fix: config Clés API & MCP — wrap des champs de création au lieu du débordement desktop

- le partage EST l'autorisation: plus de 403 'Accès refusé à la vault' pour un
  destinataire sans accès au vault émetteur (api_file, raw, download)
- chemin virtuel canonique Partage/<token>/<nom> — désambiguïse les homonymes,
  fallback par nom conservé
- 'reçu' = partagé_avec contient l'utilisateur: un admin ne voit plus les
  partages des autres comme reçus (fix File not found: Partage/…)
- +3 tests (14 total)

.gitea/workflows/ci.yml

@@ -39,6 +39,7 @@ jobs:
         run: |
           node tests/frontend/unit.test.mjs
           node tests/frontend/navfacets.test.mjs
+          node tests/frontend/desktop-roots.test.mjs
           node tests/frontend/image-viewer.test.mjs
           node tests/frontend/pdf-viewer.test.mjs
           node tests/frontend/forge-completion.test.mjs
@@ -71,6 +72,7 @@ jobs:
             node upload.test.mjs
             node config-ai-keys.test.mjs
             node xlsx-viewer.test.mjs
+            node filechat.test.mjs
           else
             echo "tests/frontend/node_modules missing - installing jsdom"
             npm install --no-audit --no-fund --silent
@@ -92,6 +94,7 @@ jobs:
             node upload.test.mjs
             node config-ai-keys.test.mjs
             node xlsx-viewer.test.mjs
+            node filechat.test.mjs
           fi
 
   # ── Tests ─────────────────────────────────────────────────────────
@@ -180,13 +183,22 @@ jobs:
         # pypdf>=6.16.1 (BUG-093).
         # CVE-2026-97687 / CVE-2026-97688 / CVE-2026-97689 (urllib3 2.7.0)
         # corrigés par le plancher urllib3>=2.8.0.
+        # CVE-2026-104874 (multidict 6.7.x) corrigé par le plancher
+        # multidict>=6.9.1 (transitive aiohttp/yarl ; 6.7.x est dans la
+        # toolcache de l'image du runner — même piège « already satisfied »).
+        # CVE-2026-85394 (python-jose ≤3.5.0, forgery HS256 par clé publique
+        # DER passée comme secret HMAC) : AUCUN correctif upstream (projet
+        # sans release depuis 2025). Non atteignable dans ObsiGate :
+        # jwt.decode passe toujours algorithms=["HS256"] et un secret
+        # symétrique serveur (backend/auth/jwt_handler.py,
+        # backend/mcp/confirmations.py) — jamais une clé publique comme clé.
         # Ces planchers doivent rester *au-dessus* des versions préinstallées
         # dans la toolcache de l'image du runner : en dessous, pip répond
         # « already satisfied » et n'aligne jamais (c'est exactement ce qui a
         # fait échouer ce job). Le garde-fou tests/test_ci_workflow.py::
         # TestDependencySecurityFloors verrouille ces planchers.
         # NOTE runner Gitea Act (BUG-083) : aucun `#` dans le `run:`.
-        run: pip-audit --ignore-vuln PYSEC-2026-1325
+        run: pip-audit --ignore-vuln PYSEC-2026-1325 --ignore-vuln CVE-2026-85394
 
   # ── Docker build ──────────────────────────────────────────────────
   build:

.gitignore

@@ -44,6 +44,7 @@ test_dir/video/
 test_vault/images/
 test_vault/markdown/
 test_vault/budget.xlsx
+test_home/
 
 # Tauri updater signing keys (private key — never commit)
 desktop/*.key

CHANGELOG.md

@@ -6,7 +6,7 @@ Format basé sur [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/),
 et [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 > **En cours de développement** : les changements à venir sont listés dans la section
-> [Unreleased](#unreleased). La dernière version livrée est **2.49.2**.
+> [Unreleased](#unreleased). La dernière version livrée est **2.68.1**.
 
 ---
 
@@ -14,6 +14,891 @@ et [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [2.68.1] — 2026-10-14
+
+### Corrigé
+
+- **UI configuration — boîtes d'édition « Clés API & MCP »** : la rangée de
+  création de clé (nom / expiration / portée / vaults / bouton) débordait de la
+  section sur desktop — `flex-wrap: wrap` n'était appliqué qu'en mobile
+  (≤768px). Le `flex-wrap` est désormais global sur `.config-add-row`, les
+  champs passent en `flex: 1 1 140px` (avec `width: auto !important` pour
+  neutraliser les largeurs inline 180/140/150/200px) et le bouton en
+  `flex: 1 1 auto` : les composants passent à la ligne au lieu de déborder.
+  Vérifié aux viewports 1600 / 1100 / 900 px (overflow horizontal : 0).
+
+---
+
+## [2.68.0] — 2026-10-14
+
+### Ajouté
+
+- **#197 - Listes de fichiers : `mtime` + `size` pour réconciliation externe (Gitea #4)**
+  - `GET /api/vault/{vault}/paths` expose `size`/`mtime`/`mtime_iso` par fichier
+    (index, même contrat que `list_all_files`) ; `GET /api/browse/{vault}` expose
+    `modified`/`modified_iso` ; outil MCP `list_directory` aligné.
+  - `PUT /api/file/{vault}/save` rafraîchit l'index en synchrone (read-after-write).
+  - Fiche `docs/features/tiktak-integration-197-200.md`, guide API_REST §5, tests
+    `tests/test_sync_lists.py` (7).
+- **#198 - Webhooks : filtre `vault` / `path_prefix` + `file_modified` émis (Gitea #3)**
+  - Filtres optionnels par webhook (sans filtre = tout, comme avant) ; `POST`/`PATCH`/
+    `GET /api/webhooks` les gèrent ; `PUT …/save` émet `file_modified`.
+  - UI : champs filtre + badge, aide intégrée FR/EN à jour ; tests
+    `tests/test_webhook_filters.py` (10).
+- **#199 - Clés API à portée limitée : vaults + périmètre `files` (Gitea #2)**
+  - `POST /api/auth/tokens` accepte `vaults?` + `scope` (`full`|`files`) ; 403 hors
+    vault (REST + MCP) et hors périmètre (`TokenScopeMiddleware`, outils
+    `token_scope_denied`, `list_tools` filtré) ; UI + i18n FR/EN ; clés existantes
+    inchangées (`full`). Guides API_REST (§2.3) / MCP ; tests
+    `tests/test_scoped_tokens.py` (13).
+- **#200 - Runbook de provisionnement du vault « TikTak » (Gitea #1)** — procédure
+  d'exploitation + recette `curl` dans la fiche feature (reste à exécuter sur l'hôte).
+
+### Corrigé
+
+- **BUG-112** — `pwsh -File scripts/e2e-server.ps1 2>&1 | head -n 20` ne se
+  terminait jamais : `Start-Process` laissait uvicorn hériter des handles
+  stdout/stderr du pwsh parent, le pipe vers `head` restait ouvert tant que le
+  serveur (immortel par design) vivait. Le serveur, lui, était prêt en ~7 s.
+  `scripts/e2e-server.ps1` lance désormais uvicorn via `Win32_Process.Create`
+  (WMI), processus détaché sans handle hérité ; les variables `OBSIGATE_*` sont
+  passées dans la ligne `cmd /c` via `set "NOM=valeur"` (le processus WMI
+  n'hérite pas de l'environnement du parent). Vérifié : commande en 6,9 s,
+  serveur up avec les 2 fixtures, `stop`/`status` OK.
+
+- **#197** — `update_single_file`/`remove_single_file` recevaient des chemins relatifs
+  au vault alors qu'ils exigeaient un absolu : le rafraîchissement d'index
+  post-écriture était un no-op silencieux (masqué par le watcher en production).
+  Les deux formes sont désormais acceptées.
+
+---
+
+## [2.67.2] — 2026-10-10
+
+---
+
+## [2.67.1] — 2026-10-10
+
+---
+
+## [2.67.0] — 2026-10-10
+
+### Ajouté
+
+- **#196 — Partage dirigé (itération 2 : visibilité & recherche)**
+  - Icône « partagé » (share-2 bleu) dans l'arborescence sur tout fichier
+    porteur d'un partage actif (créé ou reçu).
+  - Dossier virtuel **Partage** à la racine du dossier personnel du
+    destinataire : documents reçus listés avec l'icône de partage et
+    « Partagé par X » en infobulle ; ouverture en lecture seule via la page
+    de partage.
+  - Les documents reçus sont **cherchables** : la recherche plein texte
+    couvre les partages dirigés reçus (résultats `home-<user>/Partage/…`,
+    clic → page de partage, jamais l'éditeur du vault d'autrui).
+  - Cache d'icônes partagé invalidé à la création/révocation.
+  - **Itération 3 :** correction « Directory not found: Partage » (le dossier
+    virtuel ne déclenche plus la navigation) ; un fichier reçu s'ouvre dans
+    l'application en onglet — arbre, recherche et dashboard — via résolution
+    serveur `home-<user>/Partage/<fichier>` vers le fichier source
+    (`/api/file`, raw, download) ; un `path` vide/null est rejeté (400) à la
+    création d'un partage.
+  - **Itération 4 :** correctifs d'ouverture — « Accès refusé à la vault … »
+    (le partage dirigé est l'autorisation, l'ACL du vault source est
+    court-circuitée après résolution `Partage/…`), « File not found:
+    Partage/… » (les partages non adressés à l'utilisateur ne s'affichent
+    plus comme reçus ; chemin canonique `Partage/<token>/<nom>` pour
+    désambiguïser les fichiers homonymes).
+
+---
+
+## [2.66.0] — 2026-10-10
+
+### Ajouté
+
+- **#196 — Partage dirigé entre utilisateurs**
+  - Un utilisateur peut partager un document à un ou plusieurs comptes
+    précis (champ destinataires dans le dialogue de partage, noms séparés
+    par des virgules) : les pages `/s/{token}` (+ PDF, téléchargement brut)
+    exigent alors une session et n'acceptent que le créateur, les admins et
+    les destinataires — 404 opaque sinon (l'existence d'un token dirigé
+    n'est pas confirmable de l'extérieur).
+  - Dashboard : les partages reçus s'affichent avec « Partagé par X » et
+    s'ouvrent en lecture seule via la page de partage ; pas de bouton
+    révoquer pour un destinataire.
+  - Rétrocompatible : les partages publics existants (sans destinataires)
+    restent accessibles anonymement.
+
+### Sécurité
+
+- **#196 — `GET /api/shares` scopé** : un utilisateur non-admin ne voit plus
+  TOUS les partages de l'instance, mais uniquement ceux qu'il a créés ou
+  reçus (fuite préexistante, intenable avec le partage user-to-user). La
+  révocation d'un partage est réservée à son créateur ou à un admin.
+  - i18n FR/EN (7 nouvelles clés), tests `tests/test_directed_shares.py` (9),
+    fiche `docs/features/directed-shares-196.md`.
+
+---
+
+## [2.65.2] — 2026-10-10
+
+### Corrigé
+
+- **BUG-111 — Admin : icône de fermeture + navigation du tableau de bord**
+  - La modale « Administration — Utilisateurs » ouverte depuis la page `/admin` n'affichait pas l'icône du bouton fermer (lucide absent de `admin.html`) — même version du script UMD que `index.html` ajoutée.
+  - Le tableau de bord admin affiche désormais **une seule section** à la fois (état initial : hash de l'URL ou « Statistiques temps réel ») au lieu des 4 sections empilées.
+
+---
+
+## [2.65.1] — 2026-10-10
+
+---
+
+## [2.65.0] — 2026-10-10
+
+### Ajouté
+
+- **#194 (UI) — Dossier personnel visible dans l'arborescence**
+  - Les vaults `home-<user>` s'affichent **en premier** dans l'arborescence de
+    la barre latérale (tri stable appliqué à la source, `frontend/js/sidebar.js`,
+    donc aussi les sélecteurs de vault).
+  - Icône **maison** lucide (`data-lucide="home"`, même style/`stroke:
+    currentColor` que les autres icônes) via `getVaultIcon()` —
+    `frontend/js/viewer.js`.
+  - `docker-compose.test-win.yml` : montage `test_home:/vaults/Home` +
+    `OBSIGATE_HOME_ROOT=/vaults/Home` pour tester la feature en local
+    (dossier `test_home/` ignoré par git).
+  - Tests : `sidebar-filters.test.mjs` +2 (icône maison pour `home-*`,
+    gemme violette inchangée ailleurs).
+
+### Corrigé
+
+- **#194 — Un dossier perso n'est plus visible par les autres comptes**
+  - `check_vault_access` (`backend/auth/middleware.py`) refuse désormais tout
+    vault `home-*` qui n'est pas **explicitement** octroyé au compte : le
+    `vaults: ["*"]` de l'admin ne couvre plus les dossiers persos (avant,
+    l'admin voyait `home-<user>` de chaque utilisateur dans sa barre latérale).
+  - Les filtres `« * »` écrits en dur dans les routes ont été remplacés par
+    cet appel unique — dashboard, conflits, liens retour, favoris,
+    abonnements push : partout la même règle.
+  - `/api/search` filtre les résultats par vault accessible **avant**
+    pagination (`search_vaults(is_allowed=…)`), sinon les notes personnelles
+    d'un autre pouvait apparaître dans les résultats.
+  - `_grant` octroie désormais le home aussi aux comptes `« * »` : l'admin
+    voit **son** `home-admin`, réparé au démarrage pour les comptes existants.
+  - Tests : `test_user_home.py` +2 (`« * »` sans homes, filtrage de la
+    recherche), assertion API inversée dans `test_auth_api.py`.
+
+---
+
+## [2.64.0] — 2026-10-10
+
+### Ajouté
+
+- **#194 — Dossier personnel par utilisateur**
+  - Chaque utilisateur créé reçoit `<OBSIGATE_HOME_ROOT>/<username>` (ex.
+    `/NFS/OBSIDIAN_DOC/Home/<user>` côté hôte) monté comme un vault propre
+    `home-<user>` : l'isolation utilise l'**ACL par vault existante**
+    (`check_vault_access`), sans nouvelle ACL par chemin.
+  - `backend/user_home.py` : `ensure_user_home()` idempotent (mkdir + registre
+    vault + watcher + octroi dans `user.vaults`), appelé à la création d'un
+    compte (`POST /api/auth/admin/users`) **et** au démarrage
+    (`ensure_all_user_homes()` : migration des users existants + réparation
+    d'un dossier ou d'un registre perdu).
+  - **Registre persistant des vaults dynamiques** `data/vaults.json`
+    (`load_vault_config()` le fusionne avec les env `VAULT_N_*`) : auparavant,
+    tout vault ajouté à la volée (`/api/vaults/add`) disparaissait au premier
+    reindex complet et au redémarrage.
+  - Suppression d'un compte → vault refermé (index/watcher/registre) mais
+    **dossier conservé** (aucune perte de données).
+  - Correctif : `reload_single_vault` remet la config du vault après
+    `remove_vault_from_index` (sinon le vault disparaissait de
+    `vault_config` jusqu'au rechargement complet).
+  - Déploiement : montage unique `/NFS/OBSIDIAN_DOC/Home:/vaults/Home` +
+    variable `OBSIGATE_HOME_ROOT` (fonctionnalité inactive sans cette
+    variable — dev, tests, desktop inchangés).
+  - Tests : `tests/test_user_home.py` (10) + 2 tests API dans
+    `test_auth_api.py` (provisionnement, isolation, retrait).
+
+---
+
+## [2.63.0] — 2026-10-09
+
+### Ajouté
+
+- **#193 — Chat : un post s'affiche comme un document markdown**
+  - Le rendu vient du **serveur** : `backend/file_chat.py` ajoute un champ
+    `html` à chaque message en réutilisant le pipeline des documents
+    (`backend/render.py::_render_markdown` → mistune + wikilinks + masquage des
+    secrets + **sanitizer BUG-021**). Pas de second moteur markdown côté client,
+    donc pas de nouvelle surface XSS.
+  - Titres, listes, tableaux, citations, notes, listes de tâches et **blocs de
+    code colorés** : le front injecte le HTML dans un `.md-content` puis passe
+    `safeHighlight()` (highlight.js + alias de langages) sur chaque `pre code`,
+    exactement comme la visionneuse de documents.
+  - Le `html` est calculé **à la lecture** (et à l'ajout, pour l'écho SSE) :
+    rien n'est persisté dans `data/chats/*.json`, un message reste du texte.
+  - Repli conservé : sans `html`, le texte brut + liens cliquables s'affichent
+    comme avant ; un échec de rendu n'emporte jamais le message.
+  - CSS : `.file-chat-md` annule le `pre-wrap` de la bulle (sinon les retours à
+    la ligne du HTML source devenaient des lignes vides) et compacte
+    `.md-content` (tailles, `pre`/`table` défilants) pour une bulle de chat.
+  - Tests : pytest `TestMarkdownRendering` +7 (54 → **61** dans
+    `test_file_chat.py`), JSDOM `filechat.test.mjs` +2 (25 → **27**).
+
+---
+
+## [2.62.0] — 2026-10-09
+
+### Modifié
+
+- **BUG-110 — Chat : refonte visuelle des posts et des indicateurs**
+  - **Pièces jointes image** : boutons **icônes seules** (24 px, `aria-label`)
+    rangés **sous l'image**, alignés à droite — télécharger, ouvrir.
+  - **Clic sur une image = onglet de l'app** : le clic (ou le bouton « ouvrir »)
+    affiche la pièce jointe dans un **onglet**, avec le même visualiseur que les
+    images de vault (zoom/pan/plein écran/lightbox) — plus d'ouverture dans un
+    onglet du navigateur. `TabManager.openChatImage()` + branche `chatImage` de
+    `activate()` ; `renderImageViewer()` accepte une `url` directe (une pièce
+    jointe de chat ne vit pas dans un vault).
+  - **Indicateur de non-lus** : point de couleur pulsant sur l'icône « Chat » de
+    la sidebar tant qu'il reste des messages non lus, en plus du badge chiffré.
+  - **Notification OS** : quand l'app n'est pas au premier plan (`document.hidden`
+    ou hors focus), un message entrant déclenche une notification navigateur
+    (titre « Nouveau message de {user} », aperçu du texte, clic → retour sur
+    l'app). Permission demandée au premier clic d'ouverture du chat.
+  - **Suppression réellement annulable** : le `DELETE` est **différé de 10 s** ;
+    la ligne passe à « Ce message a été supprimé » avec un bouton « Annuler » qui
+    réarme le message, et un échec réseau le rend. (L'ancien « Annuler »
+    restaurait une copie DOM d'un message déjà détruit côté serveur.)
+  - i18n FR/EN : `chat.deleted_message`, `chat.undo`, `chat.download_image`,
+    `chat.view_image` — clés mortes retirées (`chat.undo_success`,
+    `chat.undo_error`, `chat.new_messages_indicator`).
+  - Tests : `tests/frontend/filechat.test.mjs` 19 → **25** (6 tests #110).
+
+---
+
+## [2.61.0] — 2026-10-08
+
+### Ajouté
+
+- **#192 - Chat : boîte de saisie auto-agrandissante + accusé de réception**
+  - **Saisie auto-agrandissante** : la boîte d'envoi (panneau document +
+    sidebar) est un `textarea` dont la hauteur suit le contenu (plafond
+    160 px puis défilement) — on relit son message entier avant l'envoi.
+    `Entrée` envoie, `Maj+Entrée` saute une ligne, la hauteur repasse à une
+    ligne après l'envoi.
+  - **Accusé de réception** : chaque conversation stocke
+    `{utilisateur: dernier_ts_de_lecture}` ; l'expéditeur voit **✓ envoyé**
+    puis **✓✓ lu** sur ses propres messages (un message est lu dès qu'un
+    *autre* participant ouvre la conversation). Le `GET` d'historique renvoie
+    la carte de lecture, `POST /api/chat/read` la met à jour et la diffuse
+    en SSE (`chat_read`) — les indicateurs basculent en direct.
+  - **Notification** : quand un message passe à ✓✓, l'expéditeur reçoit le
+    toast « {user} a lu votre message » (FR/EN) ; un message reçu pendant
+    l'affichage du canal accuse réception aussitôt.
+  - Verrou global sur le read-modify-write du store de chat (une lecture ne
+    peut plus faire disparaître un message).
+  - Tests : pytest `TestReadReceipts` (7) + JSDOM `filechat.test.mjs` +3
+    (19).
+
+### Corrigé
+
+- **BUG-109 - Tuile de lien : l'image de la carte ne s'affichait jamais** —
+  la CSP (`img-src 'self' data: blob:`) bloque toute `og:image` distante et
+  les images relatives étaient résolues contre l'origine d'ObsiGate (404).
+  La vignette est désormais téléversée à l'envoi dans `chat_uploads`
+  (`/api/chat/attachment/<uuid>`, même origine, garde SSRF + plafond 2 Mo +
+  allow-list d'extensions) ; échec du téléchargement → carte conservée sans
+  vignette. Les cartes déjà publiées gardent leur ancien lien (elles
+  étaient déjà muettes).
+
+---
+
+## [2.60.0] — 2026-10-08
+
+---
+
+## [2.59.0] — 2026-10-08
+
+### Ajouté
+
+- **#191 - Chat : suppression de post, messages privés, boîte compacte, link preview**
+  - **Suppression d'un post** : bouton 🗑 sur ses propres messages (et sur
+    tout le monde pour un admin), confirmation, `DELETE /api/chat/{id}` et
+    `/api/chat/dm/{user}/{id}`, retrait en direct chez tous les clients
+    (SSE `chat_deleted`).
+  - **Messages privés 2 utilisateurs** : rangée de canaux au-dessus du fil
+    (« Général » + un bouton par utilisateur), conversations isolées
+    (vault `__dm__`, chemin `alice|bob` trié), placeholder dédié,
+    compteurs de non-lus par canal, `GET /api/chat/users` pour la liste
+    des destinataires (sans hash/mot de passe, sans soi-même).
+  - **Boîte d'édition compacte** : bouton d'envoi réduit à une icône
+    (panneau document + sidebar), la saisie garde toute la largeur.
+  - **Link preview** : métadonnées OpenGraph récupérées à l'envoi
+    (titre, description, image, site), carte cliquable esthétique,
+    garde SSRF réutilisée (host privé/loopback rejeté), cache borné
+    200 entrées, échec silencieux (URL morte → le message passe sans carte).
+  - Tests : pytest +13 (45 au total file_chat), JSDOM `filechat.test.mjs`
+    +5 (16).
+
+---
+
+## [2.58.0] — 2026-10-08
+
+### Ajouté
+
+- **#190 - Chat : suivi du document, chat général en onglet sidebar**
+  - **Suivi du document** : le panneau du chat affiche le document ciblé
+    (titre + chemin au survol) et **suit automatiquement** le document
+    rendu — changer de fichier re-cible le panneau ouvert.
+  - **Onglet « Chat »** (dernier, après Historique IA) dans la sidebar :
+    conversation générale non liée à un fichier, **indicateur de messages
+    non lus** (pastille rouge sur l'onglet), **pièces jointes image/vidéo**
+    (upload avec allow-list d'extensions, 25 MB max, nom UUID), **URL
+    cliquables** dans les messages, date/heure d'envoi.
+  - **Ordre des onglets** : la barre de filtre passe **sous** les onglets
+    et sert de **recherche dans le chat** quand l'onglet Chat est actif
+    (texte + auteur).
+  - Backend : `GET/POST /api/chat`, `POST /api/chat/upload`,
+    `GET /api/chat/attachment/{name}` (même store #169 via les sentinelles
+    `__global__/general`), broadcast SSE `chat_message` réutilisé.
+  - Tests : pytest +12 (27 au total), JSDOM `filechat.test.mjs` +5 (11).
+
+---
+
+## [2.57.1] — 2026-10-08
+
+---
+
+## [2.57.0] — 2026-10-08
+
+### Ajouté
+
+- **#169 - Chat intégré par fichier**
+  - Bouton **💬 Chat** dans la barre d'actions du document : ouvre un panneau
+    latéral avec l'historique de la discussion et la saisie d'un message.
+  - Persistance par fichier (`data/chats/`, plafond 500 messages, texte
+    tronqué à 4000 caractères) ; routes `GET/POST /api/file/{vault}/chat`
+    protégées (auth + accès vault + contrôle de traversal).
+  - Temps réel via le transport SSE existant (événement `chat_message`) :
+    le panneau ouvert s'incrémente en direct, **toast de notification**
+    « Nouveau message de … » si le panneau est fermé ou affiche un autre
+    fichier (pas de doublon côté émetteur).
+  - Mobile : panneau plein écran ; i18n FR/EN.
+  - Tests : pytest `test_file_chat.py` (15) + JSDOM `filechat.test.mjs` (6),
+    ajoutés au pipeline CI.
+
+---
+
+## [2.56.0] — 2026-10-08
+
+### Ajouté
+
+- **#189 - Tableur : mise en page mobile (barres repliées, grille prioritaire)**
+  - Sur mobile (≤ 768 px), la **barre de menus** (Fichier, Modifier…), le
+    **ruban** de formatage et le **groupe Recherche** sont **repliés par
+    défaut** : la barre des feuilles et la **barre de formule (fx)** restent
+    toujours visibles, et la grille récupère la hauteur d'écran perdue
+    (l'ensemble dépassait 50 % de l'écran).
+  - Un **bouton unique** (`#xlsx-tools-toggle`, icône ☰) dans la barre des
+    feuilles déplie/replie le tout (`aria-expanded`, état actif) ; sur
+    desktop il reste masqué et rien ne bouge.
+  - **Ergonomie tactile** : cibles ≥ 44 px (boutons, menus, onglets), groupes
+    du ruban qui s'enroulent au lieu de déborder à cette taille, onglets de
+    feuilles sur une seule ligne qui **défile horizontalement**, champs de la
+    barre de formule en 16 px (pas de zoom iOS au focus), barre de formule qui
+    passe en 2 lignes quand les outils sont ouverts.
+  - Tests : JSDOM `xlsx-viewer.test.mjs` (bascule + règles CSS, 165/165) et
+    E2E mobile (repli par défaut, dépliage, ruban sans débordement, cibles
+    44 px).
+
+---
+
+## [2.55.0] — 2026-10-08
+
+### Ajouté
+
+- **#188 - Secrets masqués : couverture universelle + clic pour copier**
+  - **Détection élargie** (`backend/secret_redactor.py`) : les formats de
+    clés les plus répandus sont masqués d'office — OpenAI/Anthropic/
+    OpenRouter (`sk-`), Stripe (`sk_live_`, `whsec_`), GitLab (`glpat-`),
+    GitHub (`ghp_`, `github_pat_`), Google (`AIza…`, `ya29.`), AWS
+    (`AKIA`/`ASIA`), Slack (`xoxb-`), SendGrid, Hugging Face, npm, Docker,
+    Resend, Square, Atlassian, Discord, Telegram, jetons `Bearer …` — en
+    plus des JWT, clés privées et connection strings déjà couverts ; le
+    plancher des affectations `api_key=`/`token=`/`secret=` passe de 20 à
+    8 caractères.
+  - **Mots de passe masqués à leur tour** : `password=`, `"passwd": "…"`,
+    `db_password=`, `passphrase=`, `mot de passe=`… toute longueur et
+    toute quote, avec le libellé `[MOT DE PASSE MASQUÉ]` ; `PWD=` (dossier
+    de travail shell) reste épargné.
+  - **Clic sur un masque = copie de la valeur** : l'aperçu authentifié
+    sert les masques en `<span class="secret-mask" data-secret="…">` — la
+    valeur n'apparaît jamais en clair et un clic la copie dans le
+    presse-papiers (toast + infobulle FR/EN). Les masques passent par des
+    placeholders qui survivent à la conversion markdown (blocs de code
+    compris), où un `<span>` serait affiché en toutes lettres ; les blocs
+    de code masqués ne sont plus re-colorés (highlight.js perdrait le
+    badge).
+  - **Aucune fuite à l'extérieur** : partages publics, exports PDF et
+    contexte IA / MCP ne reçoivent que le libellé, jamais la valeur.
+  - Guide in-app FR/EN + `docs/GUIDES/AUTHENTIFICATION_SECURITE.md`
+    (nouvelle section « Secrets masqués dans les aperçus »), README FR/EN,
+    tests `TestSecretRedactor` (+33).
+
+---
+
+## [2.54.0] — 2026-10-08
+
+### Ajouté
+
+- **#186 - Création d'un fichier Excel depuis « Créer un fichier »**
+  - **Excel (`.xlsx`) fait partie des types proposés** dans la modale « Créer un
+    fichier » (menu contextuel d'un vault ou d'un dossier, palette de commandes) :
+    le classeur s'ouvre directement dans la visionneuse, prêt à être saisi. Les 10
+    libellés du sélecteur passent en i18n FR/EN (`modal.ext_*`) — ils étaient
+    codés en dur en français.
+  - **Un vrai classeur, pas un fichier vide.** Un `.xlsx` est une archive OPC, pas
+    du texte : `create_file()` construit désormais l'archive avec openpyxl (une
+    feuille `Feuille1`) au lieu d'écrire la charge utile vide de la modale, qui
+    aurait produit un fichier que ni la visionneuse ni Excel n'ouvrent. Le champ
+    `content` est ignoré pour cette extension.
+
+- **#183 — Panneau de sélection de couleurs façon Google Sheets (texte et fond)**
+  - Le ruban et le menu **Mise en forme** n'utilisent plus le sélecteur natif :
+    ils ouvrent un **panneau** conforme à la description fournie —
+    *Réinitialiser* en en-tête, palette **8 × 10** (ligne 1 = 8 nuances de gris
+    du noir au blanc, lignes 2 à 10 = 8 teintes × 9 nuances du clair au foncé),
+    section **STANDARD** (8 couleurs prédéfinies) avec crayon, section
+    **PERSONNALISÉ** (pastille + bouton « + » + crayon), pied de page
+    **Mise en forme conditionnelle** / **Couleurs en alternance**.
+  - Un **clic sur une pastille referme le panneau** et applique la couleur à la
+    cellule ou à la plage sélectionnée ; l'indicateur de sélection est une
+    coche **blanche ou noire selon la luminance** de la pastille.
+  - **Correction d'un piège d'encodage** : la palette est calculée en HSL pour
+    la lisibilité mais sort en **`#rrggbb`**. Une valeur `hsl(...)` était
+    silencieusement rejetée par `normHex()` — la couleur n'était donc jamais
+    écrite sur la cellule.
+  - Le chrome du panneau suit le **thème actif** (variables CSS uniquement) ;
+    « + » et les crayons ouvrent le sélecteur natif pour une couleur
+    arbitraire.
+  - Les deux entrées de pied de page sont **annoncées mais pas encore
+    disponibles** : elles affichent un message explicite plutôt qu'un bouton
+    inerte.
+
+
+### Modifié
+
+- **#185 - Tableur : barre de menus Google Sheets, boutons façon Sheets, grille unie**
+  - **Les dix menus de Google Sheets sont là** : Fichier, Modifier, Affichage,
+    Insertion, Format, Données, Outils, Gemini, Extensions, Aide — dans l'ordre
+    et avec les libellés exacts de Sheets (161 entrées). Le nouveau module
+    `frontend/js/xlsx/menus.js` décrit l'arborescence, `viewer.js` ne fait que
+    brancher chaque entrée sur un flux existant. Les sections imbriquées
+    (Nombre, Thème, Alignement, Zoom, Nettoyage…) sont des **accordéons**, une
+    seule ouverte à la fois, comme dans Sheets.
+  - **La majorité des fonctions sont opérationnelles** : Partager, Télécharger
+    (original / CSV / Markdown / HTML), Imprimer, **Renommer**, **Déplacer vers
+    la corbeille**, **Historique des versions**, Détails ; Annuler, Rétablir,
+    Couper, Copier, Coller, **Collage spécial (valeurs uniquement)**,
+    **Supprimer (lignes / colonnes / contenu)**, Tout sélectionner,
+    **Rechercher et remplacer** ; **Figer** (ici / ligne / colonne), **Afficher
+    → barre de formule · grille · en-têtes · tableau de bord**, **Zoom**,
+    **Plein écran** ; Lignes / Colonnes / Cellules, Lien, Commentaire,
+    **Fonction** (curseur placé entre les parenthèses) ; Nombre, **Thème**,
+    Gras / Italique / Souligné / Barré, Taille de police, Alignement, Retour à la
+    ligne, Rotation, **Couleurs alternées**, Effacer la mise en forme ; Trier,
+    **Créer un filtre**, **Plages nommées**, **Nettoyage des données
+    (doublons / espaces superflus)**, **Diviser le texte en colonnes** ;
+    **Saisie semi-automatique**, **Accessibilité** ; Gemini (6 entrées vers
+    l'assistant IA) ; Aide, **Mises à jour**, **Raccourcis clavier**,
+    **Signaler un problème** (diagnostic copié dans le presse-papiers).
+  - **Les options qu'ObsiGate n'a pas le disent** : les 36 entrées absentes
+    (macros, Apps Script, tableaux croisés, graphiques, formulaires, modules,
+    AppSheet, Looker Studio, formation…) restent **listées** pour tenir la
+    parité demandée, mais un clic y répond « *« X » n'est pas disponible dans
+    ObsiGate* » au lieu de ne rien faire.
+  - **Le menu Fichier a quitté la barre d'onglets** pour la barre de menus, en
+    **conservant ses identifiants** (`#xlsx-file-btn`, `#xlsx-file-menu`,
+    `#xlsx-download-btn`, `#xlsx-csv-btn`) : seuls les raccourcis internes et les
+    tests bougent. Seul **Enregistrer** reste épinglé à droite des onglets.
+  - **Ruban refait façon Google Sheets** : boutons plats de 30 × 30, sans bordure
+    ni fond au repos, survol discret, état actif teinté, groupes séparés par des
+    filets verticaux. **Enregistrer** reste le seul pilier plein. Nouveau bouton
+    **grille**, synchronisé avec Affichage ▸ Afficher ▸ Grille.
+  - **Grille unie et visible** : chaque cellule est encadrée sur **les quatre
+    côtés** par **la même** ligne de 1 px, en-têtes compris (ils se distinguent
+    par leur fond, plus par une bordure plus lourde). `--grid-border` n'est plus
+    `--border`, quasi identique au fond des cellules sur la plupart des thèmes :
+    c'est désormais un `color-mix` du texte vers la surface, calculé par
+    `themes.js`, donc une seule valeur pour toute la grille et lisible sur les 15
+    thèmes comme sur les modes contraste élevé et sépia.
+
+- **#184 - Tableur : peinture de format complète, sélection de lignes/colonnes
+  multiples, grille A → Z × 1000 lignes**
+  - **Peindre le format ne ratait plus aucun cas.** L'outil copiait un
+    sous-ensemble de propriétés et **refusait** une cellule source sans mise en
+    forme explicite — donc une cellule simple vers une cellule colorée et en
+    grande taille ne produisait rien. La copie porte maintenant sur **toute** la
+    mise en forme (gras, italique, souligné, barré, couleur du texte, couleur de
+    fond, taille, alignement, valign, retour ligne, rotation, format de nombre,
+    bordures) ; une source **sans** format **réinitialise** la cible au lieu de
+    ne rien faire.
+  - **Fuite corrigée** : annuler la peinture (`Échap`, second clic) laissait le
+    gestionnaire « appliquer au prochain clic » en place — le clic suivant dans la
+    grille repeignait une vieille mise en forme. Il est maintenant désinstallé.
+  - **Sélection de plusieurs lignes / colonnes depuis les marges**, comme dans
+    Sheets et Excel : glisser sur les numéros de ligne (ou `Maj`+clic) sélectionne
+    une plage de lignes entières ; idem sur les lettres de colonne. Le
+    redimensionnement par les bords d'en-tête reste prioritaire sur ce geste.
+  - **Grille étendue à A → Z, et jusqu'à 1000 lignes**, les cellules vides
+    étant de **vraies cellules éditables**. Les colonnes sont posées d'emblée ;
+    les lignes s'ajoutent **par blocs de 100 au défilement**, et non d'un seul
+    coup : matérialiser 1000 lignes revient à ~26 000 cellules câblées par
+    feuille, ce qui épuisait le tas de la suite JSDOM. Une feuille tronquée
+    garde son chargement serveur « Charger la suite » (les lignes manquantes
+    sont des données, pas du remplissage).
+  - **Trois goulots d'étranglement levés**, sinon la grille étendue rendait
+    l'éditeur inutilisable : `findTd` faisait un `querySelector` par appel
+    (sélectionner une colonne = 26 000 requêtes) → **index de cellules** avec
+    auto-réparation ; le rafraîchissement des formules clonait 26 000 nœuds à
+    chaque frappe → **court-circuit** sur les cellules vides ; l'application des
+    styles touchait 26 000 cellules → **court-circuit** sur celles que le
+    classeur ne style pas.
+  - Marqueur `data-wired` explicite : `data-orig` valait `""` pour une cellule
+    vide, ce qui recâblait les cellules déjà câblées (double écouteur).
+
+- **#181 — Éditeur tableur : modèle de saisie Google Sheets (sélection ≠ édition)**
+  - **Deux états distincts.** Une cellule est *sélectionnée* (clic, flèches) ou
+    *en cours d'édition*, et plus les deux en même temps. Le curseur de texte
+    n'apparaît plus en sélection (`caret-color: transparent`, sans quitter
+    `contenteditable`) : on ne voit plus un curseur clignotant au clic ou aux
+    flèches.
+  - **Entrées en édition**, comme Google Sheets / Excel : **double-clic** (le
+    curseur est placé *sous le pointeur*, l'édition se fait en place), **première
+    frappe** — qui **remplace** le contenu au lieu de s'y ajouter —, ou `F2`.
+    `Alt`+flèche insère un saut de ligne, `Échap` quitte l'édition et restaure
+    la valeur.
+  - **`Entrée` contextuelle** : en édition, elle valide et déplace le focus sur
+    **la cellule du dessous** (au lieu de perdre le focus) ; en sélection, elle
+    bascule la cellule courante en mode édition. `Tab` suit la même logique.
+  - **Indicateur de sélection renforcé** : la plage est **contourée** comme dans
+    Excel / Sheets (quatre classes de bord sur les côtés réels du bloc, pas un
+    simple lavis), et les en-têtes couverts — lettres `A`, `B`… et numéros
+    `1`, `2`… — sont reflétés.
+  - Un clic simple après une édition abandonne l'état d'édition : plus de
+    curseur résiduel.
+  - **Inventaire des écarts** vs Google Sheets / Excel dressé et priorisé
+    (poignée de recopie, *remplacer*, validation de données, filtre
+    automatique, tri multi-critères, mise en forme conditionnelle, création de
+    graphiques, protection…) : [fiche #181](docs/features/xlsx-sheet-input-181.md).
+  - Tests JSDOM : `xlsx-viewer` passe de 136 à **146/146** (10 cas #181).
+
+- **#180 — Éditeur tableur : redimensionnement au curseur, grille thémée, menu
+  Fichier & barre épinglée**
+  - **Curseur de redimensionnement.** Survoler le bord d'un en-tête de colonne
+    (`A`, `B`, `C`…) ou de ligne (`1`, `2`, `3`…) affiche désormais l'icône
+    `col-resize` / `row-resize`. Le curseur par défaut des cellules
+    (`cell`) et des en-têtes (`pointer`) masquait auparavant l'indicateur, y
+    compris pendant le glissement : les en-têtes concerned sont désormais
+    miroirés en ligne et la table porte une classe de repaint
+    (`.xlsx-resize-col` / `.xlsx-resize-row`).
+  - **Grille compatible tous les thèmes.** Les jetons de grille
+    (`--grid-*`) sont dérivés du thème actif (`--surface`, `--bg-hover`,
+    `--text-primary`, `--border`, bandeau zébré en `color-mix`) : les
+    15 thèmes × 4 modes de l'application, y compris les modes générés
+    contrasté élevé / sépia et les thèmes importés, sont désormais
+    respectés, plus les couleurs figées du thème par défaut.
+  - **Menu Fichier.** Télécharger, CSV, Markdown, HTML et Imprimer sont
+    réunis dans un seul menu **Fichier**, placé à droite de la barre des
+    onglets de feuilles, avec le bouton **Enregistrer** juste à côté. Le
+    ruban conserve les commandes d'édition. Les identifiants des contrôles
+    (`#xlsx-download-btn`, `#xlsx-csv-btn`, `#xlsx-save-btn`) sont
+    inchangés.
+  - **Barre épinglée pleine largeur.** La barre de boutons est épinglée en
+    haut, au bord de la marge de la page, et l'éditeur occupe toute la
+    largeur du contenu (comme les visionneuses PDF / images / Excalidraw).
+  - **Indicateur retiré.** La pastille « Formules calculées localement »
+    disparaît : le calcul local est le comportement normal, pas une limite
+    worthy of a badge.
+
+
+### Corrigé
+
+- **#182 — Éditeur tableur : les encadrés de la sélection s'empilaient et ne
+  suivaient plus le focus**
+  - **Cause racine.** Le sélecteur CSS de nettoyage des contours de plage était
+    écrit **sans le point** (`querySelectorAll("xlsx-sel-top,…")`). En CSS, un
+    nom nu désigne une **balise** (`<xlsx-sel-top>`), pas une classe : la requête
+    ne renvoyait **rien** et aucun contour n'était jamais effacé. Les encadrés
+    restaient donc en place et s'accumulaient à chaque changement de cellule.
+    Même famille de faute sur les en-têtes reflétés (`classList.remove` appelé
+    avec un point).
+  - **Comportement corrigé** : le contour suit désormais exactement la sélection —
+    une cellule seule est encadrée, une plage est encadrée sur ses quatre bords
+    réels, et **rien ne reste** sur les cellules quittées (navigation clavier,
+    clic, changement de cellule, changement de feuille).
+  - **Écart Sheets corrigé au passage** : pendant la saisie, les flèches
+    **valident et déplacent** la sélection (auparavant elles déplaçaient le
+    curseur dans le texte et la cellule semblait figée). `Alt`+flèche conserve
+    l'insertion d'un saut de ligne.
+  - Non-régression : `xlsx-viewer` passe de 149 à **152/152** (3 cas #182).
+
+- **#182 — Éditeur tableur : la sélection multiple ne se désélectionnait plus, et
+  les couleurs paraissaient inertes sur une plage**
+  - **Cause racine de la sélection « collée ».** La désélection reposait sur
+    l'événement `focus` de la cellule. Or `Maj`+clic appelle `preventDefault()`,
+    ce qui **empêche le navigateur de déplacer le focus** : `activeTd` et le
+    focus réel divergeaient. Un clic suivant sur la cellule déjà focalisée ne
+    déclenchait donc **aucun** `focus` et la plage restait affichée. Le clic
+    simple efface désormais la plage explicitement dans `mousedown`, sans
+    dépendre du focus ; après un `Maj`+clic le focus suit enfin la cellule
+    cliquée (sous `suppressSelectionReset`, pour ne pas écraser la plage).
+  - **Zone Nom** : après un glissement, elle affiche de nouveau la **plage**
+    (`A1:B2`) au lieu de la seule cellule d'origine (`A1`).
+  - **Couleurs sur une plage** : vérifié sur les trois chemins (menu Mise en
+    forme, nuanciers du ruban, sélection par `Maj`+flèches ou par glissement) —
+    la charge utile porte bien la plage (`A1:B2`) et les 4 cellules reçoivent
+    `color` **et** `background`.
+  - **Retour visuel manquant** : les deux nuanciers du ruban affichent désormais
+    une **pastille** qui prend la couleur choisie, ce qui donnait l'impression
+    que la couleur n'était pas appliquée.
+  - Non-régression : `xlsx-viewer` passe de 146 à **149/149** (3 cas #182).
+
+- **Visionneuse tableur / CSV : plus de ligne teintée au survol, la teinte de
+  fond est réservée aux sélections de 2 cellules et plus (Google Sheets)**
+  - Le survol ne colore **plus rien** : les règles `tr:hover` de la grille
+    XLSX (ligne entière en `--bg-hover`, y compris sur une cellule déjà
+    sélectionnée) et du tableau CSV sont retirées.
+  - Un clic simple ne change **plus le fond de la cellule** : elle ne garde que
+    son cadre accent (les quatre bords `xlsx-sel-*` + le contour
+    `xlsx-active`), comme dans Google Sheets.
+  - La teinte `.xlsx-selected` est désormais conditionnée par la classe
+    `.xlsx-range-multi`, posée/retirée sur `.xlsx-viewer` par
+    `applySelection()` selon l'étendue de la sélection — elle n'apparaît donc
+    qu'à partir de deux cellules. Les en-têtes de ligne / de colonne couverts
+    restent reflétés, comme dans Sheets.
+
+- **Visionneuse tableur : le clic droit écrasait la sélection multiple avant
+  l'ouverture du menu contextuel**
+  - **Cause.** Le `mousedown` du bouton droit laissait le navigateur déplacer
+    le focus sur la cellule ; le handler `focus` appelait `setActiveCell()` et
+    réduisait la plage à cette cellule **avant** que le menu ne s'ouvre. Les
+    entrées Copier / Coller / Effacer / Insérer / Supprimer ne s'appliquaient
+    donc plus qu'à une cellule (`Delete 1 row(s)` au lieu de
+    `Delete 2 row(s)`), et la plage disparaissait à l'écran.
+  - **Correctif.** `preventDefault()` sur le `mousedown` de bouton droit dans
+    la grille : le focus ne bouge plus, la sélection multiple survit jusqu'au
+    choix d'une option. Un clic droit **hors** plage déplace toujours la
+    sélection sur la cellule visée (comportement Sheets), via
+    `selectForTarget()` ; le clic gauche, lui, écrase toujours la plage (#182).
+  - Vérifié en conditions réelles sur l'instance Docker : la plage `A2:C3` est
+    conservée à l'ouverture du menu, le menu annonce 2 lignes / 3 colonnes, et
+    Copier place bien les 2 lignes × 3 colonnes dans le presse-papiers.
+
+- **#180 — 8 tests JSDOM réalignés** sur la sémantique « écriture verrouillée
+  puis application locale » des flux structure / mise en forme (le viewer
+  n'est plus re-lu après chaque écriture) : le second appel PUT est absent,
+  les assertions portent sur la grille peinte en place.
+
+- **Tableur — les sorties du menu Fichier étaient inertes.** Les entrées
+  Markdown, HTML et Imprimer portaient `data-xlsx-export` mais aucun
+  `data-xlsx-action`, et le répartiteur générique ne lit que ce dernier : le
+  clic ne produisait rien (les identifiants `#xlsx-download-btn` et
+  `#xlsx-csv-btn`, eux, fonctionnaient). Elles sont câblées sur
+  `export-md` / `export-html` / `print`, donc sur les fonctions déjà en place.
+
+- **Tableur — collision de classe sur `.xlsx-structure-menu`.** Les menus
+  déroulants de la nouvelle barre de menus portaient la même classe que le
+  menu Structure de la barre d'outils : toute requête `.xlsx-structure-menu`
+  tombait sur le premier nœud rencontré, donc sur un élément masqué. Les menus
+  de la barre prennent `.xlsx-menudrop` ; l'aspect reste partagé par le CSS.
+
+- **Tableur — curseur de redimensionnement absent sur la table.** La sonde
+  géométrique était conditionnée à la présence d'un en-tête sous le pointeur ;
+  sur la table elle-même aucun en-tête n'est nommé et le curseur ne
+  s'affichait pas. La table retombe désormais sur la sonde géométrique.
+
+- **Tableur — l'export emportait le quadrillage vide.** `sheetMatrix()`
+  renvoyait la grille telle que mise en page : avec les colonnes étendues à
+  A → Z, un classeur de deux colonnes exportait 26 colonnes de vide (CSV,
+  Markdown, HTML, impression). Les lignes et colonnes vides de queue sont
+  écartées — l'export porte le bloc utilisé, comme l'export d'un tableur.
+
+- **Tableur — fuite mémoire à chaque rendu.** `renderXlsxViewer()` ajoutait un
+  écouteur `click` **anonyme** sur `#content-area` : l'élément survit au
+  re-rendu et la fermeture de l'écouteur retenait la grille précédente en
+  entier. Ouvrir ou enregistrer un classeur plusieurs fois faisait croître le
+  tas sans borne. Gestionnaire nommé, démonté en tête de rendu.
+
+- **Tableur — le clic extérieur laissait le menu contextuel ouvert.** La fenêtre
+  de grâce de 250 ms, destinée au `click` résiduel d'un appui long tactile,
+  s'appliquait aussi au clic droit souris — qui n'en émet aucun : un clic
+  délibéré fait juste après l'ouverture était avalé par la grâce. Elle ne
+  couvre plus que l'ouverture tactile.
+
+- **Tableur — une entrée indisponible ne refermait pas la barre de menus.** Le
+  répartiteur annonçait « *X* n'est pas disponible dans ObsiGate » puis sortait
+  avant la fermeture : le menu restait ouvert. Tout choix referme désormais le
+  menu, y compris une entrée qui ne fait que l'annoncer.
+
+---
+
+## [2.53.3] — 2026-10-07
+
+### Corrigé
+
+- **BUG-108 - Tableur : « Coller » du menu contextuel muet**
+  - `closeContextMenu()` retirait le nœud du menu **avant** de déférencer
+    `_menu` : retirer le menu portant le focus émet un `focusout` synchrone
+    qui rappelle la fonction, et le second `remove()` sur un nœud déjà
+    démonté lève `NotFoundError` — le handler de l'action « Coller » du
+    viewer est avorté avant son exécution (régression de la fermeture au
+    focus #179 ; reproduite par l'E2E « coller une plage », CI #850-#854).
+    Déférencement avant retrait ; l'E2E passe après correctif.
+
+---
+
+## [2.53.2] — 2026-10-07
+
+### Modifié
+
+- **#187 - Assistant IA : mode agent toujours actif**
+  - Le bouton « mode agent » du panneau a été **supprimé** : l'assistant utilise
+    en permanence ses outils (lire, lister, chercher, modifier) ; la sécurité
+    est inchangée — chaque modification demande une confirmation avec aperçu.
+    Les images jointes passent toujours par l'endpoint multimodal classique.
+  - Le provider réel de l'agent est désormais résolu comme pour le chat simple
+    (l'étiquette « fournisseur · modèle » affichée est exacte), et les schémas
+    d'outils sont mis en cache (≈ 27 ms économisées par requête).
+
+---
+
+## [2.53.1] — 2026-10-04
+
+---
+
+## [2.53.0] — 2026-10-04
+
+### Ajouté
+
+- **#179 — Éditeur tableur : icônes des menus & boutons, fermeture au focus, polish mobile**
+  - Une icône Lucide par entrée (grille, Structure, Mise en forme, Export) et
+    sur les boutons Enregistrer / « + » ; suppressions marquées danger,
+    `aria-haspopup`/`aria-expanded` sur les boutons à menu.
+  - Tout menu se ferme à la perte de focus (clic extérieur, `focusout`,
+    `Échap`, défilement, redimensionnement) via `trackDismissable()` ;
+    navigation clavier (`↑`/`↓`/`Home`/`End`) dans le menu grille.
+  - Mobile : entrées ≥ 44 px (`pointer: coarse`), menus bornés au viewport,
+    ruban sans débordement horizontal.
+
+### Corrigé
+
+- **Build Docker** : `build.ps1` plaçait `--no-cache` avant `build`
+  (`unknown flag`) — flag déplacé après `docker compose -f … build`, la
+  procédure `.\build.ps1 -Test` refonctionne.
+
+---
+
+## [2.52.0] — 2026-10-04
+
+### Ajouté
+
+- **#166 — Assistant IA : détection & fusion de doublons**
+  - Score déterministe (Jaccard 70 % + titre 30 %, frontmatter exclu),
+    scan borné (500 fichiers, `truncated` exposé).
+  - Outils `find_duplicates` (READ) / `merge_duplicate_notes` (DANGEROUS,
+    backup préalable) ; API `GET /api/duplicates` et
+    `POST /api/duplicates/merge` (`confirm: true` obligatoire, stratégies
+    `append` / `prefer_target` / `prefer_source`).
+- **#168 — Assistant IA : notifications externes Discord / Telegram / SMTP / webhook**
+  - Canaux avec déclencheurs (`manual`, `schedule_failure`,
+    `schedule_success`, `duplicate_found`), secrets hors config
+    (`notify_secrets.json` 0600 ou `OBSIGATE_NOTIFY_SECRET_<ID>`), SSRF-safe.
+  - CRUD admin `/api/notify/channels`, test `/api/notify/test`,
+    outil `notify_external` (WRITE).
+- **#170 — Assistant IA : tâches planifiées type cron**
+  - Actions `create_file` / `append_to_file` / `notify` (services existants),
+    planifications `interval_hours` / `daily_time` / `once_at`, tick 60 s
+    (`OBSIGATE_SCHEDULER=0` pour désactiver), échec enregistré + notifié.
+  - API `/api/scheduler/tasks` (CRUD + `POST …/run`), outils
+    `create/list/delete/run_scheduled_task*`.
+
+---
+
+## [2.51.0] — 2026-10-03
+
+### Ajouté
+
+- **#160 — Premier lancement professionnel + section Configuration harmonisée**
+  - **Premier lancement** : `%USERPROFILE%\ObsiGate` est créé et monté comme
+    vault de démarrage (nom « ObsiGate », remplace `voute_obsidian`), le
+    contexte initial s'ouvre dessus, le dossier home reste une racine nommée
+    d'après son chemin (fin du « bruno » codé en dur), et le document
+    **`Prise en main.md`** (contenu embarqué) y est écrit une seule fois —
+    jamais écrasé.
+  - **Section « 🖥️ Vaults & dossiers (Desktop) »** refondue : lignes au motif
+    des cartes de la configuration (icône, nom, chemin tronqué), boutons
+    Retirer/Ajouter en `.config-btn-sm` secondaire/ primaire, zéro style
+    inline, variables CSS uniquement, cibles tactiles 44px en mobile.
+
+---
+
+## [2.50.2] — 2026-10-02
+
+---
+
+## [2.50.1] — 2026-10-02
+
+### Corrigé
+
+- **BUG-106 — page blanche sur `/docs`** : la CSP `script-src` sans
+  `unsafe-inline` (#87 T5c) refusait le script inline d'init de Swagger UI,
+  généré par FastAPI et jamais noncé — `SecurityHeadersMiddleware` injecte
+  désormais le nonce dans le HTML de `/docs` et `/redoc` (helper existant
+  `inject_csp_nonce`, corps ré-encodé gzip), avec 3 tests de non-régression.
+- **BUG-107 — drag & drop de fichiers inutilisable sur desktop** : Tauri/wry
+  remplaçait le gestionnaire de drag & drop du WebView2 par le sien (aucun
+  événement natif écouté) — les dépôts depuis l'Explorateur n'atteignaient
+  jamais la page. La fenêtre est désormais créée en code (`create: false`) avec
+  `disable_drag_drop_handler()` : le HTML5 drag & drop (#89) fonctionne comme
+  sur le web, avec un garde-fou de test.
+
+---
+
+## [2.50.0] — 2026-10-02
+
+### Ajouté
+
+- **#159 — Gestion desktop des vaults & dossiers** : retrait d'un vault ou dossier
+  racine par menu contextuel (« Retirer de l'application », desktop uniquement,
+  confirmation — déregistration locale, aucun fichier supprimé) et nouvelle section
+  Configuration « 🖥️ Vaults & dossiers (Desktop) » avec listes, retrait par ligne et
+  ajout de vault / dossier racine (nouvelle commande `pick_folder`, sélecteur natif
+  sans effet de bord). La jump list des raccourcis suit les ajouts et retraits de
+  vaults.
+
+---
+
+## [2.49.4] — 2026-10-02
+
+### Corrigé
+
+- **BUG-104 — commandes desktop bloquées par l'ACL Tauri** : la fenêtre desktop sert
+  sa page depuis `http://127.0.0.1` (origine *remote*) et aucune commande applicative
+  n'était déclarée — toutes étaient rejetées « not allowed by ACL », erreurs avalées
+  par `desktop.js:invoke()`. Nouveau manifeste `desktop/permissions/commands.toml`
+  (`allow-app-commands`, 19 commandes) référencé par la capability, avec un test
+  garde-fou (`test_frontend_invokes_are_acl_allowed`). Le bouton « Choisir mon
+  dossier » du wizard et toute la gestion vaults/dossiers desktop fonctionnent.
+- **BUG-105 — crash du desktop à l'ouverture (heap corruption `c0000374`)** : le
+  setter de titre du menu contextuel des raccourcis (#77) confiait un `PROPVARIANT
+  VT_LPWSTR` sur un buffer heap Rust au property store du shell, qui le libérait avec
+  l'allocateur Windows — l'application se fermait 2 à 15 s après le lancement. Fonction
+  supprimée (libellé assuré par `SetDescription`).
+
+---
+
 ## [2.49.2] — 2026-10-02
 
 ### Corrigé

Dockerfile

@@ -41,6 +41,7 @@ COPY VERSION ./VERSION
 # Using explicit UID/GID 1000 to match common host user and docker-compose settings
 RUN groupadd -g 1000 obsigate && useradd -u 1000 -g obsigate -d /app -s /sbin/nologin obsigate \
     && mkdir -p /app/data \
+    && chmod 777 /app/data \
     && chown -R obsigate:obsigate /app
 USER obsigate
 

README.fr.md

@@ -4,7 +4,7 @@
 
 **Porte d'entrée web ultra-léger pour vos vaults Obsidian** — Accédez, naviguez et recherchez dans toutes vos notes Obsidian depuis n'importe quel appareil via une interface web moderne et responsive.
 
-[![Version](https://img.shields.io/badge/Version-2.49.2-blue.svg)]()
+[![Version](https://img.shields.io/badge/Version-2.68.1-blue.svg)]()
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Docker](https://img.shields.io/badge/Docker-Ready-blue.svg)](https://www.docker.com/)
 [![Python](https://img.shields.io/badge/Python-3.11+-green.svg)](https://www.python.org/)
@@ -85,7 +85,7 @@ Les **guides d'utilisation** pas à pas se trouvent dans [`docs/GUIDES/`](docs/G
 - **🖼️ Images Obsidian** : Support complet des syntaxes d'images Obsidian avec résolution intelligente
 - **🎬 Audio & vidéo** : Lecteurs HTML5 intégrés (`.mp3 .wav .flac .mp4 .webm`…) avec streaming HTTP Range (lecture, déplacement, plein écran) et **lecture persistante** (mini-lecteur flottant / mini-fenêtre vidéo, retour au média ou arrêt à tout moment, contrôles écran verrouillé via Media Session), repli téléchargement si le format n'est pas lisible par le navigateur
 - **🎨 Diagrammes Excalidraw** : Visualiseur/éditeur natif des fichiers `.excalidraw` et `.excalidraw.md` (iframe sandboxée, auto-save, thème clair/sombre, texte des diagrammes indexé pour la recherche)
-- **📊 Tableurs Excel** : les fichiers `.xlsx` et `.xlsm` s'ouvrent dans un visualiseur dédié — un tableau par feuille avec onglets, en-têtes A1 et édition directe des cellules (`PUT /api/file/{vault}/xlsx/save`, backup automatique, écriture atomique), plus le téléchargement du fichier d'origine. Le visualiseur rend polices, couleurs, cellules fusionnées et volets figés, et offre navigation et raccourcis clavier (`Ctrl+S`, `Suppr`, `F2`, `Ctrl+Origine/Fin`, `PgPréc/PgSuiv`, `Ctrl+flèches`), barre de formule avec noms de fonctions, zone Nom éditable (« Atteindre » `A1:B3`), presse-papiers de plage (copier/couper/coller un bloc, depuis ou vers Excel), un menu **Mise en forme** (gras/italique/souligné, alignements, couleurs, formats de nombre, fusions, volets figés, largeur/hauteur — `PUT /api/file/{vault}/xlsx/style`), tri/filtre/recherche sur toutes les feuilles, export CSV/Markdown/HTML et impression (sélection ou feuille), édition de la structure (feuilles, lignes, colonnes) et un tableau de bord du classeur (plages nommées, détection graphiques/TCD, stats par feuille) ; un `.csv` s'édite dans la même grille (RFC 4180) tandis que `.xls` et `.ods` s'ouvrent en lecture seule. Les classeurs contenant des éléments qu'ObsiGate ne peut pas conserver (valeurs calculées, segments, contrôles de formulaire, signature…) affichent un **avertissement** et demandent confirmation avant l'enregistrement ; une saisie commençant par `=` ou `@` est stockée comme texte sauf activation du bouton `f(x)`, et les écritures concurrentes d'un autre poste sont détectées (`If-Match` → « Réessayer »). L'assistant IA peut lister les feuilles, injecter un tableau borné dans son contexte, rechercher dans le classeur, analyser une plage, modifier des cellules et ajouter des lignes — sur `.xlsx`, `.xlsm` et `.csv`
+- **📊 Tableurs Excel** : les fichiers `.xlsx` et `.xlsm` s'ouvrent dans un visualiseur dédié — un tableau par feuille avec onglets, en-têtes A1 et édition directe des cellules (`PUT /api/file/{vault}/xlsx/save`, backup automatique, écriture atomique), plus le téléchargement du fichier d'origine. Le visualiseur rend polices, couleurs, cellules fusionnées et volets figés, et offre navigation et raccourcis clavier (`Ctrl+S`, `Suppr`, `F2`, `Ctrl+Origine/Fin`, `PgPréc/PgSuiv`, `Ctrl+flèches`), barre de formule avec noms de fonctions, zone Nom éditable (« Atteindre » `A1:B3`), presse-papiers de plage (copier/couper/coller un bloc, depuis ou vers Excel), un menu **Mise en forme** (gras/italique/souligné, alignements, couleurs, formats de nombre, fusions, volets figés, largeur/hauteur — `PUT /api/file/{vault}/xlsx/style`), tri/filtre/recherche sur toutes les feuilles, export CSV/Markdown/HTML et impression (sélection ou feuille), édition de la structure (feuilles, lignes, colonnes) et un tableau de bord du classeur (plages nommées, détection graphiques/TCD, stats par feuille) ; un `.csv` s'édite dans la même grille (RFC 4180) tandis que `.xls` et `.ods` s'ouvrent en lecture seule. Les classeurs contenant des éléments qu'ObsiGate ne peut pas conserver (valeurs calculées, segments, contrôles de formulaire, signature…) affichent un **avertissement** et demandent confirmation avant l'enregistrement ; une saisie commençant par `=` ou `@` est stockée comme texte sauf activation du bouton `f(x)`, et les écritures concurrentes d'un autre poste sont détectées (`If-Match` → « Réessayer »). L'assistant IA peut lister les feuilles, injecter un tableau borné dans son contexte, rechercher dans le classeur, analyser une plage, modifier des cellules et ajouter des lignes — sur `.xlsx`, `.xlsm` et `.csv`. Sur mobile (≤ 768 px), la barre de menus et le ruban sont **repliés par défaut** — un bouton ☰ les déplie — pour que la grille occupe toute la hauteur d'écran
 - **🎨 Syntax highlight** : Coloration syntaxique des blocs de code
 - **🌓 Thème clair/sombre** : Toggle persisté en localStorage
 - **📡 Synchronisation temps réel** : Surveillance automatique des fichiers via watchdog avec mise à jour incrémentale de l'index
@@ -222,6 +222,7 @@ Les vaults sont configurées par paires `VAULT_N_NAME` / `VAULT_N_PATH` (N = 1,
 | `VAULT_1_PATH` | Chemin dans le conteneur | `/vaults/Obsidian-RECETTES` |
 | `VAULT_1_ATTACHMENTS_PATH` | Dossier d'attachements (optionnel) | `06_Boite_a_Outils/6.2_Attachments` |
 | `VAULT_1_SCAN_ATTACHMENTS` | Scan d'images au démarrage (défaut : true) | `true` |
+| `OBSIGATE_HOME_ROOT` | Racine des dossiers personnels (un vault `home-<user>` par compte). Absente = fonctionnalité désactivée. | `/vaults/Home` |
 
 **Règles de nommage :** lettres, chiffres et tirets uniquement ; pas d'espaces ; le nom doit correspondre au chemin dans le conteneur.
 
@@ -802,7 +803,7 @@ Configurables via l'interface (Settings) ou l'API `/api/config`.
 - **Rate limiting** : 10 tentatives de login max par IP sur 15 minutes + lockout par compte (5 tentatives)
 - **Audit log** : écritures/suppressions/config journalisées dans `data/audit.log` (JSON lines, rotation 10 MB)
 - **Backup automatique** : chaque modification/suppression sauvegardée dans `.obsigate-backup/` avec timestamp
-- **Secret redaction** : masquage automatique des JWT, clés API, tokens dans les aperçus
+- **Secret redaction** : masquage automatique des JWT, mots de passe, clés API (OpenAI, GitHub, Google, AWS, Slack, Stripe…), tokens dans les aperçus — cliquez sur un masque pour copier la valeur
 - **Utilisateur non-root** : conteneur Docker sous `obsigate` (UID 1000)
 - **Volumes read-only** : vaults montées en `:ro` par défaut
 - **Secrets dans `.env`** : jamais dans `docker-compose.yml`
@@ -976,8 +977,8 @@ Ce projet est sous licence **MIT** — voir le fichier [LICENSE](LICENSE) pour l
 
 ## 📝 Changelog
 
-Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.49.2).
+Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.68.1).
 
 ---
 
-*Projet : ObsiGate | Version : 2.49.2 | Dernière mise à jour : Septembre 2026*
+*Projet : ObsiGate | Version : 2.68.1 | Dernière mise à jour : Septembre 2026*

README.md

@@ -2,7 +2,7 @@
 
 **Ultra-light web gateway for your Obsidian vaults** — Access, browse, and search all your Obsidian notes from any device via a modern, responsive web interface.
 
-[![Version](https://img.shields.io/badge/Version-2.49.2-blue.svg)]()
+[![Version](https://img.shields.io/badge/Version-2.68.1-blue.svg)]()
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Docker](https://img.shields.io/badge/Docker-Ready-blue.svg)](https://www.docker.com/)
 [![Python](https://img.shields.io/badge/Python-3.11+-green.svg)](https://www.python.org/)
@@ -84,7 +84,7 @@ Step-by-step **user guides** live in [`docs/GUIDES/`](docs/GUIDES/):
 - **🖼️ Obsidian Images** : Full support for all Obsidian image syntaxes with intelligent resolution
 - **🎬 Audio & video** : Built-in HTML5 players (`.mp3 .wav .flac .mp4 .webm`…) with HTTP Range streaming (play, seek, fullscreen) and **persistent playback** (floating mini-player / mini video window, return to media or stop anytime, lock-screen controls via Media Session), falling back to download when the format is not playable in the browser
 - **🎨 Excalidraw Diagrams** : Native viewer/editor for `.excalidraw` and `.excalidraw.md` files (sandboxed iframe, autosave, dark/light theme, diagram text indexed for search)
-- **📊 Excel Spreadsheets** : `.xlsx` and `.xlsm` files open in a dedicated viewer — one table per sheet with tabs, A1 headers and inline cell editing (`PUT /api/file/{vault}/xlsx/save`, automatic backup, atomic write), plus download of the original file. The viewer renders fonts, colors, merged cells and frozen panes, offers keyboard navigation and shortcuts (`Ctrl+S`, `Delete`, `F2`, `Ctrl+Home/End`, `PgUp/PgDn`, `Ctrl+arrows`), a formula bar with function suggestions, an editable Name Box ("go to" `A1:B3`), a range clipboard (copy/cut/paste a block, from or to Excel), a **Format** menu (bold/italic/underline, alignments, font & fill colours, number formats, merges, frozen panes, column width/row height — `PUT /api/file/{vault}/xlsx/style`), sort/filter/find across every sheet, CSV/Markdown/HTML export and printing (selection or sheet), sheet & row/column structure editing and a workbook dashboard (named ranges, charts/pivot detection, per-sheet stats); `.csv` is edited in the same grid (RFC 4180) while `.xls` and `.ods` open read-only. Workbooks holding elements ObsiGate cannot preserve (cached values, slicers, form controls, signature…) show a **warning** and ask for confirmation before saving; a value starting with `=` or `@` is stored as text unless the `f(x)` toggle is enabled, and concurrent writes from another process are detected (`If-Match` → "Retry"). The AI assistant can list sheets, dump a bounded table to its context, search the workbook, analyze a range, update cells and append rows — on `.xlsx`, `.xlsm` and `.csv`
+- **📊 Excel Spreadsheets** : `.xlsx` and `.xlsm` files open in a dedicated viewer — one table per sheet with tabs, A1 headers and inline cell editing (`PUT /api/file/{vault}/xlsx/save`, automatic backup, atomic write), plus download of the original file. The viewer renders fonts, colors, merged cells and frozen panes, offers keyboard navigation and shortcuts (`Ctrl+S`, `Delete`, `F2`, `Ctrl+Home/End`, `PgUp/PgDn`, `Ctrl+arrows`), a formula bar with function suggestions, an editable Name Box ("go to" `A1:B3`), a range clipboard (copy/cut/paste a block, from or to Excel), a **Format** menu (bold/italic/underline, alignments, font & fill colours, number formats, merges, frozen panes, column width/row height — `PUT /api/file/{vault}/xlsx/style`), sort/filter/find across every sheet, CSV/Markdown/HTML export and printing (selection or sheet), sheet & row/column structure editing and a workbook dashboard (named ranges, charts/pivot detection, per-sheet stats); `.csv` is edited in the same grid (RFC 4180) while `.xls` and `.ods` open read-only. Workbooks holding elements ObsiGate cannot preserve (cached values, slicers, form controls, signature…) show a **warning** and ask for confirmation before saving; a value starting with `=` or `@` is stored as text unless the `f(x)` toggle is enabled, and concurrent writes from another process are detected (`If-Match` → "Retry"). The AI assistant can list sheets, dump a bounded table to its context, search the workbook, analyze a range, update cells and append rows — on `.xlsx`, `.xlsm` and `.csv`. On mobile (≤ 768 px), the menu bar and ribbon are **collapsed by default** — a single ☰ button expands them — so the grid gets the full screen height
 - **🎨 Syntax Highlight** : Syntax highlighting for code blocks
 - **🌓 Light/Dark Theme** : Toggle persisted in localStorage
 - **📡 Real-time Sync** : Automatic file monitoring via watchdog with incremental index updates
@@ -238,6 +238,7 @@ Vaults are configured using pairs of `VAULT_N_NAME` / `VAULT_N_PATH` variables (
 | `VAULT_1_SCAN_ATTACHMENTS` | Enable image scanning on startup (optional, default: true) | `true` |
 | `VAULT_2_NAME` | Display name of the vault | `IT` |
 | `VAULT_2_PATH` | Path inside the container | `/vaults/Obsidian_IT` |
+| `OBSIGATE_HOME_ROOT` | Root folder for per-user home directories (one `home-<user>` vault per account). Unset = feature disabled. | `/vaults/Home` |
 
 **Naming rules:**
 - Use only letters, numbers, and hyphens
@@ -964,7 +965,7 @@ These parameters are configurable via the interface (Settings) or the `/api/conf
 - **Rate limiting** : 10 login attempts max per IP over 15 minutes + per-account lockout (5 attempts)
 - **Audit log** : All writes, deletions, and config changes are logged in `data/audit.log` (JSON lines, 10 MB rotation)
 - **Automatic backup** : Every file modification or deletion is saved in `.obsigate-backup/` with timestamp
-- **Secret redaction** : Automatic masking of JWTs, API keys, tokens, and connection strings in previews
+- **Secret redaction** : Automatic masking of JWTs, passwords, API keys (OpenAI, GitHub, Google, AWS, Slack, Stripe…), tokens and connection strings in previews — click a mask to copy the value
 - **Non-root user** : The Docker container runs under user `obsigate` (UID 1000)
 - **Read-only volumes** : Vaults are mounted as `:ro` by default in docker-compose
 - **Secrets in `.env`** : Passwords and tokens are never in `docker-compose.yml`
@@ -1151,8 +1152,8 @@ This project is licensed under the **MIT License** - see the [LICENSE](LICENSE)
 
 ## 📝 Changelog
 
-See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.49.2).
+See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.68.1).
 
 ---
 
-*Project: ObsiGate | Version: 2.49.2 | Last updated: September 2026*
+*Project: ObsiGate | Version: 2.68.1 | Last updated: September 2026*

VERSION

@@ -1 +1 @@
-2.49.2
+2.68.1

backend/auth/jwt_handler.py

@@ -215,15 +215,37 @@ def _save_api_tokens(data: dict):
     tmp.replace(API_TOKENS_FILE)
 
 
-def create_api_token(user: dict, name: str, expiry_key: str) -> tuple[dict, str]:
+#: Endpoint perimeters accepted for scoped API tokens (#199). ``"full"``
+#: keeps today's behaviour ; ``"files"`` restricts the token to the file
+#: read/write surface (enforced by ``TokenScopeMiddleware`` on REST and by
+#: the tool registry on MCP/agent calls).
+API_TOKEN_SCOPES = ("full", "files")
+
+
+def create_api_token(
+    user: dict,
+    name: str,
+    expiry_key: str,
+    vaults: list[str] | None = None,
+    scope: str = "full",
+) -> tuple[dict, str]:
     """Create a persistent API/MCP token. Returns (record, jwt_string).
 
     ``expiry_key`` must be one of API_TOKEN_EXPIRY_CHOICES; "never" omits the
     ``exp`` claim (valid until explicitly revoked).
+
+    #199 (synchro TikTak) — optional least-privilege restriction:
+    ``vaults`` limits the token to the given vaults (``None`` = snapshot of
+    the creator's vaults, i.e. today's behaviour) and ``scope`` limits the
+    endpoint perimeter (``"full"`` or ``"files"``). Both are embedded in the
+    JWT so enforcement stays stateless; the record keeps them for display.
     """
     if expiry_key not in API_TOKEN_EXPIRY_CHOICES:
         raise ValueError("Expiration invalide")
+    if scope not in API_TOKEN_SCOPES:
+        raise ValueError("Portée invalide (full | files)")
     seconds = API_TOKEN_EXPIRY_CHOICES[expiry_key]
+    resolved_vaults = list(vaults) if vaults is not None else list(user.get("vaults", []))
     with _api_tokens_lock:
         data = _load_api_tokens()
         tokens = data["tokens"]
@@ -235,11 +257,12 @@ def create_api_token(user: dict, name: str, expiry_key: str) -> tuple[dict, str]
         payload = {
             "sub": user["username"],
             "role": user.get("role", "user"),
-            "vaults": user.get("vaults", []),
+            "vaults": resolved_vaults,
             "jti": jti,
             "iat": now,
             "type": "access",
             "api": True,
+            "scope": scope,
         }
         if seconds is not None:
             payload["exp"] = now + seconds
@@ -252,6 +275,8 @@ def create_api_token(user: dict, name: str, expiry_key: str) -> tuple[dict, str]
             "expires_at": payload.get("exp"),
             "expiry_key": expiry_key,
             "last_used_at": None,
+            "vaults": resolved_vaults,
+            "scope": scope,
         }
         tokens[jti] = record
         _save_api_tokens(data)
@@ -262,11 +287,16 @@ def list_api_tokens(username: str) -> list[dict]:
     """Token metadata for one user, newest first."""
     data = _load_api_tokens()
     now = int(time.time())
-    items = [
-        {**t, "expired": t.get("expires_at") is not None and t["expires_at"] < now}
-        for t in data["tokens"].values()
-        if t["username"] == username
-    ]
+    items = []
+    for t in data["tokens"].values():
+        if t["username"] != username:
+            continue
+        # #199 : les clés créées avant la portée limitée n'ont ni scope ni
+        # vaults stockés → portée pleine, comportement inchangé.
+        entry = {**t, "expired": t.get("expires_at") is not None and t["expires_at"] < now}
+        entry.setdefault("scope", "full")
+        entry.setdefault("vaults", None)
+        items.append(entry)
     return sorted(items, key=lambda t: t["created_at"], reverse=True)
 
 

backend/auth/middleware.py

@@ -115,6 +115,9 @@ def get_current_user(
     user["_token_vaults"] = payload.get("vaults", [])
     # Attach the token id for per-token rate limiting (AI tool layer).
     user["_token_jti"] = payload.get("jti")
+    # #199 : périmètre d'endpoints du token (défaut "full" = comportement
+    # actuel, y compris pour les clés créées avant la portée limitée).
+    user["_token_scope"] = payload.get("scope", "full")
     # Feature #107: track last usage of user-managed API/MCP tokens
     # (throttled write — this dependency runs on both REST and /mcp paths).
     if payload.get("api"):
@@ -142,6 +145,11 @@ def require_admin(current_user=Depends(require_auth)):
     return current_user
 
 
+def is_home_vault(vault_name: str) -> bool:
+    """Un dossier personnel (#194) : vault « home-<user> »."""
+    return vault_name.startswith("home-")
+
+
 def check_vault_access(vault_name: str, user: dict) -> bool:
     """Check if a user has access to a specific vault.
 
@@ -149,8 +157,13 @@ def check_vault_access(vault_name: str, user: dict) -> bool:
     - vaults == ["*"] → full access (admin default)
     - vault_name in vaults → access granted
     - otherwise → denied
+
+    #194 : un dossier personnel n'est **jamais** couvert par ``*`` — sinon
+    un admin (``vaults: ["*"]``) verrait le dossier de chaque utilisateur.
     """
     vaults = user.get("_token_vaults") or user.get("vaults", [])
+    if is_home_vault(vault_name):
+        return vault_name in vaults
     if "*" in vaults:
         return True
     return vault_name in vaults

backend/auth/router.py

@@ -946,9 +946,20 @@ async def create_user_endpoint(
         user = create_user(
             req.username, req.password, req.role, req.vaults, req.display_name
         )
-        return user
     except ValueError as e:
         raise HTTPException(400, str(e))
+    # #194 : dossier perso — best effort, réparé au démarrage si le disque
+    # (NFS) est indisponible (ensure_user_home journalise l'erreur).
+    from backend.auth.user_store import get_user
+    from backend.user_home import ensure_user_home
+
+    await ensure_user_home(req.username)
+    # La réponse doit refléter l'octroi du vault perso (#194) : create_user a
+    # renvoyé un instantané construit avant l'octroi.
+    fresh = get_user(req.username)
+    if fresh:
+        user["vaults"] = fresh.get("vaults", [])
+    return user
 
 
 @router.patch("/admin/users/{username}")
@@ -975,9 +986,13 @@ async def delete_user_endpoint(
         raise HTTPException(400, "Impossible de supprimer son propre compte")
     try:
         delete_user(username)
-        return {"message": f"Utilisateur '{username}' supprimé"}
     except ValueError as e:
         raise HTTPException(404, str(e))
+    # #194 : fermer le vault du dossier perso (le dossier est conservé).
+    from backend.user_home import release_user_home
+
+    await release_user_home(username)
+    return {"message": f"Utilisateur '{username}' supprimé"}
 
 
 # ── API / MCP tokens (feature #107) ──────────────────────────────────
@@ -988,6 +1003,8 @@ async def delete_user_endpoint(
 class CreateApiTokenRequest(BaseModel):
     name: str
     expiry: str  # 1d | 30d | 180d | 365d | never
+    vaults: list[str] | None = None  # #199 : None = vaults du créateur (comportement actuel)
+    scope: str = "full"  # #199 : "full" | "files"
 
 
 @router.get("/tokens")
@@ -1005,9 +1022,33 @@ async def create_user_token(
     request: Request,
     current_user=Depends(require_auth),
 ):
-    """Create a long-lived API/MCP token. The raw JWT is returned ONCE."""
+    """Create a long-lived API/MCP token. The raw JWT is returned ONCE.
+
+    #199 : portée optionnelle — ``vaults`` (sous-ensemble des vaults du
+    créateur, défaut = tous) et ``scope`` (``"full"`` ou ``"files"``).
+    """
+    from backend.auth.jwt_handler import API_TOKEN_SCOPES
+    from backend.auth.middleware import check_vault_access
+    from backend.indexer import index
+
+    scope = (req.scope or "full").strip().lower()
+    if scope not in API_TOKEN_SCOPES:
+        raise HTTPException(400, "Portée invalide (full | files)")
+    vaults: list[str] | None = None
+    if req.vaults is not None:
+        cleaned = sorted({v.strip() for v in req.vaults if isinstance(v, str) and v.strip()})
+        if not cleaned:
+            raise HTTPException(400, "Liste de vaults vide")
+        unknown = [v for v in cleaned if v not in index]
+        if unknown:
+            raise HTTPException(400, f"Vaults inconnus : {', '.join(unknown)}")
+        denied = [v for v in cleaned if not check_vault_access(v, current_user)]
+        if denied:
+            raise HTTPException(403, f"Accès refusé aux vaults : {', '.join(denied)}")
+        vaults = cleaned
     try:
-        record, token = create_api_token(current_user, req.name.strip(), req.expiry)
+        record, token = create_api_token(current_user, req.name.strip(), req.expiry,
+                                         vaults=vaults, scope=scope)
     except ValueError as e:
         raise HTTPException(400, str(e))
     from backend.audit import log_config_change

backend/auth/scope.py

@@ -0,0 +1,141 @@
+# backend/auth/scope.py
+# Scoped API/MCP tokens (#199, synchro TikTak — Gitea #2).
+#
+# A token may carry an endpoint perimeter in its ``scope`` JWT claim:
+# - ``"full"`` (default, and the case of every token issued before #199):
+#   no restriction — today's behaviour, unchanged ;
+# - ``"files"``: file read/write surface only (vault file CRUD, listings,
+#   search, backups read/restore). Everything else (admin, config, AI,
+#   webhooks, shares, auth management…) answers **403**.
+#
+# Vault restriction is orthogonal and needs no new machinery: a scoped token
+# embeds the allowed vault list in its ``vaults`` JWT claim, so the existing
+# ``check_vault_access`` (REST routes) and ``ToolContext.require_vault_access``
+# (MCP/agent tools) refuse other vaults with 403 — for REST *and* MCP alike.
+"""Endpoint perimeter for scoped API tokens."""
+
+from __future__ import annotations
+
+from typing import Any
+
+SCOPE_FULL = "full"
+SCOPE_FILES = "files"
+KNOWN_SCOPES = (SCOPE_FULL, SCOPE_FILES)
+
+# (methods, path prefix or exact path). ``methods`` None = any method.
+# Keep this list tight: a sync client (TikTak) needs file CRUD, listings,
+# search and backup read/restore — nothing else.
+_RULES_FOR_FILES: tuple[tuple[frozenset[str] | None, str, bool], ...] = (
+    # (methods, path, exact_only)
+    (frozenset({"GET"}), "/api/health", False),
+    (frozenset({"GET"}), "/api/auth/me", True),
+    (frozenset({"GET"}), "/api/vaults", True),
+    (None, "/api/browse/", False),
+    (None, "/api/file/", False),
+    (None, "/api/media/", False),
+    (None, "/api/directory/", False),
+    (None, "/api/move/", False),
+    (None, "/api/vault/", False),  # {vault}/files, {vault}/paths, batch-upload…
+    (frozenset({"GET"}), "/api/search", False),
+    (frozenset({"GET"}), "/api/tree-search", True),
+    (frozenset({"GET"}), "/api/suggest", False),
+    (frozenset({"GET"}), "/api/tags", False),
+    (frozenset({"GET"}), "/api/graph/", False),
+    (frozenset({"GET"}), "/api/backups", False),
+    (frozenset({"GET"}), "/docs", False),
+    (frozenset({"GET"}), "/redoc", True),
+    (frozenset({"GET"}), "/openapi.json", True),
+    (None, "/mcp", False),
+)
+
+
+def is_path_allowed_for_scope(scope: str | None, method: str, path: str) -> bool:
+    """True when a token with *scope* may call (*method*, *path*).
+
+    - ``None``/``"full"`` → everything allowed (backward compatible).
+    - ``"files"`` → allow-list above (API surface only ; static assets and
+      public pages carry no data and are handled by the caller — the
+      middleware only gates ``/api/*`` and ``/mcp*``).
+    - unknown scope → fail-closed (deny).
+    """
+    if scope in (None, SCOPE_FULL):
+        return True
+    if scope != SCOPE_FILES:
+        return False
+    if not (path.startswith("/api/") or path.startswith("/mcp")):
+        return True
+    method = (method or "GET").upper()
+    for methods, rule_path, exact in _RULES_FOR_FILES:
+        if methods is not None and method not in methods:
+            continue
+        if exact:
+            if path == rule_path:
+                return True
+        elif path == rule_path or path.startswith(rule_path):
+            return True
+    return False
+
+
+def scope_of_user(user: dict[str, Any] | None) -> str:
+    """Endpoint scope attached to an authenticated user (default ``"full"``)."""
+    if not user:
+        return SCOPE_FULL
+    return user.get("_token_scope") or SCOPE_FULL
+
+
+class TokenScopeMiddleware:
+    """Pure-ASGI middleware enforcing the endpoint perimeter of scoped tokens.
+
+    Denies out-of-perimeter calls made with a scoped token (**403**) before
+    they reach the routes. Only *adds* restrictions: the ``scope`` claim is
+    read unverified here, and the signature is still verified downstream by
+    ``get_current_user`` (an invalid token is rejected with 401 a step later
+    anyway). Full-scope and scopeless tokens pass through untouched.
+    """
+
+    def __init__(self, app: Any):
+        self.app = app
+
+    async def __call__(self, scope: Any, receive: Any, send: Any) -> None:
+        if scope.get("type") == "http":
+            method = scope.get("method", "GET")
+            path = scope.get("path", "")
+            if path.startswith("/api/") or path.startswith("/mcp"):
+                token_scope = _scope_from_asgi(scope)
+                if token_scope not in (None, SCOPE_FULL) and not is_path_allowed_for_scope(
+                    token_scope, method, path
+                ):
+                    from starlette.responses import JSONResponse
+
+                    response = JSONResponse(
+                        {"detail": "Token à portée limitée : endpoint hors périmètre 'files'"},
+                        status_code=403,
+                    )
+                    await response(scope, receive, send)
+                    return
+        await self.app(scope, receive, send)
+
+
+def _scope_from_asgi(asgi_scope: Any) -> str | None:
+    """Extract the unverified ``scope`` claim from an ASGI scope's auth."""
+    headers = {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in asgi_scope.get("headers", [])}
+    token: str | None = None
+    auth = headers.get("authorization", "")
+    if auth.lower().startswith("bearer "):
+        token = auth[7:].strip()
+    else:
+        for part in headers.get("cookie", "").split(";"):
+            name, _, value = part.strip().partition("=")
+            if name.strip() == "access_token" and value.strip():
+                token = value.strip()
+                break
+    if not token:
+        return None
+    try:
+        from jose import jwt as _jwt
+
+        claims = _jwt.get_unverified_claims(token)
+    except Exception:
+        return None
+    token_scope = (claims or {}).get("scope")
+    return token_scope if isinstance(token_scope, str) and token_scope else None

backend/bookslm_routes.py

@@ -536,18 +536,6 @@ async def api_bookslm_agent(
         # run no longer pauses on every subsequent mutating call.
         ctx.confirmed = True
 
-    async def _llm(msgs, tool_schemas):
-        return await chat_completion(
-            msgs,
-            tools=tool_schemas,
-            provider=req.provider,
-            model=req.model,
-            temperature=0.3,
-            # Tool-call arguments can carry a whole file body (e.g. a generated
-            # table): leave more room than the plain-chat default.
-            max_tokens=8192,
-        )
-
     async def generate_sse():
         import asyncio
 
@@ -561,6 +549,23 @@ async def api_bookslm_agent(
                 yield f"event: error\ndata: {error_data}\n\n"
                 return
 
+            # #187: resolve the provider like /chat does — the agent must use
+            # the same engine the SSE "provider" tag reports (the raw
+            # req.provider could name an unavailable provider and silently
+            # fall back to another one via _get_provider_config).
+            async def _llm(msgs, tool_schemas):
+                return await chat_completion(
+                    msgs,
+                    tools=tool_schemas,
+                    provider=cfg_name,
+                    model=req.model,
+                    temperature=0.3,
+                    # Tool-call arguments can carry a whole file body (e.g. a
+                    # generated table): leave more room than the plain-chat
+                    # default.
+                    max_tokens=8192,
+                )
+
             # Stream tool events live: each executed step is pushed on the
             # queue by the loop callback and emitted as soon as it happens,
             # so the UI can grow its « N steps » block while thinking.

backend/file_chat.py

@@ -0,0 +1,430 @@
+# backend/file_chat.py — historique de discussion (#169, #190)
+"""Chat history persisted under ``data/chats/``.
+
+One JSON document per ``(vault, path)`` pair, keyed by a SHA-256 of both so
+the filename never carries user-controlled path separators. Writes are
+atomic (tmp + move) and the message list is capped at
+:data:`MAX_MESSAGES` to bound growth.
+
+#190 adds the **general chat**: the same store addressed with the reserved
+sentinels (:data:`GLOBAL_VAULT` / :data:`GLOBAL_PATH`), so no second
+implementation. Messages may carry an ``attachment`` (image/video/url)
+uploaded under ``data/chat_uploads/``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import html
+import json
+import logging
+import re
+import shutil
+import threading
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+from urllib.parse import urljoin, urlparse
+
+import httpx
+
+from backend.render import _render_markdown
+
+logger = logging.getLogger("obsigate.file_chat")
+
+CHAT_DIR = Path("data/chats")
+MAX_MESSAGES = 500  # retention ceiling per file (oldest dropped first)
+MAX_TEXT = 4000  # characters per message
+
+# ponytail: global lock over read-modify-write — chat writes are HTTP-only and
+# serialized anyway, this just makes losing a message to a future thread (or a
+# watcher hook) impossible; per-file locks if it ever becomes contended.
+_LOCK = threading.RLock()
+
+# #190 — general (non file-bound) conversation, stored like any other one.
+GLOBAL_VAULT = "__global__"
+GLOBAL_PATH = "general"
+
+# #191 — private (2 users) conversations reuse the same store: the vault is
+# the reserved sentinel and the path is the sorted username pair, so the
+# storage key never depends on who asks.
+DM_VAULT = "__dm__"
+
+# #190 — attachments (image/video) live outside the vaults.
+UPLOAD_DIR = Path("data/chat_uploads")
+MAX_UPLOAD_BYTES = 25 * 1024 * 1024  # 25 MB per attachment
+ALLOWED_ATTACH_EXT = {
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg",
+    ".mp4", ".webm", ".ogg", ".mov", ".m4v",
+}
+
+# #191 — link preview fetch budget
+PREVIEW_TIMEOUT = 5.0  # seconds
+PREVIEW_MAX_BYTES = 512 * 1024  # only the head of the page is parsed
+PREVIEW_IMAGE_MAX = 2 * 1024 * 1024  # ponytail: 2 MB ceiling on a thumbnail
+
+
+def _chat_file(vault: str, path: str) -> Path:
+    """Return the chat file for *(vault, path)* (hashed, traversal-proof)."""
+    CHAT_DIR.mkdir(parents=True, exist_ok=True)
+    key = hashlib.sha256(f"{vault}\0{path}".encode()).hexdigest()[:32]
+    return CHAT_DIR / f"{key}.json"
+
+
+def _read(vault: str, path: str) -> dict[str, Any]:
+    """Load the raw chat document (empty structure when missing/corrupt)."""
+    file = _chat_file(vault, path)
+    if not file.exists():
+        return {"vault": vault, "path": path, "messages": []}
+    try:
+        doc = json.loads(file.read_text(encoding="utf-8"))
+        if not isinstance(doc.get("messages"), list):
+            raise TypeError("messages is not a list")  # caught by the handler below
+        return doc
+    except Exception as e:
+        logger.error("Failed to read chat for %s/%s: %s", vault, path, e)
+        return {"vault": vault, "path": path, "messages": []}
+
+
+def _write(file: Path, doc: dict[str, Any]) -> None:
+    """Atomically persist *doc* (tmp file + rename)."""
+    try:
+        tmp = file.with_suffix(".tmp")
+        tmp.write_text(json.dumps(doc, ensure_ascii=False, indent=1), encoding="utf-8")
+        shutil.move(str(tmp), str(file))
+    except Exception as e:
+        logger.error("Failed to write chat %s: %s", file.name, e)
+
+
+def get_messages(vault: str, path: str) -> list[dict[str, Any]]:
+    """Return the chat history for *(vault, path)* (chronological).
+
+    Every message carries its rendered ``html`` (#193): same markdown pipeline
+    as a document (mistune + sanitizer), computed on read so a template change
+    applies to the whole history without rewriting the JSON store.
+    """
+    return [_decorate(m, vault) for m in _read(vault, path).get("messages", [])]
+
+
+def _decorate(msg: dict[str, Any], vault: str) -> dict[str, Any]:
+    """Return a copy of *msg* with its sanitized markdown ``html`` (#193).
+
+    The stored message is left untouched (``html`` is never persisted). A
+    rendering failure must never break the chat: the message goes out with an
+    empty ``html`` and the client falls back to plain text.
+    """
+    try:
+        html = _render_markdown(msg.get("text", ""), vault)
+    except Exception as e:  # pragma: no cover - defensive
+        logger.warning("chat markdown rendering failed: %s", e)
+        html = ""
+    return {**msg, "html": html}
+
+
+def add_message(
+    vault: str,
+    path: str,
+    user: str,
+    text: str,
+    attachment: dict[str, Any] | None = None,
+    preview: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Append a message and persist it. Returns the stored message.
+
+    The list is capped at :data:`MAX_MESSAGES` (oldest dropped first).
+    *attachment* (#190) is ``{name, url, mime, kind}`` for image/video/url;
+    *preview* (#191) is the OpenGraph card of the first URL in *text*.
+    """
+    text = (text or "").strip()[:MAX_TEXT]
+    msg: dict[str, Any] = {
+        "id": uuid.uuid4().hex[:12],
+        "user": user or "anonyme",
+        "text": text,
+        "ts": time.time(),
+    }
+    if attachment:
+        msg["attachment"] = attachment
+    if preview:
+        msg["preview"] = preview
+    return _append(vault, path, msg)
+
+
+def _append(
+    vault: str,
+    path: str,
+    msg: dict[str, Any],
+) -> dict[str, Any]:
+    """Cap, persist and return *msg* (shared by file, global and DM chats).
+
+    The read-modify-write of the whole document happens under ``_LOCK`` so a
+    concurrent writer can never drop a message (same class of bug as
+    BUG-029 on ``users.json``).
+    """
+    with _LOCK:
+        doc = _read(vault, path)
+        messages = list(doc.get("messages", []))
+        messages.append(msg)
+        if len(messages) > MAX_MESSAGES:
+            messages = messages[-MAX_MESSAGES:]
+        doc["messages"] = messages
+        _write(_chat_file(vault, path), doc)
+    return _decorate(msg, vault)  # #193 — le html part avec l'écho SSE
+
+
+# --- #192 : accusé de réception ---------------------------------------------
+
+def get_read(vault: str, path: str) -> dict[str, float]:
+    """Return ``{username: last_read_ts}`` for a conversation (#192)."""
+    return {str(u): float(ts) for u, ts in (_read(vault, path).get("read") or {}).items()}
+
+
+def mark_read(vault: str, path: str, user: str) -> dict[str, float]:
+    """Record that *user* has seen the conversation (#192).
+
+    Returns the whole read map so the caller can broadcast it on SSE: a
+    sender learns their messages were received as soon as the recipient
+    displays the conversation.
+    """
+    if not user:
+        return get_read(vault, path)
+    with _LOCK:
+        doc = _read(vault, path)
+        read = {str(u): float(ts) for u, ts in (doc.get("read") or {}).items()}
+        read[user] = time.time()
+        doc["read"] = read
+        _write(_chat_file(vault, path), doc)
+        return read
+
+
+# --- #191 : messages privés (2 utilisateurs) -------------------------------
+
+def dm_path(user_a: str, user_b: str) -> str:
+    """Storage path for the private conversation between two users.
+
+    The pair is sorted so both participants address the same document.
+    """
+    return "|".join(sorted([user_a, user_b]))
+
+
+def get_dm_messages(user_a: str, user_b: str) -> list[dict[str, Any]]:
+    """Return the private history between two users (chronological)."""
+    return get_messages(DM_VAULT, dm_path(user_a, user_b))
+
+
+def add_dm_message(
+    user_a: str,
+    user_b: str,
+    author: str,
+    text: str,
+    attachment: dict[str, Any] | None = None,
+    preview: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Append a private message. Returns the stored message."""
+    return add_message(DM_VAULT, dm_path(user_a, user_b), author, text, attachment, preview)
+
+
+# --- #191 : suppression -----------------------------------------------------
+
+def delete_message(vault: str, path: str, message_id: str) -> bool:
+    """Remove one message from a conversation. True when it existed."""
+    with _LOCK:
+        doc = _read(vault, path)
+        messages = list(doc.get("messages", []))
+        kept = [m for m in messages if m.get("id") != message_id]
+        if len(kept) == len(messages):
+            return False
+        doc["messages"] = kept
+        _write(_chat_file(vault, path), doc)
+    return True
+
+
+# --- #190 : chat général (conversation centrale, hors fichier) -------------
+
+def get_global_messages() -> list[dict[str, Any]]:
+    """Return the general-chat history (chronological)."""
+    return get_messages(GLOBAL_VAULT, GLOBAL_PATH)
+
+
+def add_global_message(
+    user: str,
+    text: str,
+    attachment: dict[str, Any] | None = None,
+    preview: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Append a message to the general chat. Returns the stored message."""
+    return add_message(GLOBAL_VAULT, GLOBAL_PATH, user, text, attachment, preview)
+
+
+def save_attachment(filename: str, data: bytes) -> dict[str, Any]:
+    """Persist an uploaded attachment under :data:`UPLOAD_DIR`.
+
+    Returns ``{name, url, mime, kind}``. The stored name is a fresh UUID
+    (never the client name), the extension must be in
+    :data:`ALLOWED_ATTACH_EXT` and the size is capped at
+    :data:`MAX_UPLOAD_BYTES`.
+
+    Raises:
+        ValueError: extension refused, empty file or size exceeded.
+    """
+    ext = Path(filename or "").suffix.lower()
+    if ext not in ALLOWED_ATTACH_EXT:
+        raise ValueError(f"extension refusée : {ext or '(aucune)'}")
+    if not data:
+        raise ValueError("fichier vide")
+    if len(data) > MAX_UPLOAD_BYTES:
+        raise ValueError(f"fichier trop lourd (max {MAX_UPLOAD_BYTES // (1024 * 1024)} MB)")
+    UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+    name = f"{uuid.uuid4().hex}{ext}"
+    (UPLOAD_DIR / name).write_bytes(data)
+    kind = "video" if ext in {".mp4", ".webm", ".ogg", ".mov", ".m4v"} else "image"
+    return {
+        "name": name,
+        "url": f"/api/chat/attachment/{name}",
+        "mime": _MIME_BY_EXT.get(ext, "application/octet-stream"),
+        "kind": kind,
+    }
+
+
+# --- #191 : link preview ----------------------------------------------------
+
+_URL_RE = re.compile(r"https?://[^\s<>\"']+")
+_PREVIEW_CACHE: dict[str, dict[str, Any] | None] = {}
+PREVIEW_CACHE_MAX = 200
+
+
+def _og(content: str, prop: str) -> str:
+    """Extract one OpenGraph/``<title>`` value from an HTML head (regex)."""
+    for pattern in (
+        rf'<meta[^>]+(?:property|name)="{prop}"[^>]+content="([^"]*)"',
+        rf'<meta[^>]+content="([^"]*)"[^>]+(?:property|name)="{prop}"',
+    ):
+        m = re.search(pattern, content, re.IGNORECASE)
+        if m:
+            return html.unescape(m.group(1)).strip()[:300]
+    if prop == "og:title":
+        m = re.search(r"<title[^>]*>([^<]*)</title>", content, re.IGNORECASE)
+        if m:
+            return html.unescape(m.group(1)).strip()[:300]
+    return ""
+
+
+# BUG-109 — content-type → extension (the attachment allow-list decides).
+_IMG_EXT_BY_MIME = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/svg+xml": ".svg",
+}
+
+
+def _proxy_image(img_url: str, page_url: str) -> str:
+    """Download *img_url* into ``chat_uploads`` and return a same-origin URL.
+
+    The response CSP is ``img-src 'self' data: blob:``: a remote ``og:image``
+    would be blocked by the browser (BUG-109). Relative and protocol-relative
+    values are resolved against *page_url* first. Raises ``ValueError`` /
+    ``SSRFError`` on any failure — the caller keeps the card and drops only
+    the thumbnail.
+    """
+    from backend.tools.web import USER_AGENT, _assert_public_http_url
+
+    full = urljoin(page_url, img_url)
+    _assert_public_http_url(full)
+    resp = httpx.get(
+        full,
+        headers={"User-Agent": USER_AGENT},
+        timeout=PREVIEW_TIMEOUT,
+        follow_redirects=True,
+    )
+    if resp.status_code >= 400:
+        raise ValueError(f"HTTP {resp.status_code}")
+    data = resp.content
+    if not data or len(data) > PREVIEW_IMAGE_MAX:
+        raise ValueError("image vide ou trop lourde")
+    mime = (resp.headers.get("content-type") or "").split(";")[0].strip().lower()
+    ext = _IMG_EXT_BY_MIME.get(mime) or Path(urlparse(full).path).suffix.lower()
+    # save_attachment(): allow-list d'extensions + nom UUID (jamais le nom distant)
+    return str(save_attachment(f"preview{ext}", data)["url"])
+
+
+def build_preview(text: str) -> dict[str, Any] | None:
+    """Fetch OpenGraph metadata for the first URL in *text* (#191).
+
+    SSRF-guarded (reuses the web-tool guard), size/time capped, cached in a
+    bounded dict. Returns ``{url, title, description, image, site}`` or
+    ``None`` when there is no URL / the fetch fails (never raises: a dead
+    link must not block the message). ``image`` is a **same-origin**
+    ``/api/chat/attachment/...`` URL (BUG-109), empty when the thumbnail
+    could not be fetched.
+    """
+    m = _URL_RE.search(text or "")
+    if not m:
+        return None
+    url = m.group(0).rstrip(".,;:!?)")
+    if url in _PREVIEW_CACHE:
+        cached = _PREVIEW_CACHE[url]
+        return dict(cached) if cached else None
+    try:
+        from backend.tools.web import USER_AGENT, _assert_public_http_url
+
+        _assert_public_http_url(url)
+        resp = httpx.get(
+            url,
+            headers={"User-Agent": USER_AGENT, "Accept": "text/html,*/*"},
+            timeout=PREVIEW_TIMEOUT,
+            follow_redirects=True,
+        )
+        if resp.status_code >= 400:
+            raise ValueError(f"HTTP {resp.status_code}")
+        body = resp.text[:PREVIEW_MAX_BYTES]
+        # BUG-109 : vignette téléchargée côté serveur — une image distante
+        # échouerait à la CSP. Échec isolé = carte sans vignette.
+        image = _og(body, "og:image")
+        try:
+            image = _proxy_image(image, url) if image else ""
+        except Exception as ie:
+            logger.debug("preview image failed for %s: %s", url, ie)
+            image = ""
+        preview = {
+            "url": url,
+            "title": _og(body, "og:title") or _og(body, "og:site_name"),
+            "description": _og(body, "og:description"),
+            "image": image,
+            "site": _og(body, "og:site_name") or (url.split("/")[2] if "/" in url[8:] else url),
+        }
+        if not preview["title"]:
+            raise ValueError("pas de titre")
+    except Exception as e:
+        logger.debug("link preview failed for %s: %s", url, e)
+        preview = None
+    if len(_PREVIEW_CACHE) >= PREVIEW_CACHE_MAX:
+        _PREVIEW_CACHE.pop(next(iter(_PREVIEW_CACHE)))  # oldest first (dict order)
+    _PREVIEW_CACHE[url] = preview
+    return dict(preview) if preview else None
+
+
+def attachment_path(name: str) -> Path | None:
+    """Resolve an attachment by its stored name (UUID+ext only, no traversal)."""
+    p = Path(name)
+    if p.name != name or p.suffix.lower() not in ALLOWED_ATTACH_EXT:
+        return None
+    file = UPLOAD_DIR / p.name
+    return file if file.exists() else None
+
+
+# Extension → MIME (literals only; ``mimetypes`` guesses poorly for a few).
+_MIME_BY_EXT = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".ogg": "video/ogg",
+    ".mov": "video/quicktime",
+    ".m4v": "video/x-m4v",
+}

backend/indexer.py

@@ -37,6 +37,12 @@ _last_full_index_ts: str = ""
 # Hook for incremental inverted index updates: called as (action, vault, path, file_info)
 _on_index_change: Callable[..., None] | None = None
 
+# Registre des vaults ajoutés à la volée (#194) : les env VAULT_N_*/DIR_N_*
+# ne couvrent que le déploiement, tout ce qui est créé à runtime
+# (/api/vaults/add, dossiers perso) vivrait uniquement en mémoire sinon et
+# disparaîtrait au prochain rebuild ou redémarrage.
+DYNAMIC_VAULTS_FILE = Path("data/vaults.json")
+
 
 def set_index_change_hook(hook):
     """Register a callback for incremental inverted index updates.
@@ -134,7 +140,64 @@ def load_vault_config() -> dict[str, dict[str, Any]]:
         }
         n += 1
 
-    return vaults
+    # Registre dynamique (#194) : les vaults créés à runtime (dossiers
+    # persos, /api/vaults/add) sont chargés en premier, les env gagnent en
+    # cas de collision de nom (vérité du déploiement).
+    merged = _load_dynamic_vaults()
+    merged.update(vaults)
+    return merged
+
+
+def _load_dynamic_vaults() -> dict[str, dict[str, Any]]:
+    """Read vaults registered at runtime from ``data/vaults.json`` (#194)."""
+    if not DYNAMIC_VAULTS_FILE.exists():
+        return {}
+    try:
+        data = json.loads(DYNAMIC_VAULTS_FILE.read_text(encoding="utf-8"))
+        vaults = data.get("vaults", {})
+        return vaults if isinstance(vaults, dict) else {}
+    except (json.JSONDecodeError, OSError) as e:
+        logger.error(f"Failed to read {DYNAMIC_VAULTS_FILE}: {e}")
+        return {}
+
+
+def _save_dynamic_vaults(vaults: dict[str, dict[str, Any]]) -> None:
+    """Atomic write of the dynamic vault registry (tmp + rename, as users.json)."""
+    try:
+        DYNAMIC_VAULTS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        tmp = DYNAMIC_VAULTS_FILE.with_suffix(".tmp")
+        tmp.write_text(
+            json.dumps({"version": 1, "vaults": vaults}, indent=2, default=str),
+            encoding="utf-8",
+        )
+        os.replace(tmp, DYNAMIC_VAULTS_FILE)
+    except OSError as e:
+        # Le registre est un filet : vault_config mémoire reste valable
+        # jusqu'au prochain rebuild, qui se reparera du dossier manquant.
+        logger.error(f"Failed to write {DYNAMIC_VAULTS_FILE}: {e}")
+
+
+def persist_vault(vault_name: str) -> None:
+    """Persist *vault_name* so it survives rebuild/restart (#194).
+
+    Idempotent. Env-declared vaults are re-added by :func:`load_vault_config`
+    anyway; persisting them too is harmless (single source after merge).
+    """
+    cfg = vault_config.get(vault_name)
+    if not cfg:
+        return
+    vaults = _load_dynamic_vaults()
+    vaults[vault_name] = cfg
+    _save_dynamic_vaults(vaults)
+
+
+def unpersist_vault(vault_name: str) -> None:
+    """Drop *vault_name* from the dynamic registry (#194). No-op if absent."""
+    vaults = _load_dynamic_vaults()
+    if vault_name not in vaults:
+        return
+    vaults.pop(vault_name, None)
+    _save_dynamic_vaults(vaults)
 
 
 
@@ -867,6 +930,10 @@ async def reload_single_vault(vault_name: str) -> dict[str, Any]:
 
     # Remove old vault data from index structures
     await remove_vault_from_index(vault_name)
+    # remove_vault_from_index a poppé la config : la remettre, sinon le vault
+    # disparaît de vault_config jusqu'au prochain reload complet (#194 — les
+    # vaults dynamiques n'y reviennent que par data/vaults.json).
+    vault_config[vault_name] = config
 
     # Re-add the vault with updated configuration
     import functools
@@ -1162,6 +1229,13 @@ async def update_single_file(vault_name: str, abs_file_path: str) -> dict[str, A
     if not vault_path:
         return None
 
+    # #197 : les routes passent historiquement un chemin relatif au vault
+    # (``result["path"]``) alors que la docstring exigeait un absolu — le
+    # rafraîchissement était un no-op silencieux (couvert en prod par le
+    # watcher, mais pas dans les tests ni en polling lent). On accepte les deux.
+    if not Path(abs_file_path).is_absolute():
+        abs_file_path = str(Path(vault_path) / abs_file_path)
+
     # Get vault configuration for hidden files handling
     vault_cfg = vault_data.get("config") or vault_config.get(vault_name, {})
     
@@ -1205,6 +1279,10 @@ async def remove_single_file(vault_name: str, abs_file_path: str) -> dict[str, A
     if not vault_path:
         return None
 
+    # #197 : même tolérance relatif/absolu que ``update_single_file``.
+    if not Path(abs_file_path).is_absolute():
+        abs_file_path = str(Path(vault_path) / abs_file_path)
+
     try:
         rel_path = str(Path(abs_file_path).relative_to(vault_path)).replace("\\", "/")
     except ValueError:

backend/main.py

@@ -167,7 +167,7 @@ class SecurityHeadersMiddleware(BaseHTTPMiddleware):
     """Add security headers to all HTTP responses."""
 
     async def dispatch(self, request, call_next):
-        from backend.csp import new_nonce
+        from backend.csp import inject_csp_nonce, new_nonce
 
         # Nonce CSP frais par réponse (#87 T5b) : injecté dans script-src et
         # dans le balisage HTML par les routes (backend.csp.inject_csp_nonce).
@@ -200,6 +200,30 @@ class SecurityHeadersMiddleware(BaseHTTPMiddleware):
                 "form-action 'self'; "
                 "frame-ancestors 'self';"
             )
+            # BUG-106 : /docs et /redoc sont générés par FastAPI, hors de nos
+            # routes qui appellent inject_csp_nonce — leur balisage inline
+            # restait sans nonce et était bloqué par script-src (page blanche).
+            # On injecte ici avec le même helper, seul le HTML est retouché.
+            if request.url.path.startswith(("/docs", "/redoc")) and "text/html" in (
+                response.headers.get("Content-Type") or ""
+            ):
+                import gzip
+
+                # La compression (GZipMiddleware) est plus proche de la route :
+                # le corps arrive déjà gunzippé, on recomprime à l'identique.
+                raw = b"".join([chunk async for chunk in response.body_iterator])
+                is_gz = "gzip" in (response.headers.get("Content-Encoding") or "")
+                if is_gz:
+                    raw = gzip.decompress(raw)
+                patched = inject_csp_nonce(raw.decode("utf-8", "replace"), nonce).encode("utf-8")
+                if is_gz:
+                    patched = gzip.compress(patched)
+                response.headers["Content-Length"] = str(len(patched))
+
+                async def _docs_body():
+                    yield patched
+
+                response.body_iterator = _docs_body()
         # Static assets are NOT content-hashed, so they must revalidate:
         # ``immutable``/long max-age made Cloudflare and mobile browsers serve
         # a stale build for a year (the service worker cache compounded it).
@@ -340,10 +364,34 @@ async def lifespan(app: FastAPI):
         else:
             logger.info("File watcher disabled by configuration.")
 
+        # #194 : dossier personnel par utilisateur — réparation/migration
+        # (mkdir manquant, registre perdu, user créé hors API). Après le
+        # watcher pour que les vaults ajoutés soient surveillés.
+        from backend.user_home import ensure_all_user_homes
+        await ensure_all_user_homes()
+
         logger.info("Background startup complete.")
 
     asyncio.create_task(_background_startup())
 
+    async def _scheduler_loop():
+        """Background tick for scheduled tasks (#170) — every 60 s, best effort."""
+        from backend.scheduler import tick
+
+        await asyncio.sleep(60)
+        while True:
+            try:
+                outcomes = await asyncio.to_thread(tick)
+                if outcomes:
+                    logger.info(f"Scheduler tick: {len(outcomes)} task(s) executed")
+            except Exception as e:
+                logger.warning(f"Scheduler tick failed: {e}")
+            await asyncio.sleep(60)
+
+    if os.environ.get("OBSIGATE_SCHEDULER", "1") != "0":
+        asyncio.create_task(_scheduler_loop())
+        logger.info("Scheduler loop started (#170, 60 s tick).")
+
     logger.info("ObsiGate ready (listening for requests while indexing).")
     yield
 
@@ -438,6 +486,13 @@ app.add_middleware(SSESafeGZipMiddleware, minimum_size=1000)
 # Security headers on all responses
 app.add_middleware(SecurityHeadersMiddleware)
 
+# Scoped API tokens (#199) : les clés à portée "files" sont confinées à la
+# surface fichiers côté REST (403 hors périmètre). Placé avant CORS pour que
+# le refus s'applique aussi aux requêtes out-of-scope.
+from backend.auth.scope import TokenScopeMiddleware
+
+app.add_middleware(TokenScopeMiddleware)
+
 # Explicit same-origin CORS policy (#87 T8 — finit BUG-034).
 # `allow_origins=[]` : le navigateur n'émet aucun `Access-Control-Allow-*`,
 # donc toute lecture cross-origin est refusée (défense explicite, plus
@@ -466,12 +521,16 @@ from backend.routers.backups import router as backups_router
 from backend.routers.config import _load_config
 from backend.routers.config import router as config_router
 from backend.routers.conflicts import router as conflicts_router
+from backend.routers.duplicates import router as duplicates_router
+from backend.routers.file_chat import router as file_chat_router
 from backend.routers.files_media import router as files_media_router
 from backend.routers.files_read import router as files_read_router
 from backend.routers.files_write import router as files_write_router
 from backend.routers.health import router as health_router
 from backend.routers.history import router as history_router
+from backend.routers.notify import router as notify_router
 from backend.routers.realtime import router as realtime_router
+from backend.routers.scheduler import router as scheduler_router
 from backend.routers.search import router as search_router
 from backend.routers.sharing import router as sharing_router
 from backend.routers.vaults import router as vaults_router
@@ -489,12 +548,16 @@ app.include_router(search_router)  # ROADMAP #85 T5 — Search
 app.include_router(backups_router)  # ROADMAP #85 T4 — Backups
 app.include_router(conflicts_router)  # ROADMAP #85 T8 — Conflicts
 app.include_router(config_router)  # ROADMAP #85 T7 — Config
+app.include_router(file_chat_router)  # ROADMAP #169 — Chat par fichier
 app.include_router(files_read_router)  # ROADMAP #85 T6a — Files read
 app.include_router(files_media_router)  # ROADMAP #85 T6c — Media/export
 app.include_router(files_write_router)  # ROADMAP #85 T6b — Files write
 app.include_router(webhooks_router)  # ROADMAP #85 T2 — Webhooks
 app.include_router(sharing_router)  # ROADMAP #85 T3 — Sharing
 app.include_router(vaults_router)  # ROADMAP #85 T8 — Vaults
+app.include_router(duplicates_router)  # ROADMAP #166 — Doublons
+app.include_router(notify_router)  # ROADMAP #168 — Notifications externes
+app.include_router(scheduler_router)  # ROADMAP #170 — Tâches planifiées
 
 # Admin Dashboard endpoints (system stats, audit logs, backups, stream)
 try:

backend/mcp/server.py

@@ -43,6 +43,7 @@ from backend.auth.middleware import get_current_user, is_auth_enabled
 from backend.services.files import read_file_text
 from backend.services.vaults import list_accessible_vaults
 from backend.tools.api import (
+    FILES_SCOPE_TOOLS,
     ToolContext,
     ToolError,
     ToolMode,
@@ -191,6 +192,14 @@ def _tool_definitions() -> list[types.Tool]:
     return definitions
 
 
+def _mcp_base_name(mcp_name: str) -> str:
+    """Strip the ``propose_``/``apply_`` prefix back to the registry tool name."""
+    for prefix in ("propose_", "apply_"):
+        if mcp_name.startswith(prefix):
+            return mcp_name[len(prefix):]
+    return mcp_name
+
+
 def _parse_vault_uri(uri: str) -> tuple[str, str]:
     """Split ``vault://name/path`` into ``(vault, path)``."""
     parsed = urlparse(uri)
@@ -208,6 +217,10 @@ def build_server() -> Server:
     # ── Tools ──────────────────────────────────────────────────────────
     @server.list_tools()
     async def _list_tools() -> list[types.Tool]:
+        # #199 : un token à portée "files" ne voit que les outils fichiers.
+        user = _user_from_context(server)
+        if (user.get("_token_scope") or "full") == "files":
+            return [t for t in _tool_definitions() if _mcp_base_name(t.name) in FILES_SCOPE_TOOLS]
         return _tool_definitions()
 
     @server.call_tool()
@@ -262,6 +275,7 @@ def build_server() -> Server:
         user = _user_from_context(server)
         vault, path = _parse_vault_uri(str(uri))
         ctx = ToolContext(user=user, mode=ToolMode.MCP)
+        ctx.require_tool_allowed("read_file")  # #199 : portée inconnue → refus
         ctx.require_vault_access(vault)
         data = read_file_text(vault, path, redact=True, max_bytes=MAX_RESOURCE_BYTES)
         mime = "text/markdown" if Path(path).suffix.lower() == ".md" else "text/plain"
@@ -352,6 +366,12 @@ def _propose(user: dict[str, Any], tool: str, arguments: dict[str, Any]) -> list
     params = spec.input_model.model_validate(arguments)
     vault = getattr(params, "vault", None)
     ctx = ToolContext(user=user, mode=ToolMode.MCP)
+    # #199 : les tokens à portée limitée ne peuvent proposer que les outils
+    # fichiers (même garde que call_tool, qui couvre apply_).
+    try:
+        ctx.require_tool_allowed(tool)
+    except ToolError as e:
+        return _text(e.to_dict())
     if vault and vault != "all":
         ctx.require_vault_access(vault)
         if spec.risk == ToolRisk.DANGEROUS:

backend/notify.py

@@ -0,0 +1,350 @@
+"""External notifications — Discord, Telegram, SMTP, generic webhook (#168).
+
+Configuration is persisted in ``data/notify_channels.json``; secrets live in
+``data/notify_secrets.json`` (0600) or in ``OBSIGATE_NOTIFY_SECRET_<ID>``
+environment variables — never in the public config file (same pattern as
+``backend/webhooks.py``, BUG-026).
+
+Supported channel types:
+
+* ``discord`` — Discord webhook URL (``POST {"content": ...}``).
+* ``telegram`` — Bot API (``POST https://api.telegram.org/bot<token>/sendMessage``).
+* ``smtp`` — Email via stdlib ``smtplib`` (STARTTLS, auth login).
+* ``webhook`` — generic JSON ``POST`` (SSRF-safe, same policy as #9).
+
+Each channel declares ``triggers`` chosen among :data:`VALID_TRIGGERS`.
+The scheduler (#170) broadcasts on ``schedule_failure``; file-event fan-out
+stays on the historical ``backend/webhooks.py`` path.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import smtplib
+import threading
+import uuid
+from datetime import datetime, timezone
+from email.message import EmailMessage
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("obsigate.notify")
+
+DATA_DIR = Path(os.environ.get("OBSIGATE_DATA_DIR", "data"))
+CHANNELS_FILE = DATA_DIR / "notify_channels.json"
+SECRETS_FILE = DATA_DIR / "notify_secrets.json"
+
+CHANNEL_TYPES = ("discord", "telegram", "smtp", "webhook")
+VALID_TRIGGERS = ("manual", "schedule_failure", "schedule_success", "duplicate_found")
+
+_lock = threading.RLock()
+
+
+# ── Store helpers ──────────────────────────────────────────────────────────
+
+
+def _read_channels() -> list[dict[str, Any]]:
+    if not CHANNELS_FILE.exists():
+        return []
+    try:
+        data = json.loads(CHANNELS_FILE.read_text(encoding="utf-8"))
+        return data if isinstance(data, list) else []
+    except (json.JSONDecodeError, OSError):
+        return []
+
+
+def _write_channels(channels: list[dict[str, Any]]) -> None:
+    CHANNELS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    tmp = CHANNELS_FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(channels, indent=2, default=str), encoding="utf-8")
+    tmp.replace(CHANNELS_FILE)
+
+
+def _read_secrets() -> dict[str, str]:
+    if not SECRETS_FILE.exists():
+        return {}
+    try:
+        data = json.loads(SECRETS_FILE.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def _write_secrets(secrets: dict[str, str]) -> None:
+    SECRETS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    tmp = SECRETS_FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(secrets, indent=2), encoding="utf-8")
+    tmp.replace(SECRETS_FILE)
+    try:
+        SECRETS_FILE.chmod(0o600)
+    except OSError:
+        pass  # Windows: pas de permissions Unix
+
+
+def _secret_key(channel_id: str) -> str:
+    return "OBSIGATE_NOTIFY_SECRET_" + channel_id.replace("-", "_").upper()
+
+
+def _get_secret(channel_id: str) -> str | None:
+    """Resolve a channel secret: env > dedicated store > legacy inline config."""
+    env_val = os.environ.get(_secret_key(channel_id))
+    if env_val:
+        return env_val
+    stored = _read_secrets().get(channel_id)
+    if stored:
+        return stored
+    for ch in _read_channels():
+        if ch.get("id") == channel_id:
+            cfg = ch.get("config", {})
+            for key in ("webhook_url", "bot_token", "password"):
+                if cfg.get(key):
+                    return str(cfg[key])
+    return None
+
+
+def _public_view(channel: dict[str, Any]) -> dict[str, Any]:
+    clean = {k: v for k, v in channel.items() if k != "config"}
+    cfg = dict(channel.get("config", {}))
+    for secret_field in ("webhook_url", "bot_token", "password"):
+        if cfg.get(secret_field):
+            cfg[secret_field] = "***"
+    clean["config"] = cfg
+    clean["has_secret"] = bool(_get_secret(channel["id"]))
+    return clean
+
+
+# ── CRUD ───────────────────────────────────────────────────────────────────
+
+
+def _validate_config(channel_type: str, config: dict[str, Any]) -> dict[str, Any]:
+    """Validate (sans secret) and normalize a channel config. Raises ValueError."""
+    config = dict(config or {})
+    if channel_type == "discord":
+        url = str(config.get("webhook_url") or config.get("url") or "").strip()
+        if not url.startswith(("https://discord.com/api/webhooks/", "https://discordapp.com/api/webhooks/")):
+            # Laisse passer les URLs de test locales quand le mode privé est ouvert.
+            from backend.webhooks import validate_webhook_url
+
+            validate_webhook_url(url)
+            if "discord" not in url and not os.environ.get("OBSIGATE_WEBHOOK_ALLOW_PRIVATE"):
+                raise ValueError("URL Discord invalide (webhook discord.com attendu)")
+        config["webhook_url"] = url
+    elif channel_type == "telegram":
+        if not str(config.get("chat_id") or "").strip():
+            raise ValueError("chat_id Telegram requis")
+        config["chat_id"] = str(config["chat_id"]).strip()
+        if config.get("bot_token"):
+            config["bot_token"] = str(config["bot_token"]).strip()
+    elif channel_type == "smtp":
+        for field in ("host", "from_addr", "to_addr"):
+            if not str(config.get(field) or "").strip():
+                raise ValueError(f"Champ SMTP requis : {field}")
+        config["port"] = int(config.get("port") or 587)
+        config["use_tls"] = bool(config.get("use_tls", True))
+        config["username"] = str(config.get("username") or "").strip()
+    elif channel_type == "webhook":
+        from backend.webhooks import validate_webhook_url
+
+        url = str(config.get("url") or "").strip()
+        validate_webhook_url(url)
+        config["url"] = url
+    else:
+        raise ValueError(f"Type de canal inconnu : {channel_type}")
+    triggers = [t for t in (config.get("triggers") or ["manual"]) if t in VALID_TRIGGERS]
+    config["triggers"] = triggers or ["manual"]
+    return config
+
+
+def list_channels() -> list[dict[str, Any]]:
+    """Return public views of all notification channels."""
+    return [_public_view(ch) for ch in _read_channels()]
+
+
+def create_channel(name: str, channel_type: str, config: dict[str, Any]) -> dict[str, Any]:
+    """Create a notification channel. Secrets are split into the secret store."""
+    if channel_type not in CHANNEL_TYPES:
+        raise ValueError(f"Type de canal inconnu : {channel_type}")
+    with _lock:
+        channels = _read_channels()
+        channel_id = str(uuid.uuid4())
+        normalized = _validate_config(channel_type, config)
+        secrets = _read_secrets()
+        for field in ("webhook_url", "bot_token", "password"):
+            if normalized.get(field) and len(str(normalized[field])) > 8:
+                secrets[channel_id] = str(normalized[field])
+                normalized[field] = "***"  # placeholder : le secret vit dans le store dédié
+        _write_secrets(secrets)
+        channel = {
+            "id": channel_id,
+            "name": (name or channel_type).strip() or channel_type,
+            "type": channel_type,
+            "enabled": True,
+            "config": normalized,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "last_sent_at": None,
+            "last_error": None,
+        }
+        channels.append(channel)
+        _write_channels(channels)
+    logger.info(f"Created notify channel '{name}' ({channel_type})")
+    return _public_view(channel)
+
+
+def update_channel(channel_id: str, updates: dict[str, Any]) -> dict[str, Any] | None:
+    """Update a channel (name/enabled/config). Returns None when unknown."""
+    with _lock:
+        channels = _read_channels()
+        for channel in channels:
+            if channel.get("id") != channel_id:
+                continue
+            if updates.get("name"):
+                channel["name"] = str(updates["name"])
+            if "enabled" in updates:
+                channel["enabled"] = bool(updates["enabled"])
+            if "config" in updates and isinstance(updates["config"], dict):
+                merged = {**channel.get("config", {}), **updates["config"]}
+                normalized = _validate_config(channel["type"], merged)
+                secrets = _read_secrets()
+                for field in ("webhook_url", "bot_token", "password"):
+                    if updates["config"].get(field):
+                        secrets[channel_id] = str(updates["config"][field])
+                        normalized[field] = "***"
+                _write_secrets(secrets)
+                channel["config"] = normalized
+            _write_channels(channels)
+            return _public_view(channel)
+    return None
+
+
+def delete_channel(channel_id: str) -> bool:
+    """Delete a channel and its secret. Returns False when unknown."""
+    with _lock:
+        channels = _read_channels()
+        remaining = [c for c in channels if c.get("id") != channel_id]
+        if len(remaining) == len(channels):
+            return False
+        _write_channels(remaining)
+        secrets = _read_secrets()
+        if secrets.pop(channel_id, None) is not None:
+            _write_secrets(secrets)
+    return True
+
+
+# ── Dispatch ───────────────────────────────────────────────────────────────
+
+
+def _send_discord(webhook_url: str, title: str, message: str) -> None:
+    import httpx
+
+    content = f"**{title}**\n{message}"[:2000]
+    resp = httpx.post(webhook_url, json={"content": content}, timeout=10.0)
+    resp.raise_for_status()
+
+
+def _send_telegram(bot_token: str, chat_id: str, title: str, message: str) -> None:
+    import httpx
+
+    from backend.webhooks import is_safe_target
+
+    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
+    if not is_safe_target(url):
+        raise RuntimeError("Cible Telegram bloquée par la politique SSRF")
+    text = f"*{title}*\n{message}"[:4000]
+    resp = httpx.post(
+        url,
+        json={"chat_id": chat_id, "text": text, "parse_mode": "Markdown"},
+        timeout=10.0,
+    )
+    resp.raise_for_status()
+
+
+def _send_smtp(config: dict[str, Any], password: str | None, title: str, message: str) -> None:
+    msg = EmailMessage()
+    msg["Subject"] = f"[ObsiGate] {title}"
+    msg["From"] = config["from_addr"]
+    msg["To"] = config["to_addr"]
+    msg.set_content(message)
+    with smtplib.SMTP(str(config["host"]), int(config.get("port", 587)), timeout=10) as client:
+        if config.get("use_tls", True):
+            client.starttls()
+        if config.get("username") and password:
+            client.login(str(config["username"]), password)
+        client.send_message(msg)
+
+
+def _send_webhook(url: str, title: str, message: str, trigger: str) -> None:
+    import httpx
+
+    from backend.webhooks import is_safe_target
+
+    if not is_safe_target(url):
+        raise RuntimeError("Cible webhook bloquée par la politique SSRF")
+    resp = httpx.post(
+        url,
+        json={
+            "event": trigger,
+            "title": title,
+            "message": message,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "source": "obsigate-notify",
+        },
+        timeout=10.0,
+    )
+    resp.raise_for_status()
+
+
+def send_via_channel(channel: dict[str, Any], title: str, message: str, trigger: str = "manual") -> None:
+    """Send a notification through one raw channel record. Raises on failure."""
+    channel_type = channel.get("type")
+    cfg = dict(channel.get("config", {}))
+    secret = _get_secret(channel["id"])
+    if channel_type == "discord":
+        url = secret or cfg.get("webhook_url") or ""
+        if not url or url == "***":
+            raise RuntimeError("URL webhook Discord manquante")
+        _send_discord(url, title, message)
+    elif channel_type == "telegram":
+        token = secret or cfg.get("bot_token") or os.environ.get("OBSIGATE_TELEGRAM_BOT_TOKEN") or ""
+        if not token or token == "***":
+            raise RuntimeError("Token bot Telegram manquant")
+        _send_telegram(token, str(cfg.get("chat_id", "")), title, message)
+    elif channel_type == "smtp":
+        _send_smtp(cfg, secret, title, message)
+    elif channel_type == "webhook":
+        url = str(cfg.get("url") or "").strip()
+        if not url:
+            raise RuntimeError("URL webhook manquante")
+        _send_webhook(url, title, message, trigger)
+    else:
+        raise RuntimeError(f"Type de canal inconnu : {channel_type}")
+
+
+def broadcast(trigger: str, title: str, message: str) -> list[dict[str, Any]]:
+    """Send to every enabled channel subscribed to *trigger*. Never raises."""
+    results: list[dict[str, Any]] = []
+    for channel in _read_channels():
+        if not channel.get("enabled", True):
+            continue
+        if trigger not in channel.get("config", {}).get("triggers", ["manual"]):
+            continue
+        try:
+            send_via_channel(channel, title, message, trigger)
+            results.append({"channel_id": channel["id"], "ok": True})
+            _mark_sent(channel["id"], None)
+        except Exception as e:
+            logger.warning(f"Notify channel '{channel.get('name')}' failed: {e}")
+            results.append({"channel_id": channel["id"], "ok": False, "error": str(e)})
+            _mark_sent(channel["id"], str(e))
+    return results
+
+
+def _mark_sent(channel_id: str, error: str | None) -> None:
+    with _lock:
+        channels = _read_channels()
+        for channel in channels:
+            if channel.get("id") == channel_id:
+                channel["last_sent_at"] = datetime.now(timezone.utc).isoformat()
+                channel["last_error"] = error
+        _write_channels(channels)

backend/openapi_docs.py

@@ -41,6 +41,9 @@ TAGS_METADATA: list[dict[str, str]] = [
     {"name": "Admin", "description": "Admin-only system monitoring: stats, audit log, backup stats and live stream."},
     {"name": "Plugins", "description": "Install, enable and manage user plugins."},
     {"name": "Push", "description": "Web Push (VAPID) subscription management and test notifications."},
+    {"name": "Duplicates", "description": "Duplicate-note detection and confirmed merge (#166)."},
+    {"name": "Notify", "description": "External notifications: Discord, Telegram, SMTP and generic webhooks (#168)."},
+    {"name": "Scheduler", "description": "Scheduled automatic tasks reusing the vault mutation services (#170)."},
     {"name": "Frontend", "description": "Static assets and SPA fallback routes."},
 ]
 
@@ -95,6 +98,9 @@ _TAG_RULES: list[tuple[re.Pattern[str], str]] = [
     (re.compile(r"^/api/shares"), "Sharing"),
     (re.compile(r"^/s/"), "Sharing"),
     (re.compile(r"^/api/webhooks"), "Webhooks"),
+    (re.compile(r"^/api/duplicates"), "Duplicates"),
+    (re.compile(r"^/api/notify"), "Notify"),
+    (re.compile(r"^/api/scheduler"), "Scheduler"),
     (re.compile(r"^/api/conflicts"), "Conflicts"),
     (re.compile(r"^/api/backups"), "Backups"),
     (re.compile(r"^/api/file/[^/]+/(backups|diff|restore)"), "Backups"),
@@ -148,6 +154,9 @@ _TAG_ALIASES: dict[str, str] = {
     "export": "Export",
     "sharing": "Sharing",
     "webhooks": "Webhooks",
+    "duplicates": "Duplicates",
+    "notify": "Notify",
+    "scheduler": "Scheduler",
     "conflicts": "Conflicts",
     "system": "System",
     "frontend": "Frontend",
@@ -233,8 +242,8 @@ _ENDPOINT_EXAMPLES: dict[tuple[str, str], dict[str, Any]] = {
         "response": {"id": "abc…", "token": "abc…", "vault": "TestVault", "path": "notes/Accueil.md", "url": "/s/abc…"},
     },
     ("post", "/api/webhooks"): {
-        "request": {"name": "CI", "url": "https://example.com/hook", "events": ["file_modified"], "secret": "s3cr3t"},
-        "response": {"id": "3f2c…", "name": "CI", "url": "https://example.com/hook", "events": ["file_modified"], "enabled": True},
+        "request": {"name": "CI", "url": "https://example.com/hook", "events": ["file_modified"], "secret": "s3cr3t", "vault": "TikTak", "path_prefix": "Inbox"},
+        "response": {"id": "3f2c…", "name": "CI", "url": "https://example.com/hook", "events": ["file_modified"], "enabled": True, "vault": "TikTak", "path_prefix": "Inbox"},
     },
 }
 

backend/push.py

@@ -13,7 +13,7 @@ from typing import Any
 from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel, Field
 
-from backend.auth.middleware import require_auth
+from backend.auth.middleware import check_vault_access, require_auth
 
 logger = logging.getLogger("obsigate.push")
 
@@ -167,9 +167,9 @@ async def subscribe_push(
     """Subscribe to push notifications for a vault."""
     username = current_user.get("username", "unknown")
     
-    # Check if user has access to this vault
-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])
-    if "*" not in user_vaults and request.vault not in user_vaults:
+    # Check if user has access to this vault (#194 : "*" n'inclut pas les
+    # dossiers persos, check_vault_access est la source unique).
+    if not check_vault_access(request.vault, current_user):
         raise HTTPException(status_code=403, detail="No access to this vault")
     
     # Check if subscription already exists

backend/render.py

@@ -21,7 +21,7 @@ import mistune
 
 from backend.image_processor import preprocess_images
 from backend.indexer import find_file_in_index, get_vault_data
-from backend.secret_redactor import redact_file_content
+from backend.secret_redactor import redact_with_placeholders, restore_masks
 from backend.services.sanitizer import sanitize_html
 
 
@@ -166,7 +166,13 @@ def _normalize_line_breaks(text: str) -> str:
     return "".join(parts)
 
 
-def _render_markdown(raw_md: str, vault_name: str, current_file_path: Path | None = None) -> str:
+def _render_markdown(
+    raw_md: str,
+    vault_name: str,
+    current_file_path: Path | None = None,
+    *,
+    click_to_copy: bool = False,
+) -> str:
     """Render a markdown string to HTML with wikilink and image support.
 
     Uses the cached singleton mistune renderer for performance.
@@ -175,6 +181,10 @@ def _render_markdown(raw_md: str, vault_name: str, current_file_path: Path | Non
         raw_md: Raw markdown text (frontmatter already stripped).
         vault_name: Current vault for wikilink resolution context.
         current_file_path: Absolute path to the current markdown file.
+        click_to_copy: Restore masked secrets as clickable badges carrying
+            the real value (authenticated app preview, feature #188).
+            Public shares and PDF exports keep plain labels: the secret
+            never reaches their HTML.
 
     Returns:
         HTML string.
@@ -184,8 +194,13 @@ def _render_markdown(raw_md: str, vault_name: str, current_file_path: Path | Non
     vault_root = Path(vault_data["path"]) if vault_data else None
     attachments_path = vault_data.get("config", {}).get("attachmentsPath") if vault_data else None
 
-    # Redact secrets before rendering (P0 security)
-    raw_md = redact_file_content(raw_md, str(current_file_path) if current_file_path else "")
+    # Redact secrets before rendering (P0 security). Placeholders survive
+    # the markdown conversion (fenced code blocks included) and are turned
+    # back into visible masks — clickable badges when click_to_copy — right
+    # after the HTML is produced (feature #188).
+    raw_md, secret_entries = redact_with_placeholders(
+        raw_md, str(current_file_path) if current_file_path else ""
+    )
 
     # Preprocess images first
     if vault_root:
@@ -201,6 +216,10 @@ def _render_markdown(raw_md: str, vault_name: str, current_file_path: Path | Non
     # renderers HTML renvoient toujours `str` à l'exécution).
     rendered = cast(str, _markdown_renderer(converted))
 
+    # Restore secret masks (plain labels, or clickable badges carrying the
+    # real value on the authenticated app preview — feature #188).
+    rendered = restore_masks(rendered, secret_entries, click_to_copy=click_to_copy)
+
     # Add heading IDs for TOC navigation
     rendered = _add_heading_ids(rendered)
 

backend/requirements.txt

@@ -39,3 +39,8 @@ reportlab>=4.0
 pillow>=10.0
 # Plancher urllib3 >= 2.8.0 (CVE-2026-97687, CVE-2026-97688, CVE-2026-97689)
 urllib3>=2.8.0
+# Plancher de sécurité (CVE-2026-104874, fix 6.9.1) : multidict est transitive
+# (aiohttp/yarl). 6.7.x est la version pré-installée dans la toolcache de
+# l'image du runner — sans plancher, pip répond « already satisfied » et
+# n'aligne jamais (même piège que pypdf, BUG-093).
+multidict>=6.9.1

backend/routers/config.py

@@ -24,7 +24,7 @@ from pathlib import Path
 from fastapi import APIRouter, Body, Depends, HTTPException, Query
 
 from backend.ai import PROVIDERS, _read_ai_keys, get_ai_key
-from backend.auth.middleware import require_admin, require_auth
+from backend.auth.middleware import check_vault_access, require_admin, require_auth
 from backend.indexer import index
 from backend.media_types import IMAGE_EXTENSIONS
 from backend.schemas import (
@@ -495,14 +495,13 @@ async def api_diagnostics(current_user=Depends(require_admin)):
 @router.get("/api/dashboard", response_model=DashboardResponse)
 async def api_dashboard(current_user=Depends(require_auth)):
     """Aggregated dashboard statistics across all accessible vaults."""
-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])
     vault_stats = []
     total_files = 0
     total_tags = set()
     total_size = 0
     total_images = 0
     for vname, vdata in index.items():
-        if "*" not in user_vaults and vname not in user_vaults:
+        if not check_vault_access(vname, current_user):
             continue
         files = vdata.get("files", [])
         fc = len(files)

backend/routers/conflicts.py

@@ -31,10 +31,9 @@ router = APIRouter(tags=["conflicts"])
 @router.get("/api/conflicts", response_model=ConflictsResponse)
 async def api_conflicts(current_user=Depends(require_auth)):
     """List sync-conflict files across accessible vaults."""
-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])
     all_conflicts = get_conflicts()
-    if "*" not in user_vaults:
-        all_conflicts = [c for c in all_conflicts if c["vault"] in user_vaults]
+    # #194 : filtrage via check_vault_access ("*" n'inclut pas les homes).
+    all_conflicts = [c for c in all_conflicts if check_vault_access(c["vault"], current_user)]
     return {"conflicts": all_conflicts, "total": len(all_conflicts)}
 
 

backend/routers/duplicates.py

@@ -0,0 +1,88 @@
+"""Duplicate detection & merge endpoints (#166).
+
+Read endpoints require vault access; the merge endpoint is destructive
+(backup first in the service layer) and additionally requires the
+confirmation token pattern used by mutating routes — here enforced by an
+explicit ``confirm=true`` body flag, mirroring the agent two-step flow.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
+from pydantic import BaseModel, ConfigDict, Field
+
+from backend.auth.middleware import check_vault_access, require_auth
+from backend.services import duplicates as _duplicates
+from backend.services.errors import ServiceError
+
+router = APIRouter(prefix="/api/duplicates", tags=["duplicates"])
+
+
+class DuplicatePair(BaseModel):
+    """One candidate duplicate pair."""
+
+    model_config = ConfigDict(extra="allow")
+    file_a: str = Field(description="First file (vault-relative)")
+    file_b: str = Field(description="Second file (vault-relative)")
+    score: float = Field(description="Blended similarity in [0, 1]")
+
+
+class DuplicatesResponse(BaseModel):
+    """Response for GET /api/duplicates."""
+
+    model_config = ConfigDict(extra="allow")
+    vault: str = Field(description="Vault name")
+    threshold: float = Field(description="Applied threshold")
+    files_scanned: int = Field(description="Markdown files compared")
+    truncated: bool = Field(description="True when the scan hit the file cap")
+    pairs: list[DuplicatePair] = Field(description="Candidate pairs, best score first")
+
+
+class MergeResponse(BaseModel):
+    """Response for POST /api/duplicates/merge."""
+
+    model_config = ConfigDict(extra="allow")
+    strategy: str = Field(description="Applied merge strategy")
+    target: str = Field(description="Surviving note")
+    deleted: str = Field(description="Absorbed note (deleted after merge)")
+
+
+@router.get("", response_model=DuplicatesResponse)
+async def api_duplicates_list(
+    vault: str = Query(..., description="Vault name"),
+    threshold: float = Query(0.75, ge=0.3, le=1.0, description="Minimum similarity"),
+    limit: int = Query(20, ge=1, le=200, description="Max pairs"),
+    subdir: str = Query("", description="Directory scope"),
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """List candidate duplicate notes ordered by descending score."""
+    if not check_vault_access(vault, current_user):
+        raise HTTPException(403, f"No access to vault '{vault}'")
+    try:
+        return _duplicates.find_duplicate_pairs(vault, threshold=threshold, limit=limit, subdir=subdir)
+    except ServiceError as e:
+        raise HTTPException(e.status or 400, e.message) from e
+
+
+@router.post("/merge", response_model=MergeResponse)
+async def api_duplicates_merge(
+    body: dict[str, Any] = Body(...),
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Merge *source_path* into *target_path* (``confirm: true`` required)."""
+    vault = str(body.get("vault") or "")
+    if not check_vault_access(vault, current_user):
+        raise HTTPException(403, f"No access to vault '{vault}'")
+    if body.get("confirm") is not True:
+        raise HTTPException(400, "Fusion destructive : confirmez avec {confirm: true}")
+    try:
+        return _duplicates.merge_duplicates(
+            vault,
+            str(body.get("source_path") or ""),
+            str(body.get("target_path") or ""),
+            strategy=str(body.get("strategy") or "append"),
+        )
+    except ServiceError as e:
+        raise HTTPException(e.status or 400, e.message) from e

backend/routers/file_chat.py

@@ -0,0 +1,290 @@
+# backend/routers/file_chat.py — chat (#169, #190)
+"""Chat endpoints: history read + message post with SSE fan-out.
+
+- ``GET/POST /api/file/{vault_name}/chat`` — per-file chat: auth + vault
+  access + path traversal check (``resolve_safe_path`` raises
+  ``ServiceError`` mapped by the app-level handler).
+- ``GET/POST /api/chat`` — the **general chat** (#190), not bound to a file.
+- ``POST /api/chat/upload`` / ``GET /api/chat/attachment/{name}`` (#190):
+  image/video attachments (extension allow-list, size cap, UUID name).
+
+Every post is broadcast on the existing SSE channel (``chat_message``) so
+all connected clients update live without a second WebSocket.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, Body, Depends, File, HTTPException, UploadFile
+from fastapi.responses import FileResponse
+
+from backend import file_chat as _store
+from backend.auth.middleware import check_vault_access, require_auth
+from backend.auth.user_store import get_all_users, get_user
+from backend.indexer import get_vault_data
+from backend.schemas import ChatHistoryResponse, ChatMessageResponse, ChatReadResponse, StatusResponse
+from backend.services.paths import resolve_safe_path
+from backend.sse import sse_manager
+
+router = APIRouter()  # tags dérivés de `tag_for_path` → « Files »
+
+
+def _check(vault_name: str, path: str, current_user: dict[str, Any]) -> None:
+    """Authz + traversal guard shared by both verbs."""
+    if not check_vault_access(vault_name, current_user):
+        raise HTTPException(403, f"Accès refusé à la vault '{vault_name}'")
+    vault_data = get_vault_data(vault_name)
+    if not vault_data:
+        raise HTTPException(404, "Vault not found")
+    resolve_safe_path(Path(vault_data["path"]), path)  # ServiceError → 403/500
+
+
+@router.get("/api/file/{vault_name}/chat", response_model=ChatHistoryResponse)
+async def api_file_chat_history(
+    vault_name: str,
+    path: str,
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Return the chat history for a file (chronological)."""
+    _check(vault_name, path, current_user)
+    return {"messages": _store.get_messages(vault_name, path), "read": _store.get_read(vault_name, path)}
+
+
+@router.post("/api/file/{vault_name}/chat", response_model=ChatMessageResponse)
+async def api_file_chat_post(
+    vault_name: str,
+    body: dict[str, Any] = Body(...),
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Post a chat message and broadcast it on SSE (``chat_message``)."""
+    path = str(body.get("path") or "")
+    text = str(body.get("text") or "")
+    if not path:
+        raise HTTPException(400, "path is required")
+    if not text.strip():
+        raise HTTPException(400, "text is required")
+    _check(vault_name, path, current_user)
+    msg = _store.add_message(vault_name, path, current_user.get("username", ""), text)
+    await sse_manager.broadcast("chat_message", {"vault": vault_name, "path": path, "message": msg})
+    return {"message": msg, "status": "ok"}
+
+
+# --- #190 : chat général ----------------------------------------------------
+
+def _attachment(body: dict[str, Any]) -> dict[str, Any] | None:
+    """Validate the optional ``attachment`` object sent by the client."""
+    raw = body.get("attachment")
+    if not raw or not isinstance(raw, dict):
+        return None
+    name = str(raw.get("name") or "")
+    # Only an already-uploaded file (or an http(s) URL) may travel along.
+    if not _store.attachment_path(name) and not str(raw.get("url", "")).startswith(("http://", "https://", "/api/")):
+        raise HTTPException(400, "attachment inconnu")
+    return {
+        "name": name,
+        "url": str(raw.get("url") or ""),
+        "mime": str(raw.get("mime") or ""),
+        "kind": str(raw.get("kind") or "file"),
+    }
+
+
+@router.get("/api/chat", response_model=ChatHistoryResponse)
+async def api_chat_history(current_user: dict[str, Any] = Depends(require_auth)):
+    """Return the general chat history (#190, chronological)."""
+    return {
+        "messages": _store.get_global_messages(),
+        "read": _store.get_read(_store.GLOBAL_VAULT, _store.GLOBAL_PATH),
+    }
+
+
+# --- #192 : accusé de réception ---------------------------------------------
+
+def _check_read(vault: str, path: str, current_user: dict[str, Any]) -> None:
+    """Authorization for marking a conversation read (#192).
+
+    General chat is open to any member, a DM only to the two participants,
+    a file chat follows the vault ACL.
+    """
+    if vault == _store.GLOBAL_VAULT:
+        return
+    if vault == _store.DM_VAULT:
+        if current_user.get("username") not in str(path).split("|"):
+            raise HTTPException(403, "Accès refusé à cette conversation privée")
+        return
+    _check(vault, path, current_user)
+
+
+@router.post("/api/chat/read", response_model=ChatReadResponse)
+async def api_chat_read(
+    body: dict[str, Any] = Body(...),
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Record that the caller has seen a conversation (#192).
+
+    Broadcast on SSE (``chat_read``) so the sender's own messages flip to
+    ✓✓ live on every connected client.
+    """
+    vault = str(body.get("vault") or "")
+    path = str(body.get("path") or "")
+    if not vault or not path:
+        raise HTTPException(400, "vault and path are required")
+    _check_read(vault, path, current_user)
+    username = current_user.get("username", "")
+    read = _store.mark_read(vault, path, username)
+    await sse_manager.broadcast(
+        "chat_read",
+        {"vault": vault, "path": path, "user": username, "ts": read.get(username, 0.0), "read": read},
+    )
+    return {"read": read, "status": "ok"}
+
+
+@router.post("/api/chat", response_model=ChatMessageResponse)
+async def api_chat_post(
+    body: dict[str, Any] = Body(...),
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Post to the general chat and broadcast it on SSE (``chat_message``)."""
+    text = str(body.get("text") or "")
+    if not text.strip():
+        raise HTTPException(400, "text is required")
+    # #191 — best-effort link preview: a dead/slow URL never blocks the post.
+    msg = _store.add_global_message(
+        current_user.get("username", ""), text, _attachment(body),
+        _store.build_preview(text),
+    )
+    await sse_manager.broadcast(
+        "chat_message",
+        {"vault": _store.GLOBAL_VAULT, "path": _store.GLOBAL_PATH, "message": msg},
+    )
+    return {"message": msg, "status": "ok"}
+
+
+@router.post("/api/chat/upload")
+async def api_chat_upload(
+    file: UploadFile = File(...),
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Store an image/video attachment (#190). Returns ``{attachment}``."""
+    data = await file.read()
+    try:
+        info = _store.save_attachment(file.filename or "", data)
+    except ValueError as e:
+        raise HTTPException(400, str(e)) from e
+    return {"attachment": info}
+
+
+@router.get("/api/chat/attachment/{name}")
+async def api_chat_attachment(name: str, current_user: dict[str, Any] = Depends(require_auth)):
+    """Serve an uploaded attachment (name validated against the allow-list)."""
+    path = _store.attachment_path(name)
+    if not path:
+        raise HTTPException(404, "Attachment not found")
+    info = _store._MIME_BY_EXT.get(path.suffix.lower(), "application/octet-stream")
+    return FileResponse(str(path), media_type=info)
+
+
+# --- #191 : suppression + messages privés -----------------------------------
+
+def _owner_or_admin(msg_user: str, current_user: dict[str, Any]) -> None:
+    """A post may be deleted by its author or by an admin."""
+    if current_user.get("role") != "admin" and current_user.get("username") != msg_user:
+        raise HTTPException(403, "Seul l'auteur ou un administrateur peut supprimer ce message")
+
+
+def _find_and_authorize(vault: str, path: str, message_id: str, current_user: dict[str, Any]) -> dict[str, Any]:
+    """Locate *message_id* in the conversation and check the delete right."""
+    for m in _store.get_messages(vault, path):
+        if m.get("id") == message_id:
+            _owner_or_admin(m.get("user", ""), current_user)
+            return m
+    raise HTTPException(404, "Message not found")
+
+
+@router.delete("/api/chat/{message_id}", response_model=StatusResponse)
+async def api_chat_delete(message_id: str, current_user: dict[str, Any] = Depends(require_auth)):
+    """Delete a message from the general chat (author or admin, #191)."""
+    _find_and_authorize(_store.GLOBAL_VAULT, _store.GLOBAL_PATH, message_id, current_user)
+    if not _store.delete_message(_store.GLOBAL_VAULT, _store.GLOBAL_PATH, message_id):
+        raise HTTPException(404, "Message not found")
+    await sse_manager.broadcast(
+        "chat_deleted",
+        {"vault": _store.GLOBAL_VAULT, "path": _store.GLOBAL_PATH, "id": message_id},
+    )
+    return {"status": "deleted"}
+
+
+@router.get("/api/chat/users", response_model=list[dict[str, Any]])
+async def api_chat_users(current_user: dict[str, Any] = Depends(require_auth)):
+    """Usernames available for a private conversation (chat DM picker, #191).
+
+    Every authenticated member may see who else is around — this is a
+    self-hosted portal, not a directory that needs hiding.
+    """
+    me = current_user.get("username", "")
+    return [
+        {"username": u.get("username", ""), "display_name": u.get("display_name") or u.get("username", "")}
+        for u in get_all_users()
+        if u.get("username") and u.get("username") != me
+    ]
+
+
+def _dm_peer(username: str, current_user: dict[str, Any]) -> str:
+    """Validate the DM peer exists and is not ourselves."""
+    if not username or username == current_user.get("username"):
+        raise HTTPException(400, "Destinataire invalide")
+    if not get_user(username):
+        raise HTTPException(404, "Utilisateur inconnu")
+    return username
+
+
+@router.get("/api/chat/dm/{username}", response_model=ChatHistoryResponse)
+async def api_chat_dm_history(username: str, current_user: dict[str, Any] = Depends(require_auth)):
+    """Private history with *username* (#191)."""
+    peer = _dm_peer(username, current_user)
+    return {
+        "messages": _store.get_dm_messages(current_user["username"], peer),
+        "read": _store.get_read(_store.DM_VAULT, _store.dm_path(current_user["username"], peer)),
+    }
+
+
+@router.post("/api/chat/dm/{username}", response_model=ChatMessageResponse)
+async def api_chat_dm_post(
+    username: str,
+    body: dict[str, Any] = Body(...),
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Post a private message and broadcast it to both participants (#191)."""
+    peer = _dm_peer(username, current_user)
+    text = str(body.get("text") or "")
+    if not text.strip():
+        raise HTTPException(400, "text is required")
+    msg = _store.add_dm_message(
+        current_user["username"], peer, current_user.get("username", ""), text,
+        _attachment(body), _store.build_preview(text),
+    )
+    # Same shape as the general chat so the client routes on vault/path.
+    await sse_manager.broadcast(
+        "chat_message",
+        {"vault": _store.DM_VAULT, "path": _store.dm_path(current_user["username"], peer), "message": msg},
+    )
+    return {"message": msg, "status": "ok"}
+
+
+@router.delete("/api/chat/dm/{username}/{message_id}", response_model=StatusResponse)
+async def api_chat_dm_delete(
+    username: str,
+    message_id: str,
+    current_user: dict[str, Any] = Depends(require_auth),
+):
+    """Delete one private message (author or admin, #191)."""
+    peer = _dm_peer(username, current_user)
+    vault, path = _store.DM_VAULT, _store.dm_path(current_user["username"], peer)
+    _find_and_authorize(vault, path, message_id, current_user)
+    if not _store.delete_message(vault, path, message_id):
+        raise HTTPException(404, "Message not found")
+    await sse_manager.broadcast(
+        "chat_deleted", {"vault": vault, "path": path, "id": message_id}
+    )
+    return {"status": "deleted"}

backend/routers/files_read.py

@@ -45,9 +45,46 @@ from backend.services.files import read_raw_file
 from backend.services.mutations import file_revision
 from backend.services.paths import resolve_safe_path
 from backend.services.vaults import browse_directory, get_vault_root
+from backend.share import list_shares
 
 logger = logging.getLogger("obsigate")
 
+
+def _resolve_shared_file(vault_name: str, path: str, username: str | None):
+    """#196 — resolve ``home-<user>/Partage/<file>`` to the real source file.
+
+    Returns ``(real_vault, real_path)`` when *path* is a received share
+    mounted in the user's personal folder, else ``None``. Read-only: only a
+    recipient (or the share creator, whose own file is already accessible)
+    gets a mapping — a share directed to someone else never resolves here.
+
+    Chemin canonique : ``Partage/<token>/<nom>`` (token = lève l'ambiguïté
+    de deux partages au même nom). Fallback par nom seul pour les liens
+    ne transportant pas le token.
+    """
+    if not username or not vault_name.startswith("home-") or not path.startswith("Partage/"):
+        return None
+    owner = vault_name[len("home-"):]
+    if owner != username:
+        return None
+    # Chemin virtuel canonique : Partage/<token>/<nom> — le token lève
+    # l'ambiguïté (deux partages, même nom de base). Fallback : match par
+    # nom pour les liens ne portant pas le token.
+    rest = path.split("/", 1)[1]
+    parts = rest.split("/", 1)
+    if len(parts) == 2 and len(parts[0]) >= 20:  # token (64 hex) vs nom de fichier
+        token, _name = parts
+        for s in list_shares(user=username):
+            if s.get("token") == token and s.get("created_by") != username:
+                return s["vault"], s["path"]
+        return None
+    for s in list_shares(user=username):
+        if s.get("created_by") == username:
+            continue
+        if (s.get("path") or "").split("/")[-1] == rest:
+            return s["vault"], s["path"]
+    return None
+
 # Map file extensions to highlight.js language hints
 EXT_TO_LANG = {
     ".py": "python", ".js": "javascript", ".ts": "typescript",
@@ -104,7 +141,11 @@ async def api_file_raw(vault_name: str, path: str = Query(..., description="Rela
     Returns:
         ``FileRawResponse`` with vault, path, and raw text content.
     """
-    if not check_vault_access(vault_name, current_user):
+    shared = _resolve_shared_file(vault_name, path, current_user.get("username"))
+    if shared:
+        # Partage dirigé = autorisation (cf. api_file).
+        vault_name, path = shared
+    elif not check_vault_access(vault_name, current_user):
         raise HTTPException(status_code=403, detail=f"Accès refusé à la vault '{vault_name}'")
     return read_raw_file(vault_name, path)
 
@@ -120,7 +161,11 @@ async def api_file_download(vault_name: str, path: str = Query(..., description=
     Returns:
         ``FileResponse`` with ``application/octet-stream`` content-type.
     """
-    if not check_vault_access(vault_name, current_user):
+    shared = _resolve_shared_file(vault_name, path, current_user.get("username"))
+    if shared:
+        # Partage dirigé = autorisation (cf. api_file).
+        vault_name, path = shared
+    elif not check_vault_access(vault_name, current_user):
         raise HTTPException(status_code=403, detail=f"Accès refusé à la vault '{vault_name}'")
     vault_data = get_vault_data(vault_name)
     if not vault_data:
@@ -166,12 +211,11 @@ async def api_file_backlinks(
     if not vault_data:
         raise HTTPException(status_code=404, detail=f"Vault '{vault_name}' not found")
 
-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])
     backlinks = get_backlinks(vault_name, path)
 
-    # Filter by user-accessible vaults
-    if "*" not in user_vaults:
-        backlinks = [b for b in backlinks if b["vault"] in user_vaults]
+    # Filter by user-accessible vaults (#194 : check_vault_access, "*" sans
+    # les dossiers persos).
+    backlinks = [b for b in backlinks if check_vault_access(b["vault"], current_user)]
 
     return {
         "vault": vault_name,
@@ -306,8 +350,18 @@ async def api_file(vault_name: str, path: str = Query(..., description="Relative
     Returns:
         ``FileContentResponse`` with HTML, metadata, and tags.
     """
-    if not check_vault_access(vault_name, current_user):
+    # #196 — fichier reçu par partage dirigé : home-<user>/Partage/<fichier>
+    # est résolu vers le fichier source (lecture seule, viewer standard).
+    # Résolu AVANT l'ACL vault : le dossier est virtuel, l'autorisation réelle
+    # est l'appartenance au partage (vérifiée dans le resolver).
+    shared = _resolve_shared_file(vault_name, path, current_user.get("username"))
+    if shared:
+        # Le partage dirigé EST l'autorisation : le destinataire n'a par
+        # définition pas accès au vault source — on ne passe PAS par l'ACL.
+        vault_name, path = shared
+    elif not check_vault_access(vault_name, current_user):
         raise HTTPException(status_code=403, detail=f"Accès refusé à la vault '{vault_name}'")
+
     vault_data = get_vault_data(vault_name)
     if not vault_data:
         raise HTTPException(status_code=404, detail=f"Vault '{vault_name}' not found")
@@ -648,7 +702,7 @@ async def api_file(vault_name: str, path: str = Query(..., description="Relative
         tags = _extract_tags(post)
 
         title = post.metadata.get("title", file_path.stem.replace("-", " ").replace("_", " "))
-        html_content = _render_markdown(post.content, vault_name, file_path)
+        html_content = _render_markdown(post.content, vault_name, file_path, click_to_copy=True)
 
         return {
             "vault": vault_name,

backend/routers/files_write.py

@@ -115,6 +115,15 @@ async def api_file_save(
     content = body.get("content", "")
     result = service_edit_file(vault_name, path, content, backup=backup)
 
+    # #197 (synchro TikTak) : rafraîchir l'index de façon synchrone pour une
+    # cohérence read-after-write — un client qui liste juste après le save
+    # doit voir le nouveau mtime/size sans attendre le watcher.
+    await update_single_file(vault_name, result["path"])
+
+    # #198 : la sauvegarde texte émet file_modified (événement clé pour tirer
+    # les retours de synchro côté TikTak en phase 3).
+    await dispatch_webhooks("file_modified", {"vault": vault_name, "path": result["path"]})
+
     # Audit log
     client_ip = current_user.get("_request_ip", "unknown")
     log_file_save(current_user["username"], vault_name, path, len(content), client_ip)
@@ -323,9 +332,13 @@ def api_file_xlsx_style(
 
     ``ops`` is an ordered list applied in one locked, atomic rewrite:
     ``cell`` (``sheet``, ``range``/``cell``, ``style`` with ``bold``,
-    ``italic``, ``underline``, ``font_color``/``fill_color`` as ``#rrggbb``,
-    ``align`` and ``number_format``), ``merge``/``unmerge`` (``range``),
-    ``col_width`` (``col``, ``width``), ``row_height`` (``row``, ``height``)
+    ``italic``, ``underline``, ``strike``, ``font_size`` (6-72),
+    ``font_color``/``fill_color`` as ``#rrggbb``, ``align``
+    (left/center/right/justify), ``valign`` (top/middle/bottom), ``wrap``,
+    ``rotation`` (-90..90), ``border`` (all/outer/none) + ``border_style`` /
+    ``border_color`` and ``number_format``), ``merge``/``unmerge`` (``range``),
+    ``col_width`` (``col``, ``width``), ``row_height`` (``row``, ``height``),
+    ``comment_set`` (``ref``, ``text``) / ``comment_clear`` (``ref``)
     and ``freeze`` (``cell``, empty to release).
 
     Without ``force`` the call fails **409** ``xlsx_lossy_content`` when the
@@ -548,6 +561,10 @@ async def api_file_create(
 
     Returns:
         FileCreateResponse confirming creation.
+
+    Note:
+        A ``.xlsx`` path creates an empty workbook (one ``Feuille1`` sheet) built
+        with openpyxl: the payload is binary, so ``content`` is ignored (#186).
     """
     if not check_vault_access(vault_name, current_user):
         raise HTTPException(status_code=403, detail=f"Accès refusé à la vault '{vault_name}'")

backend/routers/history.py

@@ -59,7 +59,6 @@ async def api_recent(limit: int | None = Query(None), vault: str | None = Query(
 @router.get("/api/bookmarks", response_model=BookmarksResponse)
 async def api_bookmarks(vault: str | None = Query(None), current_user=Depends(require_auth)):
     username = current_user.get("username")
-    user_vaults = current_user.get("_token_vaults") or current_user.get("vaults", [])
 
     if not username:
         return {"files": []}
@@ -68,7 +67,8 @@ async def api_bookmarks(vault: str | None = Query(None), current_user=Depends(re
     files_resp = []
     for item in history:
         v_name = item["vault"]
-        if "*" not in user_vaults and v_name not in user_vaults:
+        # #194 : check_vault_access — "*" n'inclut pas les dossiers persos.
+        if not check_vault_access(v_name, current_user):
             continue
 
         # Find in index to get metadata

backend/routers/notify.py

@@ -0,0 +1,96 @@
+"""External notification channels endpoints (#168).
+
+Channel CRUD is admin-only (secrets involved); sending a test notification
+requires authentication. Responses mask secrets (``***`` + ``has_secret``).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Body, Depends, HTTPException
+from pydantic import BaseModel, ConfigDict, Field
+
+from backend import notify as _notify
+from backend.auth.middleware import require_admin, require_auth
+from backend.schemas import StatusResponse
+
+router = APIRouter(prefix="/api/notify", tags=["notify"])
+
+
+class NotifyChannel(BaseModel):
+    """Public view of a notification channel (secrets masked)."""
+
+    model_config = ConfigDict(extra="allow")
+    id: str = Field(description="Channel id")
+    name: str = Field(description="Display name")
+    type: str = Field(description="discord | telegram | smtp | webhook")
+    enabled: bool = Field(description="Whether the channel receives broadcasts")
+    config: dict[str, Any] = Field(description="Channel config (secrets masked)")
+    has_secret: bool = Field(description="True when a secret is configured")
+
+
+class NotifySendResult(BaseModel):
+    """Outcome of a test send / broadcast."""
+
+    model_config = ConfigDict(extra="allow")
+    ok: bool = Field(description="True when every delivery succeeded")
+    deliveries: list[dict[str, Any]] = Field(default_factory=list)
+
+
+@router.get("/channels", response_model=list[NotifyChannel])
+async def api_notify_list(current_user=Depends(require_admin)):
+    """List notification channels (admin)."""
+    return _notify.list_channels()
+
+
+@router.post("/channels", response_model=NotifyChannel)
+async def api_notify_create(body: dict = Body(...), current_user=Depends(require_admin)):
+    """Create a channel (``{name, type, config}``). Secrets go to the secret store."""
+    try:
+        return _notify.create_channel(
+            str(body.get("name") or ""),
+            str(body.get("type") or ""),
+            dict(body.get("config") or {}),
+        )
+    except ValueError as e:
+        raise HTTPException(400, str(e)) from e
+
+
+@router.patch("/channels/{channel_id}", response_model=NotifyChannel)
+async def api_notify_update(channel_id: str, body: dict = Body(...), current_user=Depends(require_admin)):
+    """Update a channel (name / enabled / config)."""
+    try:
+        result = _notify.update_channel(channel_id, body)
+    except ValueError as e:
+        raise HTTPException(400, str(e)) from e
+    if result is None:
+        raise HTTPException(404, "Channel not found")
+    return result
+
+
+@router.delete("/channels/{channel_id}", response_model=StatusResponse)
+async def api_notify_delete(channel_id: str, current_user=Depends(require_admin)):
+    """Delete a channel and its secret."""
+    if not _notify.delete_channel(channel_id):
+        raise HTTPException(404, "Channel not found")
+    return {"status": "deleted"}
+
+
+@router.post("/test", response_model=NotifySendResult)
+async def api_notify_test(body: dict = Body(...), current_user=Depends(require_auth)):
+    """Send a test notification (broadcast or single ``channel_id``)."""
+    title = str(body.get("title") or "Test ObsiGate")
+    message = str(body.get("message") or "Notification de test.")
+    channel_id = str(body.get("channel_id") or "")
+    if channel_id:
+        channel = next((c for c in _notify._read_channels() if c.get("id") == channel_id), None)
+        if channel is None:
+            raise HTTPException(404, "Channel not found")
+        try:
+            _notify.send_via_channel(channel, title, message, "manual")
+        except Exception as e:
+            raise HTTPException(502, f"Envoi échoué : {e}") from e
+        return {"ok": True, "deliveries": [{"channel_id": channel_id, "ok": True}]}
+    deliveries = _notify.broadcast("manual", title, message)
+    return {"ok": all(d.get("ok") for d in deliveries), "deliveries": deliveries}

backend/routers/scheduler.py

@@ -0,0 +1,118 @@
+"""Scheduled tasks endpoints (#170).
+
+Tasks reuse the existing mutation/notification services — this router only
+validates, persists and triggers. File-writing actions check vault access
+at creation time; the background tick re-checks nothing (system context) but
+records failures and notifies on ``schedule_failure`` (#168).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Body, Depends, HTTPException
+from pydantic import BaseModel, ConfigDict, Field
+
+from backend import scheduler as _scheduler
+from backend.auth.middleware import check_vault_access, require_auth
+from backend.schemas import StatusResponse
+
+router = APIRouter(prefix="/api/scheduler", tags=["scheduler"])
+
+
+class ScheduledTask(BaseModel):
+    """A programmed automatic task."""
+
+    model_config = ConfigDict(extra="allow")
+    id: str = Field(description="Task id")
+    name: str = Field(description="Display name")
+    action: dict[str, Any] = Field(description="{kind, params}")
+    schedule: dict[str, Any] = Field(description="{kind, ...}")
+    enabled: bool = Field(description="Whether the tick executes it")
+    created_by: str = Field(description="Owner username")
+    created_at: str = Field(description="ISO-8601 creation time")
+    last_run_at: str | None = Field(default=None)
+    last_status: str | None = Field(default=None)
+    last_error: str | None = Field(default=None)
+    run_count: int = Field(default=0)
+    next_run_at: str = Field(description="ISO-8601 next due time")
+
+
+class TaskRunResult(BaseModel):
+    """Outcome of a manual or due run."""
+
+    model_config = ConfigDict(extra="allow")
+    task_id: str = Field(description="Task id")
+    ok: bool = Field(description="True on success")
+    result: dict[str, Any] | None = Field(default=None)
+    error: str | None = Field(default=None)
+
+
+def _check_action_vault(action: dict[str, Any], user: dict[str, Any]) -> None:
+    from backend.services.errors import ServiceError
+    from backend.services.vaults import get_vault_root
+
+    kind = (action or {}).get("kind")
+    params = (action or {}).get("params") or {}
+    if kind in ("create_file", "append_to_file"):
+        vault = str(params.get("vault") or "")
+        if not check_vault_access(vault, user):
+            raise HTTPException(403, f"No access to vault '{vault}'")
+        try:
+            get_vault_root(vault)
+        except ServiceError as e:
+            raise HTTPException(404, f"Unknown vault '{vault}'") from e
+
+
+@router.get("/tasks", response_model=list[ScheduledTask])
+async def api_scheduler_list(current_user: dict[str, Any] = Depends(require_auth)):
+    """List scheduled tasks (newest first)."""
+    return _scheduler.list_tasks()
+
+
+@router.post("/tasks", response_model=ScheduledTask)
+async def api_scheduler_create(body: dict = Body(...), current_user: dict[str, Any] = Depends(require_auth)):
+    """Create a task (``{name, action, schedule, enabled?}``)."""
+    action = dict(body.get("action") or {})
+    _check_action_vault(action, current_user)
+    try:
+        return _scheduler.create_task(
+            str(body.get("name") or ""),
+            action,
+            dict(body.get("schedule") or {}),
+            created_by=str(current_user.get("username", "api")),
+            enabled=bool(body.get("enabled", True)),
+        )
+    except ValueError as e:
+        raise HTTPException(400, str(e)) from e
+
+
+@router.patch("/tasks/{task_id}", response_model=ScheduledTask)
+async def api_scheduler_update(task_id: str, body: dict = Body(...), current_user: dict[str, Any] = Depends(require_auth)):
+    """Update a task (name / enabled / action / schedule)."""
+    if "action" in body:
+        _check_action_vault(dict(body["action"] or {}), current_user)
+    try:
+        result = _scheduler.update_task(task_id, body)
+    except ValueError as e:
+        raise HTTPException(400, str(e)) from e
+    if result is None:
+        raise HTTPException(404, "Task not found")
+    return result
+
+
+@router.delete("/tasks/{task_id}", response_model=StatusResponse)
+async def api_scheduler_delete(task_id: str, current_user: dict[str, Any] = Depends(require_auth)):
+    """Delete a task."""
+    if not _scheduler.delete_task(task_id):
+        raise HTTPException(404, "Task not found")
+    return {"status": "deleted"}
+
+
+@router.post("/tasks/{task_id}/run", response_model=TaskRunResult)
+async def api_scheduler_run(task_id: str, current_user: dict[str, Any] = Depends(require_auth)):
+    """Execute a task immediately (manual run)."""
+    try:
+        return _scheduler.run_task(task_id, manual=True)
+    except KeyError:
+        raise HTTPException(404, "Task not found") from None

backend/routers/search.py

@@ -82,7 +82,15 @@ async def api_search(
     # paginate in the shared service so routes and tools share the same logic.
     return await loop.run_in_executor(
         get_search_executor(),
-        partial(search_vaults, q, vault, tag, limit, offset),
+        # #194 : filtre par vault accessible AVANT pagination ("*" sans les
+        # dossiers persos) — sinon un user voyait les notes des autres.
+        # #196 : les documents reçus par partage dirigé sont ajoutés aux
+        # résultats (vault virtuel "home-<user>/Partage").
+        partial(
+            search_vaults, q, vault, tag, limit, offset,
+            is_allowed=lambda v: check_vault_access(v, current_user),
+            username=current_user["username"],
+        ),
     )
 
 

backend/routers/sharing.py

@@ -24,7 +24,8 @@ import frontmatter
 from fastapi import APIRouter, Body, Depends, HTTPException, Query, Request
 from fastapi.responses import FileResponse, HTMLResponse, Response
 
-from backend.auth.middleware import check_vault_access, require_auth
+from backend.auth.middleware import check_vault_access, get_current_user, require_auth
+from backend.auth.user_store import get_user
 from backend.indexer import get_vault_data, parse_markdown_file, update_single_file
 from backend.render import _render_markdown
 from backend.schemas import ShareModel, StatusResponse
@@ -53,6 +54,27 @@ except Exception:  # pragma: no cover - WeasyPrint/GTK missing
 router = APIRouter(tags=["sharing"])
 
 
+def _gate_share(share: dict | None, user: dict | None) -> dict:
+    """#196 — directed shares: auth + membership check for ``/s/*`` pages.
+
+    Public share (``shared_with`` empty) → pass-through, no auth required.
+    Directed share → requires an authenticated user who is the creator, an
+    admin, or listed in ``shared_with``. Anything else answers **404** (never
+    403) so an outsider cannot learn that a token exists.
+    """
+    if share is None:
+        raise HTTPException(404, "Share not found or expired")
+    recipients = share.get("shared_with") or []
+    if not recipients:
+        return share
+    if user is None:
+        raise HTTPException(404, "Share not found or expired")
+    if user["username"] == share.get("created_by") or user.get("role") == "admin" \
+            or user["username"] in recipients:
+        return share
+    raise HTTPException(404, "Share not found or expired")
+
+
 @router.post("/api/share/{vault_name}", response_model=ShareModel)
 async def api_share_create(
     vault_name: str,
@@ -66,9 +88,18 @@ async def api_share_create(
     """
     if not check_vault_access(vault_name, current_user):
         raise HTTPException(403, f"Accès refusé à la vault '{vault_name}'")
-    path = body.get("path", "")
+    path = body.get("path") or ""
+    if not path:
+        raise HTTPException(400, "Chemin de fichier requis")
     expires = body.get("expires_in_hours")
-    share = create_share(vault_name, path, current_user["username"], expires)
+    # #196 — directed share: validate recipients before creating anything.
+    recipients = body.get("shared_with") or []
+    if not isinstance(recipients, list):
+        raise HTTPException(400, "shared_with doit être une liste d'utilisateurs")
+    for name in recipients:
+        if not isinstance(name, str) or not get_user(name):
+            raise HTTPException(400, f"Utilisateur inconnu : {name}")
+    share = create_share(vault_name, path, current_user["username"], expires, recipients)
     share["url"] = f"/s/{share['token']}"
 
     # Set publish: true in the file's frontmatter
@@ -94,8 +125,13 @@ async def api_share_create(
 
 @router.get("/api/shares", response_model=list[ShareModel])
 async def api_shares_list(vault: str | None = Query(None), current_user=Depends(require_auth)):
-    """List all shares (optionally filtered by vault)."""
-    shares = list_shares(vault)
+    """List shares (optionally filtered by vault).
+
+    #196 : un non-admin ne voit que SES partages (créés ou reçus) ; un admin
+    voit tout (comportement historique).
+    """
+    username = None if current_user.get("role") == "admin" else current_user["username"]
+    shares = list_shares(vault, username)
     for s in shares:
         s["url"] = f"/s/{s['token']}"
     return shares
@@ -103,6 +139,12 @@ async def api_shares_list(vault: str | None = Query(None), current_user=Depends(
 
 @router.delete("/api/share/{share_id}", response_model=StatusResponse)
 async def api_share_revoke(share_id: str, current_user=Depends(require_auth)):
+    # #196 — only the creator or an admin may revoke; a recipient cannot.
+    from backend.share import _read
+    share = _read()["shares"].get(share_id)
+    if share and current_user.get("role") != "admin" \
+            and share.get("created_by") != current_user["username"]:
+        raise HTTPException(403, "Seul le créateur du partage peut le révoquer")
     if not revoke_share(share_id):
         raise HTTPException(404, "Share not found")
     return {"status": "revoked"}
@@ -113,13 +155,12 @@ async def api_share_revoke(share_id: str, current_user=Depends(require_auth)):
     response_class=Response,
     responses={200: {"content": {"application/pdf": {}}, "description": "Shared document as PDF"}},
 )
-async def public_share_pdf_download(token: str):
+async def public_share_pdf_download(token: str, current_user=Depends(get_current_user)):
     """Download shared document as real PDF via WeasyPrint."""
     if generate_pdf is None:
         raise HTTPException(501, "PDF export unavailable (WeasyPrint/GTK not available)")
     share = get_share_by_token(token)
-    if not share:
-        raise HTTPException(404, "Share not found or expired")
+    share = _gate_share(share, current_user)
     vault_data = get_vault_data(share["vault"])
     if not vault_data:
         raise HTTPException(404, "Vault not found")
@@ -147,11 +188,10 @@ async def public_share_pdf_download(token: str):
 
 
 @router.get("/s/{token}/raw", response_class=FileResponse)
-async def public_share_raw(token: str):
+async def public_share_raw(token: str, current_user=Depends(get_current_user)):
     """Download the raw (original) shared document."""
     share = get_share_by_token(token)
-    if not share:
-        raise HTTPException(404, "Share not found or expired")
+    share = _gate_share(share, current_user)
     vault_data = get_vault_data(share["vault"])
     if not vault_data:
         raise HTTPException(404, "Vault not found")
@@ -164,13 +204,12 @@ async def public_share_raw(token: str):
 
 
 @router.get("/s/{token}", response_class=HTMLResponse)
-async def public_share_view(request: Request, token: str):
-    """Public share view — no authentication required."""
+async def public_share_view(request: Request, token: str, current_user=Depends(get_current_user)):
+    """Public share view — no authentication required (unless directed #196)."""
     from backend.csp import inject_csp_nonce
 
     share = get_share_by_token(token)
-    if not share:
-        raise HTTPException(404, "Share not found or expired")
+    share = _gate_share(share, current_user)
     vault_data = get_vault_data(share["vault"])
     if not vault_data:
         raise HTTPException(404, "Vault not found")

backend/routers/vaults.py

@@ -55,6 +55,11 @@ async def api_add_vault(body: dict = Body(...), current_user=Depends(require_adm
 
     stats = await add_vault_to_index(name, vault_path)
 
+    # #194 : persister, sinon ce vault disparaît au prochain rebuild/redémarrage.
+    from backend.indexer import persist_vault
+
+    persist_vault(name)
+
     # Start watching the new vault
     watcher = get_watcher()
     if watcher:
@@ -80,6 +85,10 @@ async def api_remove_vault(vault_name: str, current_user=Depends(require_admin))
         await watcher.remove_vault(vault_name)
 
     await remove_vault_from_index(vault_name)
+    # #194 : plus de trace au redémarrage (les vaults d'env, eux, reviennent).
+    from backend.indexer import unpersist_vault
+
+    unpersist_vault(vault_name)
     await sse_manager.broadcast("vault_removed", {"vault": vault_name})
     return {"status": "ok", "vault": vault_name}
 

backend/routers/webhooks.py

@@ -34,7 +34,9 @@ async def api_webhooks_create(body: dict = Body(...), current_user=Depends(requi
     secret = body.get("secret")
     if not url:
         raise HTTPException(400, "URL is required")
-    return create_webhook(name, url, events, secret)
+    # #198 : filtres optionnels vault / path_prefix (None = tout recevoir).
+    return create_webhook(name, url, events, secret,
+                          vault=body.get("vault"), path_prefix=body.get("path_prefix"))
 
 
 @router.patch("/{webhook_id}", response_model=WebhookModel)

backend/scheduler.py

@@ -0,0 +1,331 @@
+"""Scheduled tasks — automatic agent actions, type cron (#170).
+
+Tasks are persisted in ``data/scheduled_tasks.json`` (guarded by an RLock,
+same pattern as the other JSON stores). Supported actions reuse the existing
+mutation/notification services — no new write path:
+
+* ``create_file`` → ``backend.services.mutations.create_file``;
+* ``append_to_file`` → ``backend.services.mutations.append_to_file``;
+* ``notify`` → ``backend.notify.broadcast`` (trigger ``manual``).
+
+Supported schedules:
+
+* ``interval_hours`` — every N hours (N >= 0.25);
+* ``daily_time`` — once a day at ``HH:MM`` (local server time);
+* ``once_at`` — one shot at an ISO-8601 datetime (past = due immediately).
+
+On failure the task records ``last_error`` and a ``schedule_failure``
+broadcast is emitted to the notification channels (#168) — best effort,
+never recursive (a failing ``notify`` action does not rebroadcast).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+import uuid
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("obsigate.scheduler")
+
+DATA_DIR = Path(os.environ.get("OBSIGATE_DATA_DIR", "data"))
+TASKS_FILE = DATA_DIR / "scheduled_tasks.json"
+
+ACTION_KINDS = ("create_file", "append_to_file", "notify")
+SCHEDULE_KINDS = ("interval_hours", "daily_time", "once_at")
+
+_lock = threading.RLock()
+
+
+# ── Store ──────────────────────────────────────────────────────────────────
+
+
+def _read_tasks() -> list[dict[str, Any]]:
+    if not TASKS_FILE.exists():
+        return []
+    try:
+        data = json.loads(TASKS_FILE.read_text(encoding="utf-8"))
+        return data if isinstance(data, list) else []
+    except (json.JSONDecodeError, OSError):
+        return []
+
+
+def _write_tasks(tasks: list[dict[str, Any]]) -> None:
+    TASKS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    tmp = TASKS_FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(tasks, indent=2, default=str), encoding="utf-8")
+    tmp.replace(TASKS_FILE)
+
+
+def list_tasks() -> list[dict[str, Any]]:
+    """Return all scheduled tasks (newest first)."""
+    return sorted(_read_tasks(), key=lambda t: t.get("created_at", ""), reverse=True)
+
+
+def get_task(task_id: str) -> dict[str, Any] | None:
+    """Return one task by id, or None."""
+    for task in _read_tasks():
+        if task.get("id") == task_id:
+            return task
+    return None
+
+
+# ── Validation ─────────────────────────────────────────────────────────────
+
+
+def _validate_action(action: dict[str, Any]) -> dict[str, Any]:
+    kind = action.get("kind")
+    if kind not in ACTION_KINDS:
+        raise ValueError(f"Action inconnue : {kind} (attendu : {', '.join(ACTION_KINDS)})")
+    params = dict(action.get("params") or {})
+    if kind in ("create_file", "append_to_file"):
+        if not str(params.get("vault") or "").strip():
+            raise ValueError("params.vault requis pour create_file/append_to_file")
+        if not str(params.get("path") or "").strip():
+            raise ValueError("params.path requis pour create_file/append_to_file")
+        if kind == "append_to_file" and not str(params.get("content") or ""):
+            raise ValueError("params.content requis pour append_to_file")
+    elif kind == "notify":
+        if not str(params.get("title") or "").strip():
+            raise ValueError("params.title requis pour notify")
+        if not str(params.get("message") or "").strip():
+            raise ValueError("params.message requis pour notify")
+    return {"kind": kind, "params": params}
+
+
+def _validate_schedule(schedule: dict[str, Any]) -> dict[str, Any]:
+    kind = schedule.get("kind")
+    if kind not in SCHEDULE_KINDS:
+        raise ValueError(f"Planification inconnue : {kind} (attendu : {', '.join(SCHEDULE_KINDS)})")
+    if kind == "interval_hours":
+        hours = float(schedule.get("hours") or 0)
+        if hours < 0.25:
+            raise ValueError("hours doit être >= 0.25")
+        return {"kind": kind, "hours": hours}
+    if kind == "daily_time":
+        at = str(schedule.get("at") or "").strip()
+        try:
+            datetime.strptime(at, "%H:%M")
+        except ValueError:
+            raise ValueError("at doit être au format HH:MM (ex. 08:30)") from None
+        return {"kind": kind, "at": at}
+    # once_at
+    at = str(schedule.get("at") or "").strip()
+    try:
+        parsed = datetime.fromisoformat(at)
+        if parsed.tzinfo is None:
+            parsed = parsed.replace(tzinfo=timezone.utc)
+    except ValueError:
+        raise ValueError("at doit être une date ISO-8601 (ex. 2026-10-05T08:30:00)") from None
+    return {"kind": kind, "at": parsed.isoformat()}
+
+
+# ── CRUD ───────────────────────────────────────────────────────────────────
+
+
+def create_task(
+    name: str,
+    action: dict[str, Any],
+    schedule: dict[str, Any],
+    *,
+    created_by: str = "api",
+    enabled: bool = True,
+) -> dict[str, Any]:
+    """Create a scheduled task. Raises ValueError on invalid action/schedule."""
+    validated_action = _validate_action(action)
+    validated_schedule = _validate_schedule(schedule)
+    now = datetime.now(timezone.utc)
+    with _lock:
+        tasks = _read_tasks()
+        task = {
+            "id": str(uuid.uuid4()),
+            "name": (name or validated_action["kind"]).strip() or validated_action["kind"],
+            "action": validated_action,
+            "schedule": validated_schedule,
+            "enabled": bool(enabled),
+            "created_by": created_by,
+            "created_at": now.isoformat(),
+            "last_run_at": None,
+            "last_status": None,
+            "last_error": None,
+            "run_count": 0,
+            "next_run_at": compute_next_run(
+                {"schedule": validated_schedule, "last_run_at": None}, now
+            ).isoformat(),
+        }
+        tasks.append(task)
+        _write_tasks(tasks)
+    logger.info(f"Scheduled task created: '{task['name']}' ({validated_schedule['kind']})")
+    return task
+
+
+def update_task(task_id: str, updates: dict[str, Any]) -> dict[str, Any] | None:
+    """Update name/enabled/action/schedule. Returns None when unknown."""
+    with _lock:
+        tasks = _read_tasks()
+        for task in tasks:
+            if task.get("id") != task_id:
+                continue
+            if updates.get("name"):
+                task["name"] = str(updates["name"])
+            if "enabled" in updates:
+                task["enabled"] = bool(updates["enabled"])
+            if "action" in updates:
+                task["action"] = _validate_action(updates["action"])
+            if "schedule" in updates:
+                task["schedule"] = _validate_schedule(updates["schedule"])
+            task["next_run_at"] = compute_next_run(task).isoformat()
+            _write_tasks(tasks)
+            return task
+    return None
+
+
+def delete_task(task_id: str) -> bool:
+    """Delete a task. Returns False when unknown."""
+    with _lock:
+        tasks = _read_tasks()
+        remaining = [t for t in tasks if t.get("id") != task_id]
+        if len(remaining) == len(tasks):
+            return False
+        _write_tasks(remaining)
+    return True
+
+
+# ── Scheduling ─────────────────────────────────────────────────────────────
+
+
+def compute_next_run(task: dict[str, Any], now: datetime | None = None) -> datetime:
+    """Compute the next due datetime for *task*."""
+    now = now or datetime.now(timezone.utc)
+    if now.tzinfo is None:
+        now = now.replace(tzinfo=timezone.utc)
+    schedule = task.get("schedule", {})
+    kind = schedule.get("kind")
+    last_run_at = task.get("last_run_at")
+    last = None
+    if last_run_at:
+        try:
+            last = datetime.fromisoformat(str(last_run_at))
+            if last.tzinfo is None:
+                last = last.replace(tzinfo=timezone.utc)
+        except ValueError:
+            last = None
+    if kind == "interval_hours":
+        hours = float(schedule.get("hours", 24))
+        base = last or now
+        nxt = base + timedelta(hours=hours)
+        # Première planification : due dès maintenant + intervalle ? Non —
+        # la tâche démarre au prochain intervalle, sauf retard déjà accumulé.
+        if last is None:
+            nxt = now + timedelta(hours=hours)
+        return max(now, nxt)
+    if kind == "daily_time":
+        hour, minute = (str(schedule.get("at", "08:00")) + ":00").split(":")[:2]
+        candidate = now.replace(hour=int(hour), minute=int(minute), second=0, microsecond=0)
+        if candidate <= now:
+            candidate += timedelta(days=1)
+        return candidate
+    if kind == "once_at":
+        try:
+            at = datetime.fromisoformat(str(schedule.get("at")))
+            if at.tzinfo is None:
+                at = at.replace(tzinfo=timezone.utc)
+        except ValueError:
+            return now
+        if task.get("last_run_at"):
+            return datetime.max.replace(tzinfo=timezone.utc)  # déjà exécutée
+        return at
+    return now + timedelta(hours=24)
+
+
+def _execute_action(task: dict[str, Any]) -> dict[str, Any]:
+    action = task["action"]
+    kind = action["kind"]
+    params = action["params"]
+    if kind == "create_file":
+        from backend.services.mutations import create_file
+
+        return create_file(
+            params["vault"],
+            params["path"],
+            params.get("content", ""),
+            overwrite=bool(params.get("overwrite", False)),
+        )
+    if kind == "append_to_file":
+        from backend.services.mutations import append_to_file
+
+        return append_to_file(params["vault"], params["path"], params.get("content", ""))
+    if kind == "notify":
+        from backend.notify import broadcast
+
+        results = broadcast("manual", str(params["title"]), str(params.get("message", "")))
+        return {"broadcast": results}
+    raise ValueError(f"Action inconnue : {kind}")
+
+
+def run_task(task_id: str, *, manual: bool = False) -> dict[str, Any]:
+    """Execute one task now (manual or due). Records status; notifies on failure."""
+    with _lock:
+        tasks = _read_tasks()
+        task = next((t for t in tasks if t.get("id") == task_id), None)
+        if task is None:
+            raise KeyError(task_id)
+        if not task.get("enabled", True) and not manual:
+            return {"task_id": task_id, "skipped": True, "reason": "disabled"}
+        try:
+            result = _execute_action(task)
+            task["last_run_at"] = datetime.now(timezone.utc).isoformat()
+            task["last_status"] = "ok"
+            task["last_error"] = None
+            task["run_count"] = int(task.get("run_count", 0)) + 1
+            if task.get("schedule", {}).get("kind") == "once_at":
+                task["enabled"] = False  # one-shot consommé
+            task["next_run_at"] = compute_next_run(task).isoformat()
+            _write_tasks(tasks)
+            if manual:
+                from backend.notify import broadcast
+
+                broadcast("schedule_success", f"Tâche « {task['name']} » OK", "Exécution manuelle réussie.")
+            return {"task_id": task_id, "ok": True, "result": result}
+        except Exception as e:
+            task["last_run_at"] = datetime.now(timezone.utc).isoformat()
+            task["last_status"] = "error"
+            task["last_error"] = str(e)
+            task["run_count"] = int(task.get("run_count", 0)) + 1
+            task["next_run_at"] = compute_next_run(task).isoformat()
+            _write_tasks(tasks)
+            logger.warning(f"Scheduled task '{task.get('name')}' failed: {e}")
+            if task["action"]["kind"] != "notify":
+                try:
+                    from backend.notify import broadcast
+
+                    broadcast(
+                        "schedule_failure",
+                        f"Échec tâche « {task.get('name')} »",
+                        f"{e}",
+                    )
+                except Exception:
+                    logger.debug("Failure notification broadcast failed", exc_info=True)
+            return {"task_id": task_id, "ok": False, "error": str(e)}
+
+
+def tick(now: datetime | None = None) -> list[dict[str, Any]]:
+    """Run every due task. Returns per-task outcomes (empty when idle)."""
+    now = now or datetime.now(timezone.utc)
+    outcomes: list[dict[str, Any]] = []
+    for task in _read_tasks():
+        if not task.get("enabled", True):
+            continue
+        try:
+            next_run = datetime.fromisoformat(str(task.get("next_run_at") or ""))
+            if next_run.tzinfo is None:
+                next_run = next_run.replace(tzinfo=timezone.utc)
+        except ValueError:
+            next_run = compute_next_run(task, now)
+        if next_run <= now:
+            outcomes.append(run_task(task["id"]))
+    return outcomes

backend/schemas.py

@@ -151,6 +151,54 @@ class BacklinksResponse(BaseModel):
     total: int
 
 
+class ChatMessageItem(BaseModel):
+    """One chat message (``GET/POST /api/file/{vault}/chat`` + ``/api/chat``)."""
+
+    id: str = Field(description="Message id")
+    user: str = Field(description="Author username")
+    text: str = Field(description="Message body")
+    ts: float = Field(description="Unix timestamp")
+    attachment: dict[str, Any] | None = Field(
+        default=None,
+        description="Optional image/video/url attachment {name, url, mime, kind}",
+    )
+    preview: dict[str, Any] | None = Field(
+        default=None,
+        description="Link preview card {url, title, description, image, site} (#191)",
+    )
+    html: str = Field(
+        default="",
+        description=(
+            "Rendered (mistune + sanitized) HTML of ``text``, like a document "
+            "preview — tables, lists, fenced code blocks (#193)"
+        ),
+    )
+
+
+class ChatHistoryResponse(BaseModel):
+    """Response for ``GET /api/file/{vault}/chat``."""
+
+    messages: list[ChatMessageItem] = Field(description="Messages, chronological")
+    read: dict[str, float] = Field(
+        default_factory=dict,
+        description="{username: last read unix ts} per participant (#192)",
+    )
+
+
+class ChatReadResponse(BaseModel):
+    """Response for ``POST /api/chat/read`` (#192 read receipts)."""
+
+    read: dict[str, float] = Field(description="{username: last read unix ts}")
+    status: str = Field(description="'ok'")
+
+
+class ChatMessageResponse(BaseModel):
+    """Response for ``POST /api/file/{vault}/chat``."""
+
+    message: ChatMessageItem
+    status: str = Field(description="'ok'")
+
+
 class BackupsListResponse(BaseModel):
     """Response for ``GET /api/backups``."""
 
@@ -252,6 +300,8 @@ class BrowseItem(BaseModel):
     children_count: int | None = Field(default=None, description="Number of children (directories only)")
     size: int | None = Field(default=None, description="File size in bytes")
     extension: str | None = Field(default=None, description="File extension")
+    modified: float | None = Field(default=None, description="Modification time, epoch seconds (#197)")
+    modified_iso: str | None = Field(default=None, description="Modification time, ISO 8601 (#197)")
 
 
 class BrowseResponse(BaseModel):
@@ -563,13 +613,15 @@ class BookmarkToggleRequest(BaseModel):
 class SearchResultItem(BaseModel):
     """A single search result."""
 
+    model_config = ConfigDict(extra="allow")
     vault: str = Field(description="Vault name")
     path: str = Field(description="Relative file path")
     title: str = Field(description="File title")
     tags: list[str] = Field(description="File tags")
     score: int = Field(description="Relevance score")
     snippet: str = Field(description="Content excerpt with highlights")
-    modified: str = Field(description="ISO 8601 modification timestamp")
+    modified: str | None = Field(default=None, description="ISO 8601 modification timestamp")
+    share_token: str | None = Field(default=None, description="#196 token de partage dirigé (document reçu)")
 
 
 class SearchResponse(BaseModel):
@@ -617,6 +669,9 @@ class VaultPathEntry(BaseModel):
     path: str = Field(description="Full relative path")
     name: str = Field(description="File or directory name")
     type: str = Field(description="'file' or 'directory'")
+    size: int | None = Field(default=None, description="File size in bytes (#197, files only)")
+    mtime: float | None = Field(default=None, description="Modification time, epoch seconds (#197, files only)")
+    mtime_iso: str | None = Field(default=None, description="Modification time, ISO 8601 (#197, files only)")
 
 
 class VaultPathsResponse(BaseModel):
@@ -992,6 +1047,8 @@ class WebhookModel(BaseModel):
     enabled: bool = True
     created_at: str | None = None
     last_fired_at: str | None = None
+    vault: str | None = Field(default=None, description="#198 vault filter (None = all vaults)")
+    path_prefix: str | None = Field(default=None, description="#198 path-prefix filter (None = whole vault)")
 
 
 class ShareModel(BaseModel):
@@ -1008,6 +1065,7 @@ class ShareModel(BaseModel):
     expires_at: str | None = None
     access_count: int = 0
     last_accessed: str | None = None
+    shared_with: list[str] = Field(default_factory=list, description="#196 destinataires (partage dirigé)")
 
 
 class ConflictEntry(BaseModel):

backend/secret_redactor.py

@@ -1,48 +1,104 @@
 """
 Secret redactor: masks sensitive patterns in rendered text.
 
-Scans for common secret patterns and replaces them with [MASQUÉ]
-before content is served to the frontend. Prevents accidental
-exposure of API keys, tokens, and passwords in previews.
+Scans for common secret patterns and replaces them with a French mask
+label (``[CLÉ API MASQUÉE]``, ``[MOT DE PASSE MASQUÉ]``, …) before content
+is served to the frontend. Prevents accidental exposure of API keys,
+tokens, and passwords in previews.
 
 Patterns detected:
-    - Generic API keys (long alphanumeric strings with key/secret/token prefix)
+    - Generic API keys (``api_key=…``, ``token: …`` — values of 8+ chars)
+    - Passwords (``password=…``, ``"passwd": "…"`` — any length)
     - JWT tokens (eyJ... base64url)
-    - AWS-style keys (AKIA..., sk-..., etc.)
+    - Provider key formats: OpenAI/Anthropic/OpenRouter (``sk-``), Stripe,
+      GitLab, Google (``AIza…`` / ``ya29.``), AWS, GitHub, Slack, SendGrid,
+      Hugging Face, npm, Docker, Resend, Square, Atlassian, Discord,
+      Telegram, ``Bearer …`` tokens
     - Private key blocks (-----BEGIN ... PRIVATE KEY-----)
     - Connection strings with passwords
+    - Bare hex secrets next to a secret keyword (BUG-035)
+
+Interactive masking (feature #188): :func:`redact_with_placeholders`
+returns the text with every mask replaced by an opaque placeholder plus
+the list of ``(label, secret)`` entries; :func:`restore_masks` turns the
+placeholders back into plain labels (public shares, PDF exports, AI
+context) or into clickable ``<span class="secret-mask" data-secret="…">``
+badges (authenticated app preview) so a click copies the real value to
+the clipboard.
 """
 
+from __future__ import annotations
+
+import html as _html
 import logging
 import re
 
 logger = logging.getLogger("obsigate.redactor")
 
 # --- Patterns ---
-# Order matters: more specific patterns first
-_PATTERNS = [
+# Each entry is ``(pattern, replacement, secret_group)``:
+#   * ``replacement``: a literal label, a ``\\1``-style template, or a
+#     callable receiving the match and returning the visible label;
+#   * ``secret_group``: index of the group holding the value that a click
+#     copies to the clipboard (feature #188).
+_PATTERNS: list[tuple[re.Pattern[str], object, int]] = [
     # Private key blocks
-    (re.compile(r'-----BEGIN (?:RSA |EC |DSA |OPENSSH |ENCRYPTED )?PRIVATE KEY-----.*?-----END (?:RSA |EC |DSA |OPENSSH |ENCRYPTED )?PRIVATE KEY-----', re.DOTALL), '[CLÉ PRIVÉE MASQUÉE]'),
-    
+    (re.compile(r'-----BEGIN (?:RSA |EC |DSA |OPENSSH |ENCRYPTED )?PRIVATE KEY-----.*?-----END (?:RSA |EC |DSA |OPENSSH |ENCRYPTED )?PRIVATE KEY-----', re.DOTALL), '[CLÉ PRIVÉE MASQUÉE]', 0),
+
     # JWT tokens (base64url encoded, starts with eyJ)
-    (re.compile(r'eyJ[a-zA-Z0-9_-]{20,}\.[a-zA-Z0-9_-]{20,}\.[a-zA-Z0-9_-]{20,}'), '[JWT MASQUÉ]'),
-    
+    (re.compile(r'eyJ[a-zA-Z0-9_-]{20,}\.[a-zA-Z0-9_-]{20,}\.[a-zA-Z0-9_-]{20,}'), '[JWT MASQUÉ]', 0),
+
     # Connection strings with passwords
-    (re.compile(r'(?:mongodb|mysql|postgres(?:ql)?|redis|sqlite)://[^:]+:[^@\s]+@'), '[CONNECTION_STRING MASQUÉE]'),
-    
-    # Generic API key patterns: key=... or token=... or secret=...
-    (re.compile(r'(?:api[_-]?key|apikey|secret|token|password|passwd|auth[_-]?token)\s*[:=]\s*[\'"]?([^\s\'"]{20,})[\'"]?', re.IGNORECASE),
-     lambda m: f'{m.group(0).split("=")[0].split(":")[0]}=[MASQUÉ]' if "=" in m.group(0) or ":" in m.group(0) else '[MASQUÉ]'),
-    
-    # Prefixed API keys (sk-..., pk-..., rk-...)
-    (re.compile(r'(?:sk|pk|rk)-[a-zA-Z0-9]{20,}'), '[CLÉ API MASQUÉE]'),
-    
-    # AWS access keys
-    (re.compile(r'AKIA[0-9A-Z]{16}'), '[AWS_KEY MASQUÉ]'),
-    
+    (re.compile(r'(?:mongodb|mysql|postgres(?:ql)?|redis|sqlite)://[^:]+:[^@\s]+@'), '[CONNECTION_STRING MASQUÉE]', 0),
+
+    # Passwords — any length, bare or quoted (``password=…``,
+    # ``"passwd": "…"``). The left side may carry a qualifier
+    # (``db_password``, ``DATABASE.PASSWORD``, ``user_pwd``); a *bare*
+    # ``PWD=`` (shell working directory) must NOT match, hence ``pwd``
+    # only in its qualified branch.
+    (re.compile(
+        r'(?i)((?:[A-Za-z0-9_.-]*(?:password|passwd|passphrase|mot\s+de\s+passe)'
+        r'|[A-Za-z0-9_.-]+pwd)["\']?\s*[:=]\s*["\']?)([^\s"\',;]{4,})'),
+     r'\1[MOT DE PASSE MASQUÉ]', 2),
+
+    # Generic API key assignments: api_key=…, token=…, secret=… — values
+    # of 8+ characters (short enough to catch real keys, long enough to
+    # skip plain words).
+    (re.compile(r'(?i)([A-Za-z0-9_.-]*(?:api[_-]?key|apikey|secret|token|auth[_-]?token)["\']?\s*[:=]\s*["\']?)([^\s\'"]{8,})'),
+     lambda m: f'{m.group(1)}[MASQUÉ]' if ("=" in m.group(0) or ":" in m.group(0)) else '[MASQUÉ]', 2),
+
     # GitHub tokens (ghp_, gho_, ghu_, ghs_, ghr_)
-    (re.compile(r'gh[pousr]_[a-zA-Z0-9]{36,}'), '[GITHUB_TOKEN MASQUÉ]'),
-    
+    (re.compile(r'gh[pousr]_[a-zA-Z0-9]{36,}'), '[GITHUB_TOKEN MASQUÉ]', 0),
+
+    # AWS access keys
+    (re.compile(r'(?:AKIA|ASIA)[0-9A-Z]{16}'), '[AWS_KEY MASQUÉ]', 0),
+
+    # Provider key formats (feature #188) — one alternation covering the
+    # large majority of token shapes in the wild.
+    (re.compile(
+        r'(?<![A-Za-z0-9])(?:'
+        r'sk-[A-Za-z0-9_\-]{16,}'                  # OpenAI / Anthropic / OpenRouter
+        r'|sk_(?:live|test)_[A-Za-z0-9]{10,}'      # Stripe secret key
+        r'|pk_(?:live|test)_[A-Za-z0-9]{10,}'      # Stripe publishable key
+        r'|whsec_[A-Za-z0-9]{16,}'                 # Stripe / Svix webhook secret
+        r'|glpat-[A-Za-z0-9_\-]{20,}'              # GitLab personal access token
+        r'|github_pat_[A-Za-z0-9_]{22,}'           # GitHub fine-grained PAT
+        r'|npm_[A-Za-z0-9]{36}'                    # npm automation token
+        r'|dckr_pat_[A-Za-z0-9_\-]{20,}'           # Docker Hub token
+        r'|hf_[A-Za-z0-9]{30,}'                    # Hugging Face token
+        r'|AIza[0-9A-Za-z_\-]{35}'                 # Google API key
+        r'|ya29\.[0-9A-Za-z_\-]{20,}'              # Google OAuth access token
+        r'|xox[baprs]-[0-9A-Za-z\-]{10,}'          # Slack token
+        r'|SG\.[A-Za-z0-9_\-]{16,}'                # SendGrid API key
+        r'|re_[A-Za-z0-9]{40}'                     # Resend API key
+        r'|sq0[a-z]{3}-[A-Za-z0-9_\-]{16,}'        # Square access token
+        r'|ATATT[A-Za-z0-9_\-]{20,}'               # Atlassian access token
+        r'|[NOP][A-Za-z0-9_\-]{23,28}\.[A-Za-z0-9_\-]{6}\.[A-Za-z0-9_\-]{27,}'  # Discord bot token
+        r'|\d{8,10}:[A-Za-z0-9_\-]{35}'            # Telegram bot token
+        r'|Bearer\s+[A-Za-z0-9._~+/=\-]{20,}'      # Authorization: Bearer …
+        r')'),
+     '[CLÉ API MASQUÉE]', 0),
+
 ]
 
 # BUG-035: bare 40–64 char hex strings used to be redacted unconditionally,
@@ -61,14 +117,23 @@ _HASH_CONTEXT_RE = re.compile(
 #: How far before the hex string a keyword may appear to count as context.
 _HEX_CONTEXT_WINDOW = 60
 
+# --- Interactive masking (feature #188) ---
+# Private-use-area sentinels: they survive markdown rendering (mistune
+# treats them as plain text, fenced code blocks included) and are
+# stripped by ``backend.render._heading_slugify``.
+_PLACEHOLDER_OPEN = "\uE000"
+_PLACEHOLDER_CLOSE = "\uE001"
+_PLACEHOLDER_RE = re.compile("\uE000(\\d+)\uE001")
 
-def _redact_bare_hex_secrets(text: str) -> tuple:
+
+def _redact_bare_hex_secrets(text: str, mask) -> tuple[str, int]:
     """Redact 40–64 char hex strings only when a secret keyword is nearby.
 
     Git/SHA/checksum contexts are left untouched (BUG-035).
 
     Args:
         text: Text to scan.
+        mask: ``mask(original, label) -> str`` replacement builder.
 
     Returns:
         (redacted_text, redaction_count) tuple.
@@ -82,12 +147,38 @@ def _redact_bare_hex_secrets(text: str) -> tuple:
             return match.group(0)
         if _SECRET_CONTEXT_RE.search(window):
             count += 1
-            return '[HEX_KEY MASQUÉ]'
+            return mask(match.group(0), '[HEX_KEY MASQUÉ]')
         return match.group(0)
 
     return _HEX_RE.sub(_replace, text), count
 
 
+def _redact(text: str, mask) -> tuple[str, int]:
+    """Apply every pattern; ``mask(original, label) -> str`` builds the
+    replacement (plain label, or placeholder for the interactive mode)."""
+    count = 0
+    result = text
+    for pattern, replacement, secret_group in _PATTERNS:
+
+        def _sub(match: re.Match, replacement=replacement, secret_group=secret_group) -> str:
+            if callable(replacement):
+                label = replacement(match)
+            else:
+                label = match.expand(str(replacement))
+            return mask(match.group(secret_group), label)
+
+        new_result, n = pattern.subn(_sub, result)
+        count += n
+        result = new_result
+    result, hex_count = _redact_bare_hex_secrets(result, mask)
+    return result, count + hex_count
+
+
+def _plain_mask(original: str, label: str) -> str:
+    """Plain masking: only the visible label survives."""
+    return label
+
+
 def redact(text: str) -> tuple:
     """Redact sensitive patterns from text.
 
@@ -97,22 +188,84 @@ def redact(text: str) -> tuple:
     Returns:
         (redacted_text, redaction_count) tuple.
     """
-    count = 0
-    result = text
-    for pattern, replacement in _PATTERNS:
-        if callable(replacement):
-            new_result, n = pattern.subn(replacement, result)
-        else:
-            new_result, n = pattern.subn(str(replacement), result)
-        count += n
-        result = new_result
-    result, hex_count = _redact_bare_hex_secrets(result)
-    count += hex_count
+    result, count = _redact(text, _plain_mask)
     if count > 0:
         logger.info(f"Redacted {count} secret(s) from content")
     return result, count
 
 
+def redact_with_placeholders(text: str, file_path: str = "") -> tuple[str, list[tuple[str, str]]]:
+    """Redact *text*, replacing every mask with an opaque placeholder.
+
+    Used by the markdown rendering pipeline: placeholders survive the
+    markdown → HTML conversion (fenced code blocks included, where a
+    literal ``<span>`` would be shown as text), then
+    :func:`restore_masks` turns them back into labels or clickable badges.
+
+    Args:
+        text: The raw text content to scan.
+        file_path: Optional file path for logging context.
+
+    Returns:
+        (text_with_placeholders, entries) where *entries* is the list of
+        ``(label, secret)`` tuples referenced by the placeholders, in
+        order of appearance.
+    """
+    entries: list[tuple[str, str]] = []
+
+    def mask(original: str, label: str) -> str:
+        entries.append((label, original))
+        return f"{_PLACEHOLDER_OPEN}{len(entries) - 1}{_PLACEHOLDER_CLOSE}"
+
+    result, count = _redact(text, mask)
+    if count > 0:
+        logger.warning(f"Redacted {count} potential secret(s) from {file_path or '<unknown>'}")
+    return result, entries
+
+
+def restore_masks(
+    text: str,
+    entries: list[tuple[str, str]],
+    *,
+    click_to_copy: bool = False,
+) -> str:
+    """Turn placeholders produced by :func:`redact_with_placeholders` back
+    into visible masks.
+
+    Args:
+        text: Rendered HTML still containing placeholders.
+        entries: The ``(label, secret)`` list returned alongside.
+        click_to_copy: When True (authenticated app preview), each mask
+            becomes ``<span class="secret-mask" data-secret="…">label</span>``
+            so a click copies the real value. When False (public shares,
+            PDF exports), only the plain label is restored — the secret
+            never reaches the page.
+
+    Returns:
+        The text with every placeholder replaced.
+    """
+    if not entries:
+        return text
+
+    def _sub(match: re.Match) -> str:
+        idx = int(match.group(1))
+        if idx >= len(entries):
+            return ""
+        label, original = entries[idx]
+        label_esc = _html.escape(str(label), quote=False)
+        if not click_to_copy:
+            return label_esc
+        return (
+            '<span class="secret-mask" data-secret="'
+            + _html.escape(str(original), quote=True)
+            + '">'
+            + label_esc
+            + "</span>"
+        )
+
+    return _PLACEHOLDER_RE.sub(_sub, text)
+
+
 def redact_file_content(content: str, file_path: str = "") -> str:
     """Redact a file's content for preview rendering.
 

backend/services/duplicates.py

@@ -0,0 +1,215 @@
+"""Duplicate detection & merge services (#166).
+
+Single source of truth consumed by the REST routes
+(``/api/duplicates``) and the AI tool layer (``find_duplicates``,
+``merge_duplicate_notes``).
+
+Method is deterministic stdlib-only: frontmatter stripped, token-set
+Jaccard blended with a title similarity. No embedding dependency —
+the semantic index (#70) stays an optional refinement, not a requirement.
+
+Fusion never runs without an explicit confirmation: the tool layer
+registers the merge as ``DANGEROUS`` (two-step propose/apply) and this
+service takes an automatic backup before any destructive write.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from difflib import SequenceMatcher
+from pathlib import Path
+from typing import Any
+
+from backend.services.backups import create_backup
+from backend.services.errors import ServiceError
+from backend.services.paths import resolve_safe_path
+from backend.services.vaults import get_vault_root
+
+logger = logging.getLogger("obsigate.services.duplicates")
+
+MAX_FILES_SCANNED = 500
+MAX_FILE_BYTES = 200_000
+MAX_CONTENT_CHARS = 50_000
+
+_WORD_RE = re.compile(r"[\w]+", re.UNICODE)
+_FRONTMATTER_RE = re.compile(r"\A---\s*\n.*?\n---\s*\n", re.DOTALL)
+
+
+def _strip_frontmatter(text: str) -> str:
+    """Remove a leading YAML frontmatter block, if present."""
+    return _FRONTMATTER_RE.sub("", text, count=1)
+
+
+def _tokens(text: str) -> set[str]:
+    """Lowercase word tokens (keeps accents), stop-words free but tiny tokens dropped."""
+    return {t for t in _WORD_RE.findall(text.lower()) if len(t) > 2}
+
+
+def similarity_score(a: str, b: str) -> float:
+    """Blend Jaccard (0.7) + title/first-line similarity (0.3) in [0, 1].
+
+    Pure function — unit-tested directly.
+    """
+    ta, tb = _tokens(_strip_frontmatter(a)), _tokens(_strip_frontmatter(b))
+    if not ta or not tb:
+        return 0.0
+    jaccard = len(ta & tb) / len(ta | tb)
+    head_a = (a.strip().splitlines() or [""])[:1][0][:200].lower()
+    head_b = (b.strip().splitlines() or [""])[:1][0][:200].lower()
+    title_sim = SequenceMatcher(None, head_a, head_b).ratio() if head_a and head_b else 0.0
+    return round(0.7 * jaccard + 0.3 * title_sim, 4)
+
+
+def _iter_markdown_files(root: Path, subdir: str = "") -> list[Path]:
+    base = resolve_safe_path(root, subdir) if subdir else root.resolve()
+    if not base.exists() or not base.is_dir():
+        raise ServiceError(
+            f"Directory not found: {subdir or '.'}",
+            code="not_found",
+            status=404,
+            details={"path": subdir},
+        )
+    files = sorted(
+        (p for p in base.rglob("*.md") if p.is_file() and not p.is_symlink()),
+        key=lambda p: str(p),
+    )
+    return files[:MAX_FILES_SCANNED]
+
+
+def _read_capped(path: Path) -> str:
+    try:
+        if path.stat().st_size > MAX_FILE_BYTES:
+            return ""
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+    return text[:MAX_CONTENT_CHARS]
+
+
+def find_duplicate_pairs(
+    vault: str,
+    threshold: float = 0.75,
+    limit: int = 50,
+    subdir: str = "",
+) -> dict[str, Any]:
+    """Return candidate duplicate pairs ordered by descending score.
+
+    Args:
+        vault: Vault name.
+        threshold: Minimum blended score in [0.3, 1.0].
+        limit: Max pairs returned (1-200).
+        subdir: Optional vault-relative directory scope.
+    """
+    if not 0.3 <= threshold <= 1.0:
+        raise ServiceError(
+            "threshold must be between 0.3 and 1.0",
+            code="invalid_arguments",
+            status=400,
+        )
+    limit = max(1, min(limit, 200))
+    root = get_vault_root(vault)
+    files = _iter_markdown_files(root, subdir)
+    contents: dict[str, str] = {}
+    token_sets: dict[str, set[str]] = {}
+    for path in files:
+        rel = str(path.relative_to(root)).replace("\\", "/")
+        text = _read_capped(path)
+        if not text.strip():
+            continue
+        contents[rel] = text
+        token_sets[rel] = _tokens(_strip_frontmatter(text))
+
+    rels = sorted(contents)
+    pairs: list[dict[str, Any]] = []
+    for i in range(len(rels)):
+        for j in range(i + 1, len(rels)):
+            a, b = rels[i], rels[j]
+            ta, tb = token_sets[a], token_sets[b]
+            if not ta or not tb:
+                continue
+            # Cheap pre-filter: Jaccard lower bound before the full score.
+            inter = len(ta & tb)
+            union = len(ta | tb)
+            if union == 0 or inter / union < threshold * 0.6:
+                continue
+            score = similarity_score(contents[a], contents[b])
+            if score >= threshold:
+                pairs.append({"file_a": a, "file_b": b, "score": score})
+    pairs.sort(key=lambda p: p["score"], reverse=True)
+    return {
+        "vault": vault,
+        "threshold": threshold,
+        "files_scanned": len(contents),
+        "truncated": len(files) >= MAX_FILES_SCANNED,
+        "pairs": pairs[:limit],
+    }
+
+
+def merge_duplicates(
+    vault: str,
+    source_path: str,
+    target_path: str,
+    strategy: str = "append",
+) -> dict[str, Any]:
+    """Merge *source_path* into *target_path*, then delete the source.
+
+    Strategies:
+        ``append`` — source content appended after target (separator + origin
+        marker), source deleted.
+        ``prefer_target`` — source deleted, target untouched (dedupe only).
+        ``prefer_source`` — target overwritten with source content, source deleted.
+
+    A backup of both files is taken first; the source deletion also goes
+    through the backup-aware mutation service.
+    """
+    from backend.services import mutations as _mutations
+
+    if strategy not in ("append", "prefer_target", "prefer_source"):
+        raise ServiceError(
+            f"Unknown strategy: {strategy}",
+            code="invalid_arguments",
+            status=400,
+        )
+    if source_path == target_path:
+        raise ServiceError(
+            "source_path and target_path must differ",
+            code="invalid_arguments",
+            status=400,
+        )
+    root = get_vault_root(vault)
+    src = resolve_safe_path(root, source_path)
+    dst = resolve_safe_path(root, target_path)
+    if not src.is_file() or src.suffix.lower() != ".md":
+        raise ServiceError(
+            f"Source not found: {source_path}",
+            code="not_found",
+            status=404,
+            details={"path": source_path},
+        )
+    if not dst.is_file() or dst.suffix.lower() != ".md":
+        raise ServiceError(
+            f"Target not found: {target_path}",
+            code="not_found",
+            status=404,
+            details={"path": target_path},
+        )
+    # Backup préalable (jamais de fusion sans filet — critère #166).
+    create_backup(src, vault, source_path)
+    create_backup(dst, vault, target_path)
+
+    if strategy == "prefer_target":
+        result = _mutations.delete_file(vault, source_path)
+        return {"strategy": strategy, "target": target_path, "deleted": source_path, "delete": result}
+    if strategy == "prefer_source":
+        content = src.read_text(encoding="utf-8", errors="replace")
+        result = _mutations.edit_file(vault, target_path, content)
+        deleted = _mutations.delete_file(vault, source_path)
+        return {"strategy": strategy, "target": target_path, "edit": result, "deleted": source_path, "delete": deleted}
+    # append
+    target_text = dst.read_text(encoding="utf-8", errors="replace")
+    source_text = src.read_text(encoding="utf-8", errors="replace")
+    merged = target_text.rstrip() + f"\n\n---\n\n_Fusionné depuis `{source_path}` (#166)_\n\n" + source_text.lstrip()
+    result = _mutations.edit_file(vault, target_path, merged)
+    deleted = _mutations.delete_file(vault, source_path)
+    return {"strategy": strategy, "target": target_path, "edit": result, "deleted": source_path, "delete": deleted}

backend/services/mutations.py

@@ -41,6 +41,28 @@ _EXCALIDRAW_SKELETON = (
     '"appState":{"viewBackgroundColor":"#ffffff"},"files":{}}'
 )
 
+# Title of the single sheet of a workbook created from scratch (#186).
+_XLSX_DEFAULT_SHEET = "Feuille1"
+
+
+def _empty_xlsx_bytes() -> bytes:
+    """Return the bytes of a valid, empty single-sheet workbook.
+
+    An ``.xlsx`` is a ZIP archive (OPC), not a text file: writing ``""`` to it
+    produces a file no reader (and no spreadsheet application) can open. The
+    "Create a file" modal posts an empty text payload, so the archive itself is
+    built here with openpyxl.
+    """
+    import io
+
+    from openpyxl import Workbook
+
+    wb = Workbook()
+    wb.active.title = _XLSX_DEFAULT_SHEET
+    buffer = io.BytesIO()
+    wb.save(buffer)
+    return buffer.getvalue()
+
 
 def _rel(root: Path, path: Path) -> str:
     """Return *path* relative to *root* as a POSIX-style string."""
@@ -98,13 +120,14 @@ def create_file(
     *,
     overwrite: bool = False,
 ) -> dict[str, Any]:
-    """Create a text file in a vault.
+    """Create a file in a vault.
 
     Args:
         vault_name: Name of the vault.
         path: Vault-relative path of the new file.
         content: Initial content (an Excalidraw skeleton is injected for empty
-            ``.excalidraw`` files).
+            ``.excalidraw`` files). ``.xlsx`` is binary: the workbook is always
+            built from scratch and *content* is ignored for that extension.
         overwrite: When True, replace an existing file (with a backup) instead
             of raising ``already_exists``.
 
@@ -130,17 +153,25 @@ def create_file(
             )
         create_backup(file_path, vault_name, _rel(root, file_path))
 
+    suffix = file_path.suffix.lower()
     try:
         file_path.parent.mkdir(parents=True, exist_ok=True)
-        if file_path.suffix.lower() == ".excalidraw" and not content.strip():
-            content = _EXCALIDRAW_SKELETON
-        file_path.write_text(content, encoding="utf-8")
+        if suffix == ".xlsx":
+            # Binary OPC archive: a text write would leave an unopenable file
+            # (#186). Written as bytes, so the size below is the byte count.
+            payload = _empty_xlsx_bytes()
+            file_path.write_bytes(payload)
+        else:
+            if suffix == ".excalidraw" and not content.strip():
+                content = _EXCALIDRAW_SKELETON
+            payload = content.encode("utf-8")
+            file_path.write_text(content, encoding="utf-8")
     except PermissionError as e:
         raise ServiceError("Permission denied: cannot create file", code="permission_denied", status=403) from e
 
     rel_path = _rel(root, file_path)
     logger.info(f"File created: {vault_name}/{rel_path}")
-    return {"success": True, "vault": vault_name, "path": rel_path, "size": len(content)}
+    return {"success": True, "vault": vault_name, "path": rel_path, "size": len(payload)}
 
 
 def create_directory(vault_name: str, path: str, *, exist_ok: bool = False) -> dict[str, Any]:
@@ -673,11 +704,42 @@ def mutate_xlsx_structure(
                                 "Position 'at' / 'count' invalides", code="invalid", status=400
                             )
                         if op == "row_insert":
-                            ws.insert_rows(at, count)
+                            # Le modèle sparse d'openpyxl ignore les inserts
+                            # au-delà de la dernière ligne utilisée (rien à
+                            # décaler), et l'écrivain abandonne les cellules
+                            # vides (None) au cycle suivant : on matérialise
+                            # avec " " (un blanc qui persiste, relu tel quel,
+                            # affiché vide, ignoré par la recherche) pour
+                            # qu'une insertion « sous la dernière ligne »
+                            # crée bien des lignes blanches, comme Excel.
+                            if at > ws.max_row:
+                                if at - ws.max_row > _INSERT_GAP_LIMIT:
+                                    raise ServiceError(
+                                        "Position trop éloignée de la fin de la feuille",
+                                        code="invalid", status=400,
+                                    )
+                                for r in range(at, at + count):
+                                    cell = ws.cell(row=r, column=1)
+                                    if cell.value is None:
+                                        cell.value = " "
+                            else:
+                                ws.insert_rows(at, count)
                         elif op == "row_delete":
                             ws.delete_rows(at, count)
                         elif op == "col_insert":
-                            ws.insert_cols(at, count)
+                            # Idem côté colonnes : « à droite de la dernière ».
+                            if at > ws.max_column:
+                                if at - ws.max_column > _INSERT_GAP_LIMIT:
+                                    raise ServiceError(
+                                        "Position trop éloignée de la fin de la feuille",
+                                        code="invalid", status=400,
+                                    )
+                                for c in range(at, at + count):
+                                    cell = ws.cell(row=1, column=c)
+                                    if cell.value is None:
+                                        cell.value = " "
+                            else:
+                                ws.insert_cols(at, count)
                         else:
                             ws.delete_cols(at, count)
                         applied.append(f"{op}:{sheet}@{at}x{count}")
@@ -725,16 +787,34 @@ def mutate_xlsx_structure(
 # #156-A8 — write-side formatting. Every value is data-driven (the colours
 # come from the caller, never from a hardcoded palette) and the whole batch
 # rides the same lock, backup and atomic swap as the cell edits.
+# Cap anti-DoS : une insertion au-delà de la fin matérialise des cellules,
+# jamais un gouffre de lignes/colonnes.
+_INSERT_GAP_LIMIT = 1000
 _STYLE_KEYS = {
     "bold",
     "italic",
     "underline",
+    "strike",
+    "font_size",
     "font_color",
     "fill_color",
     "align",
+    "valign",
+    "wrap",
+    "rotation",
+    "border",
+    "border_style",
+    "border_color",
     "number_format",
 }
-_STYLE_ALIGNS = {"left", "center", "right"}
+_STYLE_ALIGNS = {"left", "center", "right", "justify"}
+_STYLE_VALIGNS = {"top": "top", "middle": "center", "bottom": "bottom"}
+_STYLE_BORDERS = {"all", "outer", "none"}
+_STYLE_BORDER_STYLES = {
+    "thin", "medium", "thick", "dashed", "dotted", "double", "hair",
+    "mediumDashed", "dashDot", "mediumDashDot", "dashDotDot",
+    "mediumDashDotDot", "slantDashDot",
+}
 MAX_STYLE_CELLS = 10_000
 _HEX_COLOR_RE = re.compile(r"^#?[0-9a-fA-F]{6}$")
 
@@ -760,14 +840,14 @@ def _apply_cell_style(cell: Any, style: dict[str, Any]) -> None:
     """
     import copy as copy_mod
 
-    from openpyxl.styles import Alignment, Color, PatternFill
+    from openpyxl.styles import Alignment, Border, Color, PatternFill, Side
 
     unknown = set(style) - _STYLE_KEYS
     if unknown:
         raise ServiceError(
             f"Style inconnu: {sorted(unknown)}", code="invalid", status=400
         )
-    if {"bold", "italic", "underline", "font_color"} & set(style):
+    if {"bold", "italic", "underline", "strike", "font_size", "font_color"} & set(style):
         font = copy_mod.copy(cell.font)
         if "bold" in style:
             font.bold = bool(style["bold"])
@@ -775,6 +855,22 @@ def _apply_cell_style(cell: Any, style: dict[str, Any]) -> None:
             font.italic = bool(style["italic"])
         if "underline" in style:
             font.underline = "single" if style["underline"] else None
+        if "strike" in style:
+            font.strike = bool(style["strike"])
+        if "font_size" in style:
+            try:
+                size = float(style["font_size"])
+            except (TypeError, ValueError):
+                raise ServiceError(
+                    f"Taille de police invalide: {style['font_size']!r}",
+                    code="invalid", status=400,
+                ) from None
+            if not 6 <= size <= 72:
+                raise ServiceError(
+                    f"Taille de police hors bornes (6-72): {style['font_size']!r}",
+                    code="invalid", status=400,
+                )
+            font.size = size
         if "font_color" in style:
             rgb = _style_color(style["font_color"])
             font.color = Color(rgb=rgb) if rgb else None
@@ -797,7 +893,69 @@ def _apply_cell_style(cell: Any, style: dict[str, Any]) -> None:
             horizontal=align,
             vertical=getattr(current, "vertical", None),
             wrap_text=getattr(current, "wrap_text", None),
+            text_rotation=getattr(current, "text_rotation", None),
         )
+    if "valign" in style or "wrap" in style or "rotation" in style:
+        current = cell.alignment
+        vertical = getattr(current, "vertical", None)
+        wrap_text = getattr(current, "wrap_text", None)
+        text_rotation = getattr(current, "text_rotation", None) or 0
+        if "valign" in style:
+            valign = style["valign"]
+            if valign not in _STYLE_VALIGNS:
+                raise ServiceError(
+                    f"Alignement vertical invalide: {valign!r}", code="invalid", status=400
+                )
+            vertical = _STYLE_VALIGNS[valign]
+        if "wrap" in style:
+            wrap_text = bool(style["wrap"])
+        if "rotation" in style:
+            try:
+                rotation = int(style["rotation"])
+            except (TypeError, ValueError):
+                raise ServiceError(
+                    f"Rotation invalide: {style['rotation']!r}", code="invalid", status=400
+                ) from None
+            if not (-90 <= rotation <= 90 or rotation == 180):
+                raise ServiceError(
+                    f"Rotation hors bornes (-90..90, 180): {rotation!r}", code="invalid", status=400
+                )
+            # OOXML stocke les angles horaires sur 91..180 (-45° → 135).
+            # 180 = texte vertical retourné (le lecteur le relit tel quel).
+            text_rotation = rotation if rotation >= 0 else 180 + rotation
+        cell.alignment = Alignment(
+            horizontal=getattr(current, "horizontal", None),
+            vertical=vertical,
+            wrap_text=wrap_text,
+            text_rotation=text_rotation,
+        )
+    if {"border", "border_style", "border_color"} & set(style):
+        which = style.get("border", "all")
+        if which not in _STYLE_BORDERS:
+            raise ServiceError(
+                f"Bordure invalide: {which!r}", code="invalid", status=400
+            )
+        bstyle = style.get("border_style", "thin")
+        if bstyle not in _STYLE_BORDER_STYLES:
+            raise ServiceError(
+                f"Style de bordure invalide: {bstyle!r}", code="invalid", status=400
+            )
+        raw_color = style.get("border_color", "#000000")
+        if raw_color in (None, ""):
+            raw_color = "FF000000"
+        rgb = _style_color(raw_color)
+        if rgb is None:
+            raise ServiceError(
+                f"Couleur de bordure invalide: {style.get('border_color')!r}",
+                code="invalid", status=400,
+            )
+        if which == "none":
+            cell.border = Border()
+        else:
+            # `all` et `outer` se rendent pareil cellule par cellule : les
+            # bords partagés coïncident, le contour de la plage reste net.
+            side = Side(style=bstyle, color=rgb)
+            cell.border = Border(left=side, right=side, top=side, bottom=side)
     if "number_format" in style:
         fmt = style["number_format"] or "General"
         if not isinstance(fmt, str) or len(fmt) > 120:
@@ -821,12 +979,17 @@ def mutate_xlsx_style(
     ``ops`` is an ordered list (1 to 50) applied in one locked, atomic rewrite:
 
     * ``{"op": "cell", "sheet": "X", "range": "A1:B2", "style": {…}}`` with
-      ``bold``, ``italic``, ``underline``, ``font_color`` / ``fill_color``
-      (``#rrggbb``, ``""`` clears), ``align`` (left/center/right) and
+      ``bold``, ``italic``, ``underline``, ``strike``, ``font_size`` (6-72),
+      ``font_color`` / ``fill_color`` (``#rrggbb``, ``""`` clears),
+      ``align`` (left/center/right/justify), ``valign`` (top/middle/bottom),
+      ``wrap`` (bool), ``rotation`` (-90..90), ``border``
+      (all/outer/none) + ``border_style`` / ``border_color`` and
       ``number_format`` ;
     * ``{"op": "merge"|"unmerge", "sheet": "X", "range": "A1:B2"}`` ;
     * ``{"op": "col_width", "sheet": "X", "col": "A", "width": 24}`` ;
     * ``{"op": "row_height", "sheet": "X", "row": 3, "height": 30}`` ;
+    * ``{"op": "comment_set", "sheet": "X", "ref": "B2", "text": "…"}``
+      (``author`` optional) / ``{"op": "comment_clear", ...}`` ;
     * ``{"op": "freeze", "sheet": "X", "cell": "B2"}`` (``""`` releases).
 
     Same guards as the cell edits: per-file lock, ``.bak`` backup,
@@ -960,7 +1123,17 @@ def mutate_xlsx_style(
                             raise ServiceError(
                                 "Largeur invalide (0 à 255)", code="invalid", status=400
                             )
-                        ws.column_dimensions[col.strip().upper()].width = float(width)
+                        width = float(width)
+                        if width == 0:
+                            # 0 = largeur par défaut (équivalent « Default
+                            # Width » d'Excel / « Reset » de Sheets) : on
+                            # retire la mesure explicite au lieu d'écrire une
+                            # largeur de 0, qu'Excel lirait comme une colonne
+                            # quasi masquée pendant que l'affichage reste en
+                            # largeur automatique.
+                            ws.column_dimensions.pop(col.strip().upper(), None)
+                        else:
+                            ws.column_dimensions[col.strip().upper()].width = width
                         applied.append(f"col_width:{ws.title}!{col}={width}")
                     elif op == "row_height":
                         ws = _sheet(wb, action)
@@ -972,7 +1145,14 @@ def mutate_xlsx_style(
                             raise ServiceError(
                                 "Hauteur invalide (0 à 409)", code="invalid", status=400
                             )
-                        ws.row_dimensions[row].height = float(height)
+                        height = float(height)
+                        if height == 0:
+                            # 0 = hauteur par défaut (même logique que la
+                            # largeur ci-dessus) : la mesure explicite est
+                            # retirée, la ligne redevient automatique.
+                            ws.row_dimensions.pop(row, None)
+                        else:
+                            ws.row_dimensions[row].height = height
                         applied.append(f"row_height:{ws.title}!{row}={height}")
                     elif op == "freeze":
                         ws = _sheet(wb, action)
@@ -981,6 +1161,31 @@ def mutate_xlsx_style(
                             _range(cell_ref)
                         ws.freeze_panes = cell_ref.upper() or None
                         applied.append(f"freeze:{ws.title}!{cell_ref or '-'}")
+                    elif op in ("comment_set", "comment_clear"):
+                        from openpyxl.comments import Comment
+
+                        ws = _sheet(wb, action)
+                        ref = str(action.get("ref") or action.get("cell") or "")
+                        min_col, min_row, max_col, max_row = _range(ref)
+                        if (min_col, min_row) != (max_col, max_row):
+                            raise ServiceError(
+                                "Un commentaire vise une cellule (A1), pas une plage",
+                                code="invalid", status=400,
+                            )
+                        if op == "comment_clear":
+                            ws.cell(row=min_row, column=min_col).comment = None
+                        else:
+                            text = str(action.get("text") or "")
+                            if not text.strip() or len(text) > 2000:
+                                raise ServiceError(
+                                    "Texte de commentaire invalide (1 à 2000 caractères)",
+                                    code="invalid", status=400,
+                                )
+                            author = str(action.get("author") or "ObsiGate")[:64]
+                            ws.cell(row=min_row, column=min_col).comment = Comment(
+                                text, author
+                            )
+                        applied.append(f"{op}:{ws.title}!{ref}")
                     else:
                         raise ServiceError(
                             f"Action inconnue: {op!r}", code="invalid", status=400

backend/services/recent.py

@@ -12,6 +12,7 @@ import time
 from datetime import datetime
 from typing import Any
 
+from backend.auth.middleware import is_home_vault
 from backend.history import get_recent_opened, is_bookmarked
 from backend.indexer import find_file_in_index, index
 
@@ -31,6 +32,10 @@ def humanize_mtime(mtime: float) -> str:
 
 
 def _can_access(vault: str, user_vaults: list[str]) -> bool:
+    # #194 : un dossier perso ne bénéficie jamais de "*" (même règle que
+    # backend.auth.middleware.check_vault_access).
+    if is_home_vault(vault):
+        return vault in user_vaults
     return "*" in user_vaults or vault in user_vaults
 
 

backend/services/search.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import Any
 
 
@@ -11,15 +12,29 @@ def search_vaults(
     tag: str | None = None,
     limit: int = 50,
     offset: int = 0,
+    is_allowed: Callable[[str], bool] | None = None,
+    username: str | None = None,
 ) -> dict[str, Any]:
     """Full-text search with pagination, returned as the API response payload.
 
-    No permission filtering is applied here: callers that need it (the tool
-    layer) filter the ``results`` list themselves.
+    ``is_allowed`` (#194) filters the raw hits **before** pagination, so a
+    restricted vault set neither distorts ``total`` nor the returned page.
+    The tool layer filters on its own and leaves it as ``None``.
+
+    ``username`` (#196) : les documents **reçus** par cet utilisateur via un
+    partage dirigé sont ajoutés aux résultats (lecture seule, sans indexer
+    les fichiers d'autrui — le contenu est lu à la volée et mis en cache
+    TF-IDF côté index, pas sur disque).
     """
     from backend.search import search
 
     all_results = search(q, vault_filter=vault, tag_filter=tag)
+    if is_allowed is not None:
+        all_results = [r for r in all_results if is_allowed(r.get("vault", ""))]
+
+    if username is not None:
+        all_results = all_results + _shared_results(username, q, vault)
+
     total = len(all_results)
     page = all_results[offset: offset + limit]
     return {
@@ -34,6 +49,67 @@ def search_vaults(
     }
 
 
+def _shared_results(username: str, q: str, vault: str) -> list[dict[str, Any]]:
+    """Search results for documents shared TO *username* (#196).
+
+    Reads the shared file content on the fly (read-only, source vault on
+    disk) and returns hits shaped exactly like ordinary search results so
+    the frontend can open them via the normal share page.
+    """
+    from pathlib import Path
+
+    from backend.indexer import get_vault_data
+    from backend.services.paths import resolve_safe_path
+    from backend.share import list_shares
+
+    out: list[dict[str, Any]] = []
+    if not q:
+        return out
+    q_lower = q.lower()
+
+    for s in list_shares(user=username):
+        if s.get("created_by") == username:
+            continue  # own share — already indexed in its own vault
+        if vault not in ("all", f"home-{username}"):
+            continue
+        data = get_vault_data(s["vault"])
+        if not data:
+            continue
+        try:
+            fp = resolve_safe_path(Path(data["path"]), s["path"])
+            if not fp.exists() or fp.suffix.lower() != ".md":
+                continue
+            raw = fp.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            continue
+        title = fp.stem
+        occurrences = raw.lower().count(q_lower)
+        if q_lower in title.lower():
+            occurrences += 1
+        if occurrences == 0:
+            continue
+        out.append({
+            "vault": f"home-{username}",
+            "path": f"Partage/{fp.name}",
+            "title": title,
+            "tags": [],
+            "score": min(occurrences, 10),
+            "snippet": _snippet(raw, q_lower),
+            "modified": None,
+            "share_token": s["token"],
+        })
+    return out
+
+
+def _snippet(text: str, q_lower: str, width: int = 160) -> str:
+    """Small excerpt around the first match (#196, shared-file search)."""
+    idx = text.lower().find(q_lower)
+    if idx < 0:
+        return text[:width]
+    start = max(0, idx - width // 2)
+    return "…" + text[start:start + width].replace("\n", " ") + "…"
+
+
 def list_tags(vault: str | None = None) -> dict[str, int]:
     """Return tag → count, optionally restricted to a single vault."""
     from backend.search import get_all_tags
@@ -122,23 +198,51 @@ def list_paths(vault: str, limit: int = 5000) -> dict[str, Any]:
     once lets the client filter files/directories instantly instead of issuing
     a request per keystroke.
 
+    #197 (synchro TikTak) : chaque entrée fichier expose aussi ``size``,
+    ``mtime`` (epoch) et ``mtime_iso`` — un client externe peut détecter les
+    fichiers modifiés depuis un horodatage en **un seul appel**, sans relire
+    chaque fichier. Les valeurs viennent de l'index (source unique, même
+    contrat que ``list_all_files``) ; les répertoires portent ``None``.
+
     Args:
         vault: Vault name.
         limit: Maximum number of entries returned.
 
     Returns:
-        ``{"vault", "count", "results": [{vault, path, name, type}]}``.
+        ``{"vault", "count", "results": [{vault, path, name, type, size?,
+        mtime?, mtime_iso?}]}``.
     """
-    from backend.indexer import path_index
+    from datetime import datetime
+
+    from backend.indexer import get_vault_data, path_index
 
     entries = path_index.get(vault, [])
-    results = [
-        {
+    meta: dict[str, dict[str, Any]] = {}
+    data = get_vault_data(vault)
+    if data:
+        for info in data.get("files", []):
+            meta[info["path"]] = info
+
+    results = []
+    for entry in entries[: max(0, limit)]:
+        item: dict[str, Any] = {
             "vault": vault,
             "path": entry["path"],
             "name": entry["name"],
             "type": entry["type"],
+            "size": None,
+            "mtime": None,
+            "mtime_iso": None,
         }
-        for entry in entries[: max(0, limit)]
-    ]
+        info = meta.get(entry["path"])
+        if info is not None:
+            item["size"] = info.get("size")
+            iso = info.get("modified")
+            item["mtime_iso"] = iso
+            if iso:
+                try:
+                    item["mtime"] = datetime.fromisoformat(iso).timestamp()
+                except (ValueError, TypeError):
+                    item["mtime"] = None
+        results.append(item)
     return {"vault": vault, "count": len(results), "results": results}

backend/services/vaults.py

@@ -49,6 +49,8 @@ def get_vault_root(vault_name: str) -> Path:
 
 def browse_directory(vault_name: str, path: str = "") -> dict[str, Any]:
     """Return the direct children of a vault directory (directories first)."""
+    from datetime import datetime, timezone
+
     from backend.indexer import SUPPORTED_EXTENSIONS
     from backend.vault_settings import get_vault_setting
 
@@ -89,11 +91,14 @@ def browse_directory(vault_name: str, path: str = "") -> dict[str, Any]:
                     "children_count": file_count,
                 })
             elif entry.suffix.lower() in SUPPORTED_EXTENSIONS or entry.name.lower() in ("dockerfile", "makefile"):
+                stat = entry.stat()
                 items.append({
                     "name": entry.name,
                     "path": rel,
                     "type": "file",
-                    "size": entry.stat().st_size,
+                    "size": stat.st_size,
+                    "modified": stat.st_mtime,
+                    "modified_iso": datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat(),
                     "extension": entry.suffix.lower(),
                 })
     except PermissionError:

backend/share.py

@@ -44,8 +44,14 @@ def create_share(
     path: str,
     created_by: str,
     expires_in_hours: int | None = None,
+    shared_with: list[str] | None = None,
 ) -> dict:
-    """Create a new share token for a document."""
+    """Create a new share token for a document.
+
+    ``shared_with`` non vide (#196) : partage **dirigé** — la page ``/s/…``
+    exige alors une session et n'accepte que les destinataires listés (plus
+    le créateur et les admins). Vide/absent : comportement public inchangé.
+    """
     with _lock:
         data = _read()
         token = secrets.token_hex(32)  # 64-char hex token
@@ -64,6 +70,7 @@ def create_share(
             "expires_at": expires_at,
             "access_count": 0,
             "last_accessed": None,
+            "shared_with": list(shared_with) if shared_with else [],
         }
         data["shares"][token] = share
         _write(data)
@@ -107,10 +114,17 @@ def revoke_share(share_id: str) -> bool:
     return False
 
 
-def list_shares(vault_filter: str | None = None) -> list:
-    """List all shares, optionally filtered by vault."""
+def list_shares(vault_filter: str | None = None, user: str | None = None) -> list:
+    """List shares, optionally filtered by vault and/or requesting user.
+
+    #196 : un non-admin ne voit que les partages qu'il a créés **ou** qui lui
+    sont dirigés. Un admin voit tout. ``user=None`` (anciens appels, tests
+    unitaires) conserve l'ancien comportement : tout lister.
+    """
     data = _read()
     shares = list(data["shares"].values())
+    if user is not None:
+        shares = [s for s in shares if user in (s.get("created_by"), *(s.get("shared_with") or []))]
     if vault_filter:
         shares = [s for s in shares if s["vault"] == vault_filter]
     # Most recent first

backend/tools/api.py

@@ -12,10 +12,14 @@ which ``.gitignore`` excludes via ``_*.py``), hence this explicit facade.
 from backend.tools import connected as _connected  # noqa: F401  (registers connected-source tools)
 from backend.tools import crawler as _crawler  # noqa: F401  (registers the site crawler)
 from backend.tools import documents as _documents  # noqa: F401  (registers document tools)
+from backend.tools import duplicates as _duplicates  # noqa: F401  (registers duplicate tools #166)
+from backend.tools import notify as _notify_tools  # noqa: F401  (registers notify tool #168)
+from backend.tools import scheduled as _scheduled  # noqa: F401  (registers scheduler tools #170)
 from backend.tools import service as _service  # noqa: F401  (registers tools)
 from backend.tools import spreadsheets as _spreadsheets  # noqa: F401  (registers existing-workbook tools #153 A6)
 from backend.tools import web as _web  # noqa: F401  (registers web tools)
 from backend.tools.context import (
+    FILES_SCOPE_TOOLS,
     ToolConfirmationRequired,
     ToolContext,
     ToolError,
@@ -49,6 +53,7 @@ from backend.tools.registry import (
 from backend.tools.schemas import ToolResult
 
 __all__ = [
+    "FILES_SCOPE_TOOLS",
     "ToolConfirmationRequired",
     "ToolContext",
     "ToolError",

backend/tools/context.py

@@ -117,6 +117,29 @@ class ToolRateLimitError(ToolError):
         self.retry_after = retry_after
 
 
+#: Tools a ``files``-scoped API token (#199, synchro TikTak) may invoke :
+#: vault file read/write surface only — no external calls (git/web), no
+#: notifications, no scheduler, no cross-vault analysis beyond file content.
+FILES_SCOPE_TOOLS: frozenset[str] = frozenset({
+    # Lecture / recherche de fichiers
+    "list_vaults", "list_directory", "list_all_files",
+    "read_file", "read_file_raw", "get_backlinks",
+    "get_graph", "search_fulltext", "search_advanced", "search_paths",
+    "list_tags", "suggest_tags", "list_recent",
+    "list_backups", "diff_backup", "restore_backup",
+    "find_duplicates",
+    # Mutations de fichiers
+    "create_file", "create_directory", "edit_file", "append_to_file",
+    "rename_file", "rename_directory", "move_path", "replace_in_files",
+    "delete_file", "delete_directory", "merge_duplicate_notes",
+    # Tableurs & documents (création/édition de fichiers du vault)
+    "create_xlsx", "create_docx", "create_csv", "create_pdf",
+    "list_xlsx_sheets", "xlsx_to_markdown", "search_workbook",
+    "analyze_range", "update_xlsx_cells", "append_xlsx_rows",
+    "edit_xlsx_structure",
+})
+
+
 @dataclass
 class ToolContext:
     """Carries the caller identity and execution options for a tool call.
@@ -190,6 +213,32 @@ class ToolContext:
                 details={"vault": vault},
             )
 
+    def require_tool_allowed(self, tool: str) -> None:
+        """Raise :class:`ToolPermissionError` when the caller's token scope
+        forbids *tool* (#199).
+
+        A ``files``-scoped token is confined to :data:`FILES_SCOPE_TOOLS`
+        (vault file surface). Full-scope and scopeless callers (session
+        tokens, pre-#199 API keys) are unaffected ; an unknown scope fails
+        closed.
+        """
+        token_scope = self.user.get("_token_scope") or "full"
+        if token_scope == "full":
+            return
+        if token_scope == "files":
+            if tool not in FILES_SCOPE_TOOLS:
+                raise ToolPermissionError(
+                    f"Token à portée limitée : outil '{tool}' hors périmètre 'files'",
+                    code="token_scope_denied",
+                    details={"tool": tool, "scope": "files"},
+                )
+            return
+        raise ToolPermissionError(
+            "Token à portée inconnue : appel refusé",
+            code="token_scope_denied",
+            details={"tool": tool},
+        )
+
 
 def resolve_safe_path(vault_root: Path, relative_path: str | None) -> Path:
     """Resolve a vault-relative path, rejecting traversal outside the vault.

backend/tools/duplicates.py

@@ -0,0 +1,59 @@
+"""Duplicate detection & merge tools (#166).
+
+* ``find_duplicates`` — READ, vault-scoped: candidate pairs with scores.
+* ``merge_duplicate_notes`` — DANGEROUS: confirmed fusion with automatic
+  backup (service layer), never without an explicit approval.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from backend.services import duplicates as _duplicates
+from backend.services.errors import ServiceError
+from backend.tools.context import ToolContext, ToolError, ToolRisk
+from backend.tools.registry import tool
+from backend.tools.schemas import FindDuplicatesInput, MergeDuplicatesInput
+
+
+@tool(
+    name="find_duplicates",
+    description="Find candidate duplicate markdown notes in a vault (similarity scores).",
+    input_model=FindDuplicatesInput,
+    risk=ToolRisk.READ,
+    requires_vault=True,
+)
+def find_duplicates(ctx: ToolContext, params: FindDuplicatesInput) -> dict[str, Any]:
+    """List duplicate candidates ordered by descending score."""
+    try:
+        return _duplicates.find_duplicate_pairs(
+            params.vault,
+            threshold=params.threshold,
+            limit=params.limit,
+            subdir=params.subdir,
+        )
+    except ServiceError as e:
+        raise ToolError(e.message, code=e.code, details=e.details) from e
+
+
+@tool(
+    name="merge_duplicate_notes",
+    description=(
+        "Merge one note into another and delete the source (backup first). "
+        "Destructive: requires confirmation."
+    ),
+    input_model=MergeDuplicatesInput,
+    risk=ToolRisk.DANGEROUS,
+    requires_vault=True,
+)
+def merge_duplicate_notes(ctx: ToolContext, params: MergeDuplicatesInput) -> dict[str, Any]:
+    """Fuse *source_path* into *target_path* using the chosen strategy."""
+    try:
+        return _duplicates.merge_duplicates(
+            params.vault,
+            params.source_path,
+            params.target_path,
+            strategy=params.strategy,
+        )
+    except ServiceError as e:
+        raise ToolError(e.message, code=e.code, details=e.details) from e

backend/tools/labels.py

@@ -62,6 +62,13 @@ _STEP_LABELS: dict[str, tuple[str, str | None]] = {
     "create_docx": ("docx_create", "path"),
     "create_csv": ("csv_create", "path"),
     "create_pdf": ("pdf_create", "path"),
+    "find_duplicates": ("duplicates", "vault"),
+    "merge_duplicate_notes": ("duplicates_merge", "source_path"),
+    "notify_external": ("notify", "title"),
+    "create_scheduled_task": ("schedule_create", "name"),
+    "list_scheduled_tasks": ("schedule_list", None),
+    "delete_scheduled_task": ("schedule_delete", "task_id"),
+    "run_scheduled_task_now": ("schedule_run", "task_id"),
 }
 
 GENERIC_KEY = "generic"

backend/tools/notify.py

@@ -0,0 +1,42 @@
+"""External notification tool (#168) — Discord, Telegram, SMTP, webhook.
+
+``notify_external`` is WRITE (external side effect → confirmation card in the
+UI, propose/apply over MCP). Delivery itself lives in :mod:`backend.notify`.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from backend import notify as _notify
+from backend.tools.context import ToolContext, ToolError, ToolRisk
+from backend.tools.registry import tool
+from backend.tools.schemas import NotifyExternalInput
+
+
+@tool(
+    name="notify_external",
+    description="Send a notification through external channels (Discord, Telegram, SMTP, webhook).",
+    input_model=NotifyExternalInput,
+    risk=ToolRisk.WRITE,
+)
+def notify_external(ctx: ToolContext, params: NotifyExternalInput) -> dict[str, Any]:
+    """Broadcast to the trigger scope, or target a single channel id."""
+    try:
+        if params.channel_id:
+            channel = next(
+                (c for c in _notify._read_channels() if c.get("id") == params.channel_id),
+                None,
+            )
+            if channel is None:
+                raise ToolError(f"Unknown channel: {params.channel_id}", code="not_found")
+            if not channel.get("enabled", True):
+                raise ToolError(f"Channel disabled: {params.channel_id}", code="invalid_arguments")
+            _notify.send_via_channel(channel, params.title, params.message, params.trigger)
+            return {"ok": True, "channel_id": params.channel_id}
+        results = _notify.broadcast(params.trigger, params.title, params.message)
+        return {"ok": True, "deliveries": results}
+    except ToolError:
+        raise
+    except Exception as e:
+        raise ToolError(f"Notification failed: {e}", code="notify_failed") from e

backend/tools/registry.py

@@ -117,9 +117,22 @@ def list_tools(*, scope: ToolScope | None = None) -> list[ToolSpec]:
     return specs
 
 
+# ponytail: tool schemas are static after import (registration is decorator
+# only); keying the cache on len(_REGISTRY) invalidates it if a tool is ever
+# registered at runtime. Rebuilding 50 pydantic JSON schemas cost ~27 ms per
+# agent/MCP request.
+_SCHEMAS_CACHE: dict[Any, list[dict[str, Any]]] = {}
+
+
 def get_tool_schemas(*, scope: ToolScope | None = None) -> list[dict[str, Any]]:
-    """Return OpenAI-compatible schemas for registered tools."""
-    return [spec.openai_schema() for spec in list_tools(scope=scope)]
+    """Return OpenAI-compatible schemas for registered tools (cached)."""
+    key = (scope, len(_REGISTRY))
+    cached = _SCHEMAS_CACHE.get(key)
+    if cached is None:
+        cached = [spec.openai_schema() for spec in list_tools(scope=scope)]
+        _SCHEMAS_CACHE.clear()
+        _SCHEMAS_CACHE[key] = cached
+    return [dict(s) for s in cached]
 
 
 def _audit(ctx: ToolContext, spec: ToolSpec, arguments: dict[str, Any], *, ok: bool, error: str | None = None) -> None:
@@ -203,6 +216,14 @@ def call_tool(
             _audit(ctx, spec, arguments, ok=False, error=e.code)
             raise
 
+    # #199 : les tokens à portée limitée sont confinés à la surface fichiers,
+    # y compris pour les outils sans vault (git, web, notify…).
+    try:
+        ctx.require_tool_allowed(name)
+    except ToolPermissionError as e:
+        _audit(ctx, spec, arguments, ok=False, error=e.code)
+        raise
+
     if spec.risk == ToolRisk.DANGEROUS and vault and vault != "all":
         try:
             ctx.require_destructive_allowed(vault)

backend/tools/scheduled.py

@@ -0,0 +1,78 @@
+"""Scheduled-task tools (#170) — the agent programs its own cron.
+
+* ``create_scheduled_task`` — WRITE (a future write, confirmed once now).
+* ``list_scheduled_tasks`` — READ.
+* ``delete_scheduled_task`` — WRITE (removes a future side effect).
+* ``run_scheduled_task_now`` — WRITE (immediate side effect).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from backend import scheduler as _scheduler
+from backend.tools.context import ToolContext, ToolError, ToolRisk
+from backend.tools.registry import tool
+from backend.tools.schemas import (
+    CreateScheduledTaskInput,
+    DeleteScheduledTaskInput,
+    ListVaultsInput,
+    RunScheduledTaskInput,
+)
+
+
+@tool(
+    name="create_scheduled_task",
+    description="Program an automatic task (create_file, append_to_file, notify) on a cron-like schedule.",
+    input_model=CreateScheduledTaskInput,
+    risk=ToolRisk.WRITE,
+)
+def create_scheduled_task(ctx: ToolContext, params: CreateScheduledTaskInput) -> dict[str, Any]:
+    """Create a task owned by the requesting user."""
+    try:
+        return _scheduler.create_task(
+            params.name,
+            params.action,
+            params.schedule,
+            created_by=ctx.username,
+        )
+    except ValueError as e:
+        raise ToolError(str(e), code="invalid_arguments") from e
+
+
+@tool(
+    name="list_scheduled_tasks",
+    description="List automatic tasks programmed in ObsiGate.",
+    input_model=ListVaultsInput,
+    risk=ToolRisk.READ,
+)
+def list_scheduled_tasks(ctx: ToolContext, _params: ListVaultsInput) -> list[dict[str, Any]]:
+    """Return tasks newest first."""
+    return _scheduler.list_tasks()
+
+
+@tool(
+    name="delete_scheduled_task",
+    description="Delete a programmed automatic task.",
+    input_model=DeleteScheduledTaskInput,
+    risk=ToolRisk.WRITE,
+)
+def delete_scheduled_task(ctx: ToolContext, params: DeleteScheduledTaskInput) -> dict[str, Any]:
+    """Delete by id; unknown id is a not_found tool error."""
+    if not _scheduler.delete_task(params.task_id):
+        raise ToolError(f"Unknown task: {params.task_id}", code="not_found")
+    return {"ok": True, "task_id": params.task_id}
+
+
+@tool(
+    name="run_scheduled_task_now",
+    description="Execute a programmed task immediately (manual run).",
+    input_model=RunScheduledTaskInput,
+    risk=ToolRisk.WRITE,
+)
+def run_scheduled_task_now(ctx: ToolContext, params: RunScheduledTaskInput) -> dict[str, Any]:
+    """Run now and return the outcome (failures are recorded + notified)."""
+    try:
+        return _scheduler.run_task(params.task_id, manual=True)
+    except KeyError as e:
+        raise ToolError(f"Unknown task: {params.task_id}", code="not_found") from e

backend/tools/schemas.py

@@ -441,6 +441,53 @@ class PdfInput(BaseModel):
     overwrite: bool = Field(True, description="Replace an existing file (with backup)")
 
 
+class FindDuplicatesInput(BaseModel):
+    """Find candidate duplicate notes in a vault (#166)."""
+
+    vault: str = Field(..., description="Vault name")
+    threshold: float = Field(0.75, ge=0.3, le=1.0, description="Minimum similarity score")
+    limit: int = Field(20, ge=1, le=200, description="Maximum number of pairs")
+    subdir: str = Field("", description="Vault-relative directory scope (empty = whole vault)")
+
+
+class MergeDuplicatesInput(BaseModel):
+    """Merge one note into another, then delete the source (#166, destructive)."""
+
+    vault: str = Field(..., description="Vault name")
+    source_path: str = Field(..., description="Vault-relative path of the note to absorb")
+    target_path: str = Field(..., description="Vault-relative path of the surviving note")
+    strategy: str = Field("append", description="'append', 'prefer_target' or 'prefer_source'")
+
+
+class NotifyExternalInput(BaseModel):
+    """Send a notification through external channels (#168)."""
+
+    title: str = Field(..., min_length=1, description="Notification title")
+    message: str = Field(..., min_length=1, description="Notification body")
+    trigger: str = Field("manual", description="Trigger scope: manual, schedule_failure, schedule_success")
+    channel_id: str = Field("", description="Single channel id (empty = broadcast to trigger)")
+
+
+class CreateScheduledTaskInput(BaseModel):
+    """Create an automatic task executed by the scheduler (#170)."""
+
+    name: str = Field(..., min_length=1, description="Task display name")
+    action: dict[str, Any] = Field(..., description="{kind, params} (create_file, append_to_file, notify)")
+    schedule: dict[str, Any] = Field(..., description="{kind, ...} (interval_hours, daily_time, once_at)")
+
+
+class DeleteScheduledTaskInput(BaseModel):
+    """Delete a scheduled task by id (#170)."""
+
+    task_id: str = Field(..., min_length=1, description="Task id")
+
+
+class RunScheduledTaskInput(BaseModel):
+    """Execute a scheduled task immediately (#170)."""
+
+    task_id: str = Field(..., min_length=1, description="Task id")
+
+
 class ToolResult(BaseModel):
     """Uniform result returned by :func:`backend.tools.registry.call_tool`."""
 

backend/tools/service.py

@@ -123,10 +123,17 @@ def list_vaults(ctx: ToolContext, _params: ListVaultsInput) -> list[dict[str, An
 def list_directory(ctx: ToolContext, params: ListDirectoryInput) -> list[dict[str, Any]]:
     """Return the entries of a vault directory (direct children only)."""
     data = browse_directory(params.vault, params.path)
-    return [
-        {"name": item["name"], "path": item["path"], "type": item["type"]}
-        for item in data["items"]
-    ]
+    # #197 : même contrat que la REST — la taille et le mtime permettent la
+    # réconciliation externe sans relire chaque fichier.
+    out = []
+    for item in data["items"]:
+        entry = {"name": item["name"], "path": item["path"], "type": item["type"]}
+        if item["type"] == "file":
+            entry["size"] = item.get("size")
+            entry["mtime"] = item.get("modified")
+            entry["mtime_iso"] = item.get("modified_iso")
+        out.append(entry)
+    return out
 
 
 @tool(

backend/user_home.py

@@ -0,0 +1,169 @@
+"""Dossier personnel par utilisateur (#194).
+
+Chaque utilisateur reçoit ``<OBSIGATE_HOME_ROOT>/<username>`` monté comme un
+vault propre ``home-<username>`` : l'isolation profite de l'ACL par vault
+déjà en place (``check_vault_access``), aucune ACL par chemin à inventer.
+
+Tout est idempotent (``ensure_user_home``) pour être rappelé à la création
+d'un compte ET au démarrage : un dossier supprimé, un registre perdu ou un
+user créé hors API se réparent au boot.
+
+La fonctionnalité est inactive tant que ``OBSIGATE_HOME_ROOT`` n'est pas
+défini (dev, tests, desktop) — comportement inchangé.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from pathlib import Path
+
+logger = logging.getLogger("obsigate.user_home")
+
+# Même grammaire que CreateUserRequest.username_valid (backend/auth/router.py) :
+# segment de chemin sûr, déjà passé par la validation de l'API. Re-vérifié ici
+# car le nom sert à construire un chemin (défense en profondeur).
+_USERNAME_RE = re.compile(r"^[a-zA-Z0-9_-]{2,32}$")
+
+
+def home_root() -> Path | None:
+    """Racine des dossiers persos, ou ``None`` si la fonctionnalité est inactive."""
+    root = os.environ.get("OBSIGATE_HOME_ROOT", "").strip()
+    return Path(root) if root else None
+
+
+def home_vault_name(username: str) -> str:
+    """Nom de vault du dossier perso — pas de ``/`` ni ``::`` (segment d'URL, clé d'index)."""
+    return f"home-{username}"
+
+
+async def ensure_user_home(username: str) -> str | None:
+    """Crée (si besoin) le dossier perso de *username*, son vault et son octroi.
+
+    Retourne le nom de vault, ou ``None`` si désactivé / nom invalide /
+    erreur disque (journalisée, réparée au prochain démarrage).
+    """
+    root = home_root()
+    if root is None:
+        return None
+    if not _USERNAME_RE.match(username):
+        logger.warning(f"Home folder skipped: invalid username {username!r}")
+        return None
+
+    home = root / username
+    try:
+        home.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        logger.exception(f"Cannot create home folder {home} for user '{username}'")
+        return None
+
+    name = home_vault_name(username)
+    try:
+        from backend.indexer import add_vault_to_index, index, persist_vault, vault_config
+        from backend.sse import sse_manager
+
+        vault_path = str(home)
+        if name not in index:
+            await add_vault_to_index(name, vault_path)
+            persist_vault(name)
+            from backend.watcher_state import get_watcher
+
+            watcher = get_watcher()
+            if watcher:
+                await watcher.add_vault(name, vault_path)
+            await sse_manager.broadcast("vault_added", {"vault": name})
+            logger.info(f"Home vault '{name}' registered at {vault_path}")
+        elif name not in vault_config:
+            vault_config[name] = {"path": vault_path, "attachmentsPath": None,
+                                  "scanAttachmentsOnStartup": True}
+    except Exception:
+        logger.exception(f"Cannot register home vault '{name}' for user '{username}'")
+        return None
+
+    _grant(username, name)
+    return name
+
+
+async def release_user_home(username: str) -> None:
+    """Retire le vault du dossier perso à la suppression du compte (#194).
+
+    Le dossier sur disque est **conservé** (décision produit : pas de perte
+    de données) ; seul l'index, le watcher et le registre le referment.
+    """
+    name = home_vault_name(username)
+    try:
+        from backend.indexer import index, remove_vault_from_index, unpersist_vault
+
+        unpersist_vault(name)
+        if name not in index:
+            return
+        await remove_vault_from_index(name)
+        from backend.sse import sse_manager
+        from backend.watcher_state import get_watcher
+
+        watcher = get_watcher()
+        if watcher:
+            await watcher.remove_vault(name)
+        await sse_manager.broadcast("vault_removed", {"vault": name})
+        logger.info(f"Home vault '{name}' released (folder kept)")
+    except Exception:
+        logger.exception(f"Cannot release home vault '{name}'")
+
+
+def _grant(username: str, vault_name: str) -> None:
+    """Ajoute le vault à ``user.vaults`` s'il n'y est pas déjà (#194).
+
+    L'octroi est explicite même pour un admin (``vaults: ["*"]``) : ``*`` ne
+    couvre jamais un dossier perso (voir ``check_vault_access``).
+    """
+    from backend.auth.user_store import get_user, update_user
+
+    user = get_user(username)
+    if not user:
+        return  # créé hors API (bootstrap avant users.json) → réparé au boot suivant
+    vaults = user.get("vaults") or []
+    if vault_name in vaults:
+        return
+    update_user(username, {"vaults": [*vaults, vault_name]})
+
+
+async def ensure_all_user_homes() -> int:
+    """Passe de réparation/migration au démarrage : un home par user existant.
+
+    Balaye aussi les vaults orphelins (compte supprimé hors route, ex.
+    ``create_admin.py delete``) : ils sont refermés, dossier conservé.
+    """
+    from backend.auth.user_store import get_all_users
+    from backend.indexer import index, vault_config
+
+    root = home_root()
+    if root is None:
+        return 0
+    users = get_all_users()
+    usernames = {u.get("username") for u in users}
+    created = 0
+    for user in users:
+        username = user.get("username")
+        if not username:
+            continue
+        if await ensure_user_home(username):
+            created += 1
+    if created:
+        logger.info(f"User home folders ensured for {created} user(s)")
+
+    # Orphelins : vault home-<x> toujours indexé mais <x> n'existe plus.
+    # Path.parent == root → on ne touche qu'aux dossiers sous la racine Home,
+    # jamais à un vault admin nommé « home-… » par ailleurs.
+    for name in list(index):
+        if not name.startswith("home-"):
+            continue
+        owner = name[len("home-"):]
+        if owner in usernames:
+            continue
+        cfg_path = Path((vault_config.get(name) or {}).get("path", ""))
+        if cfg_path.parent != root:
+            continue
+        logger.warning(f"Orphan home vault '{name}' released (user deleted?)")
+        await release_user_home(owner)
+    return created

backend/webhooks.py

@@ -16,6 +16,9 @@ Security (BUG-026):
 
 Events: file_created, file_deleted, file_modified, file_renamed,
         directory_created, directory_deleted, directory_renamed
+(#198 : chaque webhook peut porter un filtre optionnel ``vault`` et/ou
+``path_prefix`` — seuls les événements correspondants sont livrés ; la
+charge utile inclut toujours ``vault`` et le(s) chemin(s)).
 """
 
 import asyncio
@@ -120,6 +123,65 @@ def is_safe_target(url: str) -> bool:
     return True
 
 
+def _normalize_vault_filter(vault: str | None) -> str | None:
+    """Normalize an optional vault filter (``None``/empty = no filtering)."""
+    if not vault or not isinstance(vault, str):
+        return None
+    cleaned = vault.strip()
+    return cleaned or None
+
+
+def _normalize_prefix_filter(prefix: str | None) -> str | None:
+    """Normalize an optional path-prefix filter (``None``/empty = no filtering)."""
+    if not prefix or not isinstance(prefix, str):
+        return None
+    cleaned = prefix.strip().strip("/")
+    return cleaned or None
+
+
+def _event_paths(data: dict) -> list[str]:
+    """Vault-relative paths carried by a webhook payload.
+
+    File/directory events use ``path``; renames and moves carry
+    ``old_path``/``new_path`` instead.
+    """
+    paths = []
+    for key in ("path", "old_path", "new_path"):
+        value = data.get(key)
+        if isinstance(value, str) and value:
+            paths.append(value.strip("/"))
+    return paths
+
+
+def webhook_matches(wh: dict, event_type: str, data: dict) -> bool:
+    """True when webhook *wh* must receive (*event_type*, *data*).
+
+    Pure function (no I/O) so the filtering is unit-testable :
+    - event subscription (as before) ;
+    - #198 optional ``vault`` filter — exact match on ``data["vault"]`` ;
+    - #198 optional ``path_prefix`` filter — matches when any carried path
+      equals the prefix or lies underneath it (``Docs`` matches ``Docs`` and
+      ``Docs/a.md``, not ``Docs2/b.md``).
+
+    Webhooks created before #198 carry neither key and keep receiving
+    everything they subscribe to (backward compatible).
+    """
+    if event_type not in wh.get("events", []):
+        return False
+    vault_filter = _normalize_vault_filter(wh.get("vault"))
+    if vault_filter and data.get("vault") != vault_filter:
+        return False
+    prefix = _normalize_prefix_filter(wh.get("path_prefix"))
+    if prefix:
+        wanted = prefix + "/"
+        for candidate in _event_paths(data):
+            if candidate == prefix or candidate.startswith(wanted):
+                break
+        else:
+            return False
+    return True
+
+
 def _read() -> list:
     if not WEBHOOKS_FILE.exists():
         return []
@@ -195,7 +257,14 @@ def get_webhooks() -> list:
     return [_public_view(wh) for wh in _read()]
 
 
-def create_webhook(name: str, url: str, events: list[str], secret: str | None = None) -> dict:
+def create_webhook(
+    name: str,
+    url: str,
+    events: list[str],
+    secret: str | None = None,
+    vault: str | None = None,
+    path_prefix: str | None = None,
+) -> dict:
     validate_webhook_url(url)
     with _lock:
         webhooks = _read()
@@ -208,6 +277,9 @@ def create_webhook(name: str, url: str, events: list[str], secret: str | None =
             "enabled": True,
             "created_at": datetime.now(timezone.utc).isoformat(),
             "last_fired_at": None,
+            # #198 : filtres optionnels (None = pas de filtre, reçoit tout).
+            "vault": _normalize_vault_filter(vault),
+            "path_prefix": _normalize_prefix_filter(path_prefix),
         }
         webhooks.append(wh)
         _write(webhooks)
@@ -226,6 +298,13 @@ def update_webhook(wh_id: str, updates: dict) -> dict | None:
                     validate_webhook_url(updates["url"])
                 if "secret" in updates:
                     _store_secret(wh_id, updates["secret"])
+                # #198 : normaliser les filtres ("" réinitialise le filtre).
+                for key, normalizer in (
+                    ("vault", _normalize_vault_filter),
+                    ("path_prefix", _normalize_prefix_filter),
+                ):
+                    if key in updates:
+                        updates[key] = normalizer(updates[key])
                 safe_updates = {
                     k: v for k, v in updates.items()
                     if k not in ("id", "secret")
@@ -250,9 +329,16 @@ def delete_webhook(wh_id: str) -> bool:
 
 
 async def dispatch_webhooks(event_type: str, data: dict):
-    """Fire all enabled webhooks subscribed to event_type."""
+    """Fire all enabled webhooks subscribed to event_type.
+
+    #198 : les webhooks portant un filtre ``vault``/``path_prefix`` ne sont
+    livrés que pour les événements correspondants (voir :func:`webhook_matches`).
+    """
     webhooks = _read()
-    targets = [wh for wh in webhooks if wh.get("enabled", True) and event_type in wh.get("events", [])]
+    targets = [
+        wh for wh in webhooks
+        if wh.get("enabled", True) and webhook_matches(wh, event_type, data)
+    ]
     if not targets:
         return
 

backend/xlsx_reader.py

@@ -129,8 +129,16 @@ def _cell_fragments(cell: Any) -> tuple[list[str], str | None]:
         fragments.append("font-style:italic")
     # #156-A8 — underline is written from the viewer too, so it is read back
     # (the toggle in the formatting menu needs to see its own effect).
+    decorations = []
     if font and font.underline:
-        fragments.append("text-decoration:underline")
+        decorations.append("underline")
+    if font and getattr(font, "strike", False):
+        decorations.append("line-through")
+    if decorations:
+        fragments.append("text-decoration:" + " ".join(decorations))
+    size = getattr(font, "size", None) if font else None
+    if isinstance(size, (int, float)) and size != 11:
+        fragments.append(f"font-size:{size:g}pt")
     fmt = cell.number_format
     if fmt and fmt not in ("General", "@"):
         # A custom number format is signalled typographically (mono font)
@@ -140,29 +148,129 @@ def _cell_fragments(cell: Any) -> tuple[list[str], str | None]:
         fragments.append("font-family:'JetBrains Mono',monospace")
     alignment = cell.alignment
     align = alignment.horizontal if alignment else None
-    return fragments, (align if align in ("left", "right", "center") else None)
+    if alignment is not None:
+        vertical = getattr(alignment, "vertical", None)
+        if vertical == "center":
+            fragments.append("vertical-align:middle")
+        elif vertical in ("top", "bottom"):
+            fragments.append(f"vertical-align:{vertical}")
+        if getattr(alignment, "wrap_text", None) is True:
+            fragments.append("white-space:normal")
+        elif getattr(alignment, "wrap_text", None) is False:
+            fragments.append("white-space:nowrap")
+        rotation = getattr(alignment, "text_rotation", None) or 0
+        if rotation == 90 or rotation == 255:
+            fragments.append("writing-mode:vertical-rl")
+        elif rotation == 180:
+            fragments.append("writing-mode:vertical-rl;transform:scale(-1)")
+        else:
+            # Angles diagonaux (ex. ±45° du menu Format › Rotation) : OOXML
+            # stocke l'anti-horaire sur 0..90 et l'horaire sur 91..180 (-45°
+            # → 135, cf. mutations). Le CSS tourne en sens horaire : signe
+            # inversé pour un rendu fidèle.
+            excel = rotation if rotation <= 90 else -(180 - rotation)
+            if excel:
+                fragments.append(f"transform:rotate({-excel}deg)")
+    border = getattr(cell, "border", None)
+    if border is not None:
+        sides = []
+        for side_name in ("left", "right", "top", "bottom"):
+            side = getattr(border, side_name, None)
+            style = getattr(side, "style", None)
+            if not style:
+                continue
+            color = getattr(getattr(side, "color", None), "rgb", None)
+            hexpart = ""
+            if isinstance(color, str) and len(color) == 8:
+                hexpart = f" #{color[2:].lower()}"
+            width = {"medium": "2px", "thick": "3px"}.get(style, "1px")
+            css_style = {"dashed": "dashed", "dotted": "dotted", "double": "double"}.get(
+                style, "solid"
+            )
+            sides.append(f"border-{side_name}:{width} {css_style}{hexpart}")
+        fragments.extend(sides)
+    return fragments, (align if align in ("left", "right", "center", "justify") else None)
 
 
-def _sheet_style_maps(ws: Any) -> tuple[dict[str, str], dict[str, str]]:
-    """Flat ``{ref: css}`` and ``{ref: align}`` maps of one worksheet.
+def _sheet_style_maps(
+    ws: Any,
+) -> tuple[dict[str, str], dict[str, str], dict[str, str], dict[str, str]]:
+    """Flat maps of one worksheet: css, align, comment text, number format.
 
     The flat string is what the API serves and what the viewer applies
     verbatim to ``td.style``; a plain cell is simply absent from the map.
     ``left`` is the table default and never included. Bounded by
-    ``MAX_ROWS x MAX_COLS`` like the render itself.
+    ``MAX_ROWS x MAX_COLS`` like the render itself. Comment texts are capped
+    (tooltip use) and formats only list non-General number formats.
     """
     styles: dict[str, str] = {}
     aligns: dict[str, str] = {}
+    comments: dict[str, str] = {}
+    formats: dict[str, str] = {}
     for row in ws.iter_rows(min_row=1, max_row=MAX_ROWS, max_col=MAX_COLS):
         for cell in row:
-            if cell.value is None and cell.number_format == "General":
+            comment = getattr(cell, "comment", None)
+            comment_text = getattr(comment, "text", None) if comment is not None else None
+            # Une cellule vide mais stylée (gras, diagonale, commentaire…)
+            # doit survivre à la relecture : `has_style` (et le commentaire)
+            # sont les seuls tests rapides qui la distinguent d'une cellule
+            # vraiment vierge — sinon le style semble « ne pas fonctionner »
+            # dès qu'on recharge le classeur.
+            if cell.value is None and cell.number_format == "General" and not cell.has_style:
+                if comment_text:
+                    comments[cell.coordinate] = str(comment_text)[:500]
                 continue
             fragments, align = _cell_fragments(cell)
             if fragments:
                 styles[cell.coordinate] = ";".join(fragments)
             if align and align != "left":
                 aligns[cell.coordinate] = align
-    return styles, aligns
+            if comment_text:
+                comments[cell.coordinate] = str(comment_text)[:500]
+            fmt = getattr(cell, "number_format", None)
+            if fmt and fmt not in ("General", "@", None):
+                formats[cell.coordinate] = str(fmt)
+    return styles, aligns, comments, formats
+
+
+def _sheet_dim_maps(ws: Any) -> tuple[dict[str, float], dict[str, float]]:
+    """Explicit column widths (units) and row heights (pt), by letter/number.
+
+    Only dimensions the file sets explicitly are listed (defaults are a
+    rendering concern of the client). Bounded like the render itself.
+    """
+    from openpyxl.utils import column_index_from_string
+
+    colwidths: dict[str, float] = {}
+    try:
+        for key, dim in (getattr(ws, "column_dimensions", {}) or {}).items():
+            width = getattr(dim, "width", None)
+            if not isinstance(width, (int, float)):
+                continue
+            letters = str(key).split(":")
+            try:
+                cols = [column_index_from_string(a.strip()) for a in letters]
+            except ValueError:
+                continue
+            lo, hi = min(cols), max(cols)
+            for c in range(lo, min(hi, MAX_COLS) + 1):
+                if c >= 1:
+                    from openpyxl.utils import get_column_letter
+
+                    colwidths[get_column_letter(c)] = float(width)
+    except Exception:
+        logger.debug("xlsx column widths unavailable", exc_info=True)
+    rowheights: dict[str, float] = {}
+    try:
+        for r, dim in (getattr(ws, "row_dimensions", {}) or {}).items():
+            if not isinstance(r, int) or not 1 <= r <= MAX_ROWS:
+                continue
+            height = getattr(dim, "height", None)
+            if isinstance(height, (int, float)):
+                rowheights[str(r)] = float(height)
+    except Exception:
+        logger.debug("xlsx row heights unavailable", exc_info=True)
+    return colwidths, rowheights
 
 
 def read_sheet_styles(file_path: Path, sheet: str) -> dict[str, dict[str, Any]]:
@@ -445,7 +553,8 @@ def invalidate_workbook_meta(file_path: Path | str) -> None:
 
 
 def read_workbook_meta(file_path: Path) -> dict[str, dict[str, Any]]:
-    """Return ``{sheet: {styles, aligns, merges, freeze}}`` for every sheet.
+    """Return ``{sheet: {styles, aligns, comments, formats, colwidths,
+    rowheights, merges, freeze}}``.
 
     One normal (non-streaming) load serves the three A15 metadata maps: the
     fragments are the workbook's own values, a failure yields ``{}`` per sheet
@@ -483,12 +592,17 @@ def _read_workbook_meta_uncached(file_path: Path) -> dict[str, dict[str, Any]]:
     out: dict[str, dict[str, Any]] = {}
     try:
         for ws in wb.worksheets:
-            styles, aligns = _sheet_style_maps(ws)
+            styles, aligns, comments, formats = _sheet_style_maps(ws)
+            colwidths, rowheights = _sheet_dim_maps(ws)
             merged = getattr(ws, "merged_cells", None)
             ranges = getattr(merged, "ranges", None) or []
             out[ws.title] = {
                 "styles": styles,
                 "aligns": aligns,
+                "comments": comments,
+                "formats": formats,
+                "colwidths": colwidths,
+                "rowheights": rowheights,
                 "merges": [str(r) for r in ranges],
                 "freeze": str(getattr(ws, "freeze_panes", None) or ""),
             }
@@ -496,7 +610,14 @@ def _read_workbook_meta_uncached(file_path: Path) -> dict[str, dict[str, Any]]:
     except Exception:
         logger.debug("xlsx meta unavailable", exc_info=True)
         for t in wb.sheetnames:
-            out.setdefault(t, {"styles": {}, "aligns": {}, "merges": [], "freeze": ""})
+            out.setdefault(
+                t,
+                {
+                    "styles": {}, "aligns": {}, "comments": {}, "formats": {},
+                    "colwidths": {}, "rowheights": {},
+                    "merges": [], "freeze": "",
+                },
+            )
         return out
     finally:
         wb.close()
@@ -565,6 +686,10 @@ def render_sheets(file_path: Path) -> list[dict[str, Any]]:
                 "truncated": total_rows > MAX_ROWS or total_cols > MAX_COLS,
                 "styles": sheet_meta.get("styles", {}),
                 "aligns": sheet_meta.get("aligns", {}),
+                "comments": sheet_meta.get("comments", {}),
+                "formats": sheet_meta.get("formats", {}),
+                "colwidths": sheet_meta.get("colwidths", {}),
+                "rowheights": sheet_meta.get("rowheights", {}),
                 "merges": sheet_meta.get("merges", []),
                 "freeze": sheet_meta.get("freeze", ""),
             }
@@ -629,6 +754,10 @@ def read_sheet_window(
         "html": _table(grid, shadow, row_offset=offset, styles=meta.get("styles")),
         "styles": meta.get("styles", {}),
         "aligns": meta.get("aligns", {}),
+        "comments": meta.get("comments", {}),
+        "formats": meta.get("formats", {}),
+        "colwidths": meta.get("colwidths", {}),
+        "rowheights": meta.get("rowheights", {}),
         "merges": meta.get("merges", []),
         "freeze": meta.get("freeze", ""),
     }

build.ps1

@@ -115,7 +115,9 @@ $env:VERSION = $Version
 Write-Info "Version : $Version"
 
 # ----- Build the image -----
-$BuildArgs = @("-f", $ComposeFile)
+# NOTE : `--no-cache` est un flag de `docker compose build` (après `build`),
+# pas un flag global (avant) — sinon `unknown flag: --no-cache`.
+$BuildArgs = @("-f", $ComposeFile, "build")
 if (-not $UseCache) {
     $BuildArgs += "--no-cache"
     Write-Info "Construction de l'image Docker (sans cache)..."
@@ -123,7 +125,7 @@ if (-not $UseCache) {
     Write-Info "Construction de l'image Docker (avec cache)..."
 }
 
-docker compose @BuildArgs build
+docker compose @BuildArgs
 if ($LASTEXITCODE -ne 0) {
     Write-Error "Échec de la construction de l'image Docker."
     exit $LASTEXITCODE

build.sh

@@ -223,4 +223,4 @@ $COMPOSE_CMD -f "$COMPOSE_FILE" ps
 
 echo ""
 info "Logs récents (Ctrl+C pour quitter) :"
-$COMPOSE_CMD -f "$COMPOSE_FILE" logs --tail=20 -f
+$COMPOSE_CMD -f "$COMPOSE_FILE" logs --tail=20

desktop/Cargo.lock

@@ -2626,7 +2626,7 @@ dependencies = [
 
 [[package]]
 name = "obsigate-desktop"
-version = "2.49.2"
+version = "2.68.1"
 dependencies = [
  "chrono",
  "env_logger",

desktop/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "obsigate-desktop"
-version = "2.49.2"
+version = "2.68.1"
 description = "ObsiGate Desktop — Porte d'entrée native pour vos vaults Obsidian"
 authors = ["Bruno Charest"]
 edition = "2021"

desktop/build.rs

@@ -38,5 +38,7 @@ fn main() {
     println!("cargo:rerun-if-changed=.git/refs/heads/main");
     println!("cargo:rerun-if-changed=.git/refs/tags");
 
+    println!("cargo:rerun-if-changed=permissions");
+
     tauri_build::build()
 }

desktop/capabilities/default.json

@@ -7,6 +7,7 @@
   },
   "permissions": [
     "core:default",
+    "allow-app-commands",
     "shell:allow-open",
     "shell:allow-execute",
     "dialog:default",

desktop/gen/schemas/capabilities.json

@@ -1 +1 @@
-{"default":{"identifier":"default","description":"Default capabilities for ObsiGate Desktop","remote":{"urls":["http://127.0.0.1:*","http://localhost:*"]},"local":true,"windows":["main"],"permissions":["core:default","shell:allow-open","shell:allow-execute","dialog:default","notification:default","fs:default","process:default","store:default"]}}
+{"default":{"identifier":"default","description":"Default capabilities for ObsiGate Desktop","remote":{"urls":["http://127.0.0.1:*","http://localhost:*"]},"local":true,"windows":["main"],"permissions":["core:default","allow-app-commands","shell:allow-open","shell:allow-execute","dialog:default","notification:default","fs:default","process:default","store:default"]}}

desktop/gen/schemas/desktop-schema.json

@@ -2210,6 +2210,12 @@
     "Identifier": {
       "description": "Permission identifier",
       "oneOf": [
+        {
+          "description": "Commandes de l'application ObsiGate appelées depuis la page backend (http://127.0.0.1).",
+          "type": "string",
+          "const": "allow-app-commands",
+          "markdownDescription": "Commandes de l'application ObsiGate appelées depuis la page backend (http://127.0.0.1)."
+        },
         {
           "description": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`",
           "type": "string",

desktop/gen/schemas/windows-schema.json

@@ -2210,6 +2210,12 @@
     "Identifier": {
       "description": "Permission identifier",
       "oneOf": [
+        {
+          "description": "Commandes de l'application ObsiGate appelées depuis la page backend (http://127.0.0.1).",
+          "type": "string",
+          "const": "allow-app-commands",
+          "markdownDescription": "Commandes de l'application ObsiGate appelées depuis la page backend (http://127.0.0.1)."
+        },
         {
           "description": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`",
           "type": "string",

desktop/permissions/commands.toml

@@ -0,0 +1,36 @@
+# Commandes applicatives ObsiGate — autorisées depuis l'origine distante.
+#
+# La fenêtre Tauri redirige vers http://127.0.0.1:<port> (page servie par le
+# backend Python). Pour Tauri v2 c'est une origine *remote* : sans entrée ACL
+# explicite, TOUTE commande de l'app (invoke_handler) est rejetée avec
+# "Command ... not allowed by ACL" — le bouton « Choisir mon dossier » et le
+# wizard ne faisaient alors rien (erreurs avalées par desktop.js:invoke()).
+#
+# Auto-généré en… non : édité à la main. Liste = tauri::generate_handler![…]
+# dans src/main.rs — ajouter toute nouvelle commande ici.
+
+[[permission]]
+identifier = "allow-app-commands"
+description = "Commandes de l'application ObsiGate appelées depuis la page backend (http://127.0.0.1)."
+commands.allow = [
+  "get_backend_url",
+  "get_version",
+  "get_config",
+  "save_vault_path",
+  "get_vault_path",
+  "get_wizard_state",
+  "complete_wizard",
+  "pick_vault_folder",
+  "pick_folder",
+  "get_system_theme",
+  "restart_backend",
+  "check_backend_health",
+  "save_window_state",
+  "get_window_state",
+  "add_vault",
+  "remove_vault",
+  "list_vaults",
+  "add_dir",
+  "remove_dir",
+  "list_dirs",
+]

desktop/src/jumplist.rs

@@ -10,48 +10,23 @@ use log::{info, warn};
 
 #[cfg(target_os = "windows")]
 mod imp {
-    use super::*;
-    use std::os::windows::ffi::OsStrExt;
-    use windows::core::{Interface, HSTRING, PCWSTR};
-    use windows::Win32::Foundation::PROPERTYKEY;
-    use windows::Win32::System::Com::{
-        CoCreateInstance, CoInitializeEx, CLSCTX_INPROC_SERVER, COINIT_APARTMENTTHREADED,
-    };
-    use windows::Win32::System::Com::StructuredStorage::PROPVARIANT;
-    use windows::Win32::System::Variant::VT_LPWSTR;
-    use windows::Win32::UI::Shell::{
-        ICustomDestinationList, IShellLinkW, SetCurrentProcessExplicitAppUserModelID,
-        DestinationList, EnumerableObjectCollection, ShellLink,
-    };
-    use windows::Win32::UI::Shell::Common::IObjectCollection;
-    use windows::Win32::UI::Shell::PropertiesSystem::IPropertyStore;
+use super::*;
+use std::os::windows::ffi::OsStrExt;
+use windows::core::{Interface, HSTRING, PCWSTR};
+use windows::Win32::System::Com::{
+    CoCreateInstance, CoInitializeEx, CLSCTX_INPROC_SERVER, COINIT_APARTMENTTHREADED,
+};
+use windows::Win32::UI::Shell::{
+    ICustomDestinationList, IShellLinkW, SetCurrentProcessExplicitAppUserModelID,
+    DestinationList, EnumerableObjectCollection, ShellLink,
+};
+use windows::Win32::UI::Shell::Common::IObjectCollection;
 
-    const APP_ID: &str = "com.obsigate.desktop";
+const APP_ID: &str = "com.obsigate.desktop";
 
-    // PKEY_Title (System.Title): {F29F85E0-4FF9-1068-AB91-08002B27B3D9}, pid 2
-    const PKEY_TITLE: PROPERTYKEY = PROPERTYKEY {
-        fmtid: windows::core::GUID::from_u128(0xF29F85E0_4FF9_1068_AB91_08002B27B3D9),
-        pid: 2,
-    };
-
-    fn wide_null_terminated(s: &str) -> Vec<u16> {
-        std::ffi::OsStr::new(s).encode_wide().chain(std::iter::once(0)).collect()
-    }
-
-    /// Set the jump-list display title via the shell link's property store.
-    fn set_link_title(link: &IShellLinkW, title: &str) -> windows::core::Result<()> {
-        let store: IPropertyStore = link.cast()?;
-        let mut wide = wide_null_terminated(title);
-        let mut pv: PROPVARIANT = unsafe { std::mem::zeroed() };
-        unsafe {
-            let inner = &mut *pv.Anonymous.Anonymous;
-            inner.vt = VT_LPWSTR;
-            inner.Anonymous.pwszVal = windows::core::PWSTR(wide.as_mut_ptr());
-            store.SetValue(&PKEY_TITLE, &pv)?;
-            store.Commit()?;
-        }
-        Ok(())
-    }
+fn wide_null_terminated(s: &str) -> Vec<u16> {
+    std::ffi::OsStr::new(s).encode_wide().chain(std::iter::once(0)).collect()
+}
 
     /// Build one shell link for a vault. `arg` is the command-line argument the
     /// app expects to open that vault (see file associations / single-instance).
@@ -70,9 +45,10 @@ mod imp {
             }
             link.SetDescription(&HSTRING::from(name))?;
         }
-        // Title (display name) is best-effort — a missing title only means the
-        // jump-list entry falls back to the executable name.
-        let _ = set_link_title(&link, name);
+        // Title (display name): the raw PROPVARIANT setter that used to live
+        // here corrupted the process heap (STATUS_HEAP_CORRUPTION c0000374 —
+        // the shell property store freed our Rust-allocated VT_LPWSTR buffer).
+        // SetDescription below already gives jump-list entries their label.
         Ok(link)
     }
 

desktop/src/main.rs

@@ -48,6 +48,7 @@ fn pick_free_port() -> u16 {
 #[cfg(target_os = "windows")]
 use std::os::windows::process::CommandExt;
 use tauri::Manager;
+use tauri::webview::WebviewWindowBuilder;
 
 // ── State ───────────────────────────────────────────────────────────────────
 
@@ -160,6 +161,39 @@ fn save_config(config: &AppConfig) {
     }
 }
 
+// ── Premier lancement (#160) ───────────────────────────────────────────────
+
+/// Répertoire de démarrage monté comme vault au premier lancement.
+const STARTER_VAULT_NAME: &str = "ObsiGate";
+/// Document d'accueil écrit (si absent) dans le répertoire de démarrage.
+const WELCOME_DOC_NAME: &str = "Prise en main.md";
+const WELCOME_DOC: &str = include_str!("prise_en_main.md");
+
+/// Config par défaut au premier lancement — pure, sans I/O (testable).
+/// `<home>/ObsiGate` est monté comme vault ET comme contexte initial ; le
+/// dossier home reste une racine, nommée d'après son dernier segment
+/// (fin du « bruno » codé en dur, #160).
+fn default_first_run_config(home: &str) -> AppConfig {
+    let home_path = std::path::Path::new(home);
+    let vault_dir = home_path.join("ObsiGate");
+    let vault_path = vault_dir.to_string_lossy().to_string();
+    AppConfig {
+        vault_path: Some(vault_path.clone()),
+        vaults: vec![VaultConfig {
+            name: STARTER_VAULT_NAME.to_string(),
+            path: vault_path,
+        }],
+        dirs: vec![DirConfig {
+            name: home_path
+                .file_name()
+                .map(|s| s.to_string_lossy().to_string())
+                .unwrap_or_else(|| home.to_string()),
+            path: home.to_string(),
+        }],
+        ..AppConfig::default()
+    }
+}
+
 // ── Backend lifecycle ───────────────────────────────────────────────────────
 
 fn spawn_backend(exe_dir: &PathBuf) -> Result<Child, String> {
@@ -320,6 +354,18 @@ async fn pick_vault_folder(app: tauri::AppHandle) -> Result<String, String> {
     }
 }
 
+/// Sélecteur de dossier générique, sans effet de bord (contrairement à
+/// `pick_vault_folder` qui écrit `vault_path` + `wizard_done` pour le wizard).
+/// Sert à l'ajout d'un dossier racine depuis la section Configuration (#159).
+#[tauri::command]
+async fn pick_folder(app: tauri::AppHandle) -> Result<String, String> {
+    use tauri_plugin_dialog::DialogExt;
+    match app.dialog().file().blocking_pick_folder() {
+        Some(p) => Ok(p.to_string()),
+        None => Err("No folder selected".to_string()),
+    }
+}
+
 #[tauri::command]
 fn get_wizard_state() -> bool {
     load_config().wizard_done
@@ -343,6 +389,13 @@ fn get_system_theme(app: tauri::AppHandle) -> String {
     }
 }
 
+/// La jump list des raccourcis suit les vaults : à rafraîchir après tout
+/// ajout/retrait de vault (#159). Best-effort — `update_jumplist` logge et n'échoue jamais.
+fn refresh_jumplist() {
+    let vaults = load_config().vaults;
+    jumplist::update_jumplist(&jumplist::build_vault_args(&vaults));
+}
+
 #[tauri::command]
 fn add_vault(name: String, path: String) -> Result<(), String> {
     let mut config = load_config();
@@ -350,6 +403,7 @@ fn add_vault(name: String, path: String) -> Result<(), String> {
     config.vaults.retain(|v| v.name != name);
     config.vaults.push(VaultConfig { name: name.clone(), path });
     save_config(&config);
+    refresh_jumplist();
     info!("Vault added: {} — restart backend to apply", name);
     Ok(())
 }
@@ -359,6 +413,7 @@ fn remove_vault(name: String) -> Result<(), String> {
     let mut config = load_config();
     config.vaults.retain(|v| v.name != name);
     save_config(&config);
+    refresh_jumplist();
     info!("Vault removed: {} — restart backend to apply", name);
     Ok(())
 }
@@ -513,7 +568,7 @@ fn main() {
     // Load config for window state
     let mut config = load_config();
 
-    // First run: create sensible defaults per platform
+    // First run: create sensible defaults per platform (#160)
     if config.vaults.is_empty() {
         info!("First run — creating default vault configuration");
         #[cfg(target_os = "windows")]
@@ -521,25 +576,28 @@ fn main() {
         #[cfg(not(target_os = "windows"))]
         let home = std::env::var("HOME").unwrap_or_else(|_| "/home/bruno".to_string());
 
-        let vault_dir = std::path::PathBuf::from(&home).join("voute_obsidian");
-        // Create the vault directory if it doesn't exist
-        if !vault_dir.exists() {
-            if let Err(e) = fs::create_dir_all(&vault_dir) {
-                error!("Failed to create default vault dir {}: {}", vault_dir.display(), e);
-            } else {
-                info!("Created default vault dir: {}", vault_dir.display());
+        // Montage du répertoire de démarrage (vault + contexte initial) sans
+        // toucher aux autres champs (taille/position de fenêtre) de la config.
+        let defaults = default_first_run_config(&home);
+        config.dirs = defaults.dirs;
+        config.vaults = defaults.vaults;
+        config.vault_path = defaults.vault_path;
+
+        let vault_dir = std::path::PathBuf::from(config.vaults[0].path.clone());
+        if let Err(e) = fs::create_dir_all(&vault_dir) {
+            error!("Failed to create default vault dir {}: {}", vault_dir.display(), e);
+        } else {
+            info!("Created default vault dir: {}", vault_dir.display());
+        }
+        // Document d'accueil : écrit une seule fois, jamais écrasé (#160).
+        let welcome = vault_dir.join(WELCOME_DOC_NAME);
+        if !welcome.exists() {
+            match fs::write(&welcome, WELCOME_DOC) {
+                Ok(()) => info!("Welcome document written: {}", welcome.display()),
+                Err(e) => error!("Failed to write {}: {}", welcome.display(), e),
             }
         }
-        config.dirs = vec![
-            DirConfig { name: "bruno".to_string(), path: home.clone() },
-        ];
-        config.vaults = vec![
-            VaultConfig {
-                name: "Obsidian".to_string(),
-                path: vault_dir.to_string_lossy().to_string(),
-            },
-        ];
-        config.vault_path = Some(home);
+
         save_config(&config);
         info!("Default vault config saved");
     }
@@ -589,6 +647,7 @@ fn main() {
             get_wizard_state,
             complete_wizard,
             pick_vault_folder,
+            pick_folder,
             get_system_theme,
             restart_backend,
             check_backend_health,
@@ -602,6 +661,19 @@ fn main() {
             list_dirs,
         ])
         .setup(move |app| {
+            // BUG-107 / #89 — HTML5 drag & drop des fichiers : Tauri installe
+            // son propre IDropTarget par-dessus celui du WebView2 (wry :
+            // « find the WebView2 window and override! ») et aucun événement
+            // natif n'est écouté ici → les glisser-déposer depuis
+            // l'Explorateur n'atteignaient jamais la page. La fenêtre est donc
+            // créée manuellement (`create: false` dans tauri.conf.json) avec
+            // le handler désactivé : la page reçoit les drops comme sur le web.
+            let window_config = app.config().app.windows[0].clone();
+            WebviewWindowBuilder::from_config(app, &window_config)
+                .expect("fenêtre principale (tauri.conf.json)")
+                .disable_drag_drop_handler()
+                .build()?;
+
             // Build native menu bar (File / Edit / Help)
             let _ = build_native_menu(app);
 
@@ -1122,4 +1194,116 @@ mod tests {
         let dbg = format!("{:?}", d);
         assert!(dbg.contains("x"));
     }
+
+    /// Guardrail ACL : toute commande Tauri invoquée par le frontend doit
+    /// figurer dans desktop/permissions/commands.toml. La page servie par le
+    /// backend (http://127.0.0.1) est une origine *remote* pour Tauri v2 :
+    /// sans cette entrée, la commande est rejetée « not allowed by ACL » et
+    /// desktop.js:invoke() avale l'erreur → bouton silencieusement mort
+    /// (bouton « Choisir mon dossier » du wizard, BUG-104).
+    #[test]
+    fn test_frontend_invokes_are_acl_allowed() {
+        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+        let perms = fs::read_to_string(dir.join("permissions/commands.toml"))
+            .expect("desktop/permissions/commands.toml manquant");
+        let main_src = fs::read_to_string(dir.join("src/main.rs")).unwrap();
+
+        // Commandes déclarées dans le manifeste de permissions.
+        let allow_list = perms
+            .split("commands.allow")
+            .nth(1)
+            .and_then(|s| s.split(']').next())
+            .unwrap_or("");
+        let allowed: Vec<String> = allow_list
+            .split('"')
+            .skip(1)
+            .step_by(2)
+            .map(|s| s.to_string())
+            .collect();
+        assert!(!allowed.is_empty(), "commands.allow vide dans commands.toml");
+
+        // Chaque permission doit correspondre à une commande réellement
+        // enregistrée (faute de frappe → permission morte).
+        for cmd in &allowed {
+            assert!(
+                main_src.contains(&format!("fn {cmd}(")),
+                "permission allow pour la commande inconnue {cmd}"
+            );
+        }
+
+        // Toute commande invoke('…') du frontend doit être autorisée.
+        let js_dir = dir.join("../frontend/js");
+        let mut seen = 0usize;
+        for entry in fs::read_dir(&js_dir).unwrap() {
+            let path = entry.unwrap().path();
+            if path.extension().and_then(|e| e.to_str()) != Some("js") { continue; }
+            let src = fs::read_to_string(&path).unwrap();
+            let mut rest = src.as_str();
+            while let Some(pos) = rest.find("invoke('") {
+                rest = &rest[pos + "invoke('".len()..];
+                let name: String = rest.chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '_').collect();
+                if !name.is_empty() {
+                    seen += 1;
+                    assert!(
+                        allowed.contains(&name),
+                        "commande {name} invoquée par {} absente de permissions/commands.toml",
+                        path.file_name().unwrap().to_string_lossy()
+                    );
+                }
+                rest = &rest[rest.find('\'').map(|i| i + 1).unwrap_or(rest.len())..];
+            }
+        }
+        assert!(seen > 0, "aucun invoke('…') trouvé dans frontend/js");
+    }
+
+    /// BUG-107 : la fenêtre est créée en code (`create: false`) avec le
+    /// handler de drag & drop de Tauri désactivé. Si l'un des deux manque,
+    /// wry réinstalle son IDropTarget par-dessus celui du WebView2 et les
+    /// glisser-déposer de fichiers depuis l'Explorateur n'atteignent plus la
+    /// page (#89 fonctionnait uniquement sur le web).
+    #[test]
+    fn test_window_created_without_tauri_drag_drop_handler() {
+        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+        let conf = fs::read_to_string(dir.join("tauri.conf.json")).unwrap();
+        assert!(
+            conf.contains("\"create\": false"),
+            "tauri.conf.json : la fenêtre doit être créée en code (create: false)"
+        );
+        let main_src = fs::read_to_string(dir.join("src/main.rs")).unwrap();
+        assert!(
+            main_src.contains("disable_drag_drop_handler()"),
+            "main.rs : disable_drag_drop_handler() manquant — drag & drop bloqué"
+        );
+    }
+
+    /// #160 — premier lancement : `<home>/ObsiGate` monté comme vault et
+    /// comme contexte initial, racine home nommée d'après son chemin.
+    #[test]
+    fn test_default_first_run_config() {
+        #[cfg(target_os = "windows")]
+        let home = r"C:\Users\alice";
+        #[cfg(not(target_os = "windows"))]
+        let home = "/home/alice";
+
+        let c = default_first_run_config(home);
+        assert_eq!(c.vaults.len(), 1);
+        assert_eq!(c.vaults[0].name, STARTER_VAULT_NAME);
+        assert!(c.vaults[0].path.ends_with("ObsiGate"), "{}", c.vaults[0].path);
+        assert_eq!(c.vault_path.as_deref(), Some(c.vaults[0].path.as_str()));
+        assert_eq!(c.dirs.len(), 1);
+        assert_eq!(c.dirs[0].name, "alice", "nom de racine dérivé du chemin");
+        assert_eq!(c.dirs[0].path, home);
+        assert!(!c.wizard_done);
+    }
+
+    /// #160 — le document d'accueil est embarqué dans le binaire : non vide,
+    /// Markdown, et nom de fichier stable (écrit une seule fois sur le disque).
+    #[test]
+    fn test_welcome_doc_embedded() {
+        assert!(WELCOME_DOC.len() > 500, "document d'accueil trop court");
+        assert!(WELCOME_DOC.starts_with('#'), "attendu : titre Markdown");
+        assert!(WELCOME_DOC.contains("ObsiGate"));
+        assert!(WELCOME_DOC.contains("Ctrl+Espace"));
+        assert_eq!(WELCOME_DOC_NAME, "Prise en main.md");
+    }
 }

desktop/src/prise_en_main.md

@@ -0,0 +1,41 @@
+# 🟢 Bienvenue sur ObsiGate — Prise en main
+
+Ce dossier `%USERPROFILE%\ObsiGate` est votre **espace de départ** : il est
+monté automatiquement comme vault **ObsiGate** au premier lancement. Vous
+pouvez y écrire librement, puis brancher vos vrais vaults Obsidian quand vous
+êtes prêt.
+
+## ObsiGate en 30 secondes
+
+ObsiGate est une porte d'entrée locale vers vos notes : index en mémoire,
+recherche instantanée, lecture Markdown avec liens `[[wikilinks]]`, images,
+PDF, tableurs Excel, Excalidraw, Mermaid et assistant IA — sans base de
+données, sans modification de vos fichiers, tout reste sur votre machine.
+
+## Premiers pas (application desktop)
+
+1. **Ce document** s'affiche dans la visionneuse : c'est votre première note,
+   modifiez-la ou supprimez-la quand vous n'en avez plus besoin.
+2. **Ajouter vos vaults** : Configuration → « 🖥️ Vaults & dossiers (Desktop) »
+   → *Ajouter un vault* (sélecteur de dossier natif). Depuis la sidebar,
+   clic droit sur une racine → « Retirer de l'application » la désiste
+   (aucun fichier n'est supprimé).
+3. **Naviguer** : la sidebar liste vos racines et leur arbre ; l'onglet
+   Navigation parcourt un dossier sous forme de vues répertoire.
+4. **Rechercher** : `Ctrl+Espace` (palette de fichiers),
+   `Ctrl+Alt+Espace` (palette de commandes), `Ctrl+F` dans un document.
+5. **Onglets** : `Ctrl+W` ferme l'onglet, `Ctrl+Tab` bascule ; le mode split
+   divise l'écran en panneaux.
+6. **Guide complet** : bouton d'aide de l'en-tête — sommaire, raccourcis,
+   architecture, et téléchargement du guide en Markdown/PDF.
+
+## Le saviez-vous ?
+
+- Le **glisser-déposer** de fichiers depuis l'Explorateur est pris en charge :
+  déposez-les sur la fenêtre pour les importer.
+- Le **clic droit** est partout : menus contextuels de fichier, dossier et
+  vault (avec renommage, création, suppression, vue graphique).
+- Le **watcher** surveille vos vaults : une note modifiée dans Obsidian
+  apparaît immédiatement ici.
+
+— *Ce fichier vous appartient.*

desktop/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/nicedoc/obsigate/main/desktop/tauri.conf.schema.json",
   "productName": "ObsiGate",
-  "version": "2.49.2",
+  "version": "2.68.1",
   "identifier": "com.obsigate.desktop",
   "build": {
     "frontendDist": "../frontend",
@@ -13,6 +13,7 @@
     "withGlobalTauri": true,
     "windows": [
       {
+        "create": false,
         "title": "ObsiGate",
         "width": 1200,
         "height": 800,

docker-compose.test-linux.yml

@@ -13,14 +13,14 @@ services:
       context: .
     image: obsigate:latest
     container_name: obsigate-test
-    user: "1000:1000"
+    user: "197609:197609"
     restart: unless-stopped
     ports:
       - "2021:8080"
     volumes:
-      - /tmp/obsigate-test-vault:/vaults/TestVault
-      - /tmp/obsigate-test-dir:/vaults/TestDir
-      - /tmp/obsigate-test-data:/app/data
+      - ./test_vault:/vaults/TestVault
+      - ./test_dir:/vaults/TestDir
+      - obsigate_data:/app/data
     environment:
       - VAULT_1_NAME=TestVault
       - VAULT_1_PATH=/vaults/TestVault
@@ -51,3 +51,4 @@ services:
 
 volumes:
   ollama_data:
+  obsigate_data:

docker-compose.test-win.yml

@@ -21,12 +21,17 @@ services:
     volumes:
       - /c/dev/git/python/ObsiGate/test_vault:/vaults/TestVault
       - /c/dev/git/python/ObsiGate/test_dir:/vaults/TestDir
+      # #194 : racine des dossiers persos — UN seul montage pour tous les
+      # utilisateurs (dossier hôte : mkdir test_home à côté du dépôt).
+      - /c/dev/git/python/ObsiGate/test_home:/vaults/Home
       - obsigate_data:/app/data
     environment:
       - VAULT_1_NAME=TestVault
       - VAULT_1_PATH=/vaults/TestVault
       - DIR_1_NAME=TestDir
       - DIR_1_PATH=/vaults/TestDir
+      # #194 : dossier personnel par utilisateur = <racine>/home-<user>
+      - OBSIGATE_HOME_ROOT=/vaults/Home
       - OBSIGATE_AUTH_ENABLED=true
       - OBSIGATE_ADMIN_USER=admin
       - OBSIGATE_ADMIN_PASSWORD=test123

docker-compose.yml

@@ -36,6 +36,9 @@ services:
       - /NFS/OBSIDIAN_DOC/Obsidian_WORKOUT:/vaults/Obsidian_WORKOUT
       - /NFS/OBSIDIAN_DOC/SessionsManager:/vaults/SessionsManager
       - /home/bruno:/vaults/bruno
+      # #194 : racine des dossiers perso — UN seul montage pour tous les
+      # utilisateurs (un montage par user demanderait un redémarrage).
+      - /NFS/OBSIDIAN_DOC/Home:/vaults/Home
       - /DOCKER_CONFIG/ObsiGate/data:/app/data
     environment:
       - VAULT_1_NAME=Recettes
@@ -50,6 +53,8 @@ services:
       - VAULT_5_PATH=/vaults/SessionsManager
       - DIR_1_NAME=Bruno
       - DIR_1_PATH=/vaults/bruno
+      # #194 : dossier personnel par utilisateur = <racine>/home-<user>
+      - OBSIGATE_HOME_ROOT=/vaults/Home
       - OBSIGATE_AUTH_ENABLED=true
       - OBSIGATE_ADMIN_USER=admin
       # OBSIGATE_ADMIN_PASSWORD → .env

docs/Assistant-V2/ASSISTANT-V2.md

@@ -0,0 +1,527 @@
+# Assistant V2 — ObsiGate comme second cerveau & assistant personnel
+
+> **Statut :** 📐 Spécification de conception (non implémentée)
+> **Dernière mise à jour :** 2026-10-08
+> **IDs proposés :** ObsiGate **#191 → #201** (liste « Assistant V2 »)
+> **Portée :** évolution de l'assistant IA existant en assistant à mémoire long terme,
+> outillé (connecteurs externes), planifié (rappels, briefing) et proactif (insights).
+> **Hors portée :** toute intégration avec l'infrastructure externe du homelab
+> (Honcho, Hermes, Ollama partagé, ntfy homelab, cron système). ObsiGate est **autonome** :
+> un seul conteneur, ses propres stores, ses propres clés.
+
+---
+
+## 1. Vision
+
+Transformer ObsiGate d'un portail de notes avec assistant vers un **second cerveau
+conversationnel et autonome** :
+
+1. **Il se souvient** — mémoire long terme structurée (faits, préférences, décisions,
+   entités), consolidée chaque nuit, **visible et éditable en markdown dans le vault**
+   (pas de boîte noire).
+2. **Il agit** — lit/écrit le vault, mais aussi les services externes connectés :
+   Gmail, Google Agenda, Teams, Discord, Notion, Drive… (cadre de connecteurs unifié).
+3. **Il anticipe** — rappels conversationnels, briefing quotidien généré par l'agent,
+   détection de boucles ouvertes et d'engagements non tenus.
+4. **Il centralise** — ObsiGate devient le point d'entrée unique prise de notes +
+   assistant ; tout le reste (desktop Tauri, MCP externe, PWA mobile) n'est qu'un
+   accès à *ce même* cerveau.
+
+Le modèle économique de la conception : **Muse/Snow/ChatGPT-Memory rendent l'effet
+« l'assistant me connaît » ; ici la mémoire est auditable (markdown dans le vault,
+audit log, dédupli, réversibilité) et les données ne quittent jamais le stack ObsiGate
+sauf appel explicite aux API des services que Bruno a connectés lui-même.**
+
+---
+
+## 2. Principes directeurs (non négociables)
+
+| # | Principe | Conséquence technique |
+|---|---|---|
+| P1 | **Autonomie du stack** | Tout vit dans le conteneur `obsigate` + son volume `data/`. Aucun nouveau conteneur runtime (Ollama est retiré — voir §9). |
+| P2 | **Zéro framework d'agent externe** | Décision déjà prise en #92 : boucle maison `backend/agent/loop.py`. L'Assistant V2 l'étend, ne la remplace pas. |
+| P3 | **Un outil = un `@tool`** | Toute nouvelle capacité passe par le registre typé (`backend/tools/registry.py`) : risque, scope, rate-limit, confirmation, audit, labels + i18n. |
+| P4 | **Mémoire = markdown d'abord** | Les artefacts durables (profil, insights, briefings, rappels) sont des notes du vault ; la base SQLite n'est que l'index reconstructible. |
+| P5 | **Humain dans la boucle** | `WRITE`/`DANGEROUS` exigent confirmation (#91/#92) ; un fait de confiance faible reste `pending` tant que l'utilisateur ne le valide pas. |
+| P6 | **Secrets jamais committés** | Pattern existant : `data/api_keys.json` / `data/connector_secrets.json` (0600) ou variables `OBSIGATE_*` dans `.env` (`env_file`, jamais dans le compose). |
+| P7 | **i18n FR/EN systématique** | Toute clé d'interface (`ai.step.*`, config connecteurs, cartes mémoire) existe dans les deux locales. |
+| P8 | **Le desktop Tauri reste fonctionnel** | Les connecteurs se dégradent silencieusement hors ligne (capability = absente si pas de token) ; aucune dépendance à un service réseau au démarrage. |
+| P9 | **Sécurité existante réutilisée** | `_resolve_safe_path()`, `require_auth`/`require_vault_access`, SSRF guards (`validate_webhook_url`, `is_safe_target`), `secret_redactor` avant tout appel LLM. |
+
+---
+
+## 3. Inventaire de l'existant (socle sur lequel on bâtit)
+
+Constat clé : **l'ossature « agent » existe déjà**. Ce qui manque, c'est la mémoire
+long terme, les connecteurs, la couche proactive et l'ordonnancement de haut niveau.
+
+| Brique | Fichier(s) | État | Rôle dans la V2 |
+|---|---|---|---|
+| Boucle agent multi-étapes + tool calling natif | `backend/agent/loop.py` (`run_agent`), `backend/ai_chat.py` (payload `tools`/`tool_choice`, conversion Gemini, fallback si refus) | ✅ livré (#91/#92) | Moteur de l'assistant V2 — inchangé |
+| Registre d'outils typé | `backend/tools/registry.py` (`@tool`, `ToolRisk` READ/WRITE/DANGEROUS, `ToolScope` IN_APP/MCP, confirmation auto si non-READ, rate-limit, audit, schéma OpenAI) | ✅ | Cadre d'insertion de **tous** les nouveaux outils |
+| Outils vault (~26) | `backend/tools/service.py`, `backend/services/*` (files, mutations, search, vaults, duplicates…) | ✅ | Outils natifs de l'assistant |
+| Recherche TF-IDF + sémantique embeddings (RRF) | `backend/search.py`, `backend/semantic_search.py`, `requirements-semantic.txt` (sentence-transformers **local, optionnel**, FAISS) | ✅ (#70) | Retrieval de la mémoire épisodique ; remplace le besoin Ollama embeddings |
+| Historique de conversation persistant | `backend/ai_history.py` (`data/sessions`, par utilisateur) | ✅ (#95) | **Mémoire épisodique** brute — source de la consolidation |
+| Serveur MCP externe | `backend/mcp/server.py` (Streamable HTTP `/mcp`, propose/apply) | ✅ (#79) | Même registre exposé — les outils V2 en profitent gratis |
+| Scheduler type cron | `backend/scheduler.py` (tick asyncio 60 s, `data/scheduled_tasks.json`, `interval_hours`/`daily_time`/`once_at`, actions `create_file`/`append_to_file`/`notify`) + outils `create/list/delete/run_scheduled_task` (`backend/tools/scheduled.py`) | ✅ (#170) | Socle des rappels & briefing — à étendre (§8) |
+| Notifications externes | `backend/notify.py` (canaux **Discord webhook, Telegram, SMTP, webhook générique**, triggers, secrets 0600) + outil `notify_external` | ✅ (#168) | Bras de sortie des rappels/briefing |
+| Web Push PWA | `backend/push.py` (VAPID) + `frontend/sw.js` | ✅ (#67) | Deuxième canal de rappel, sans dépendance externe |
+| Sources connectées (premier précédent) | `backend/tools/connected.py` (Gitea/GitHub, READ), page Configurations #103, `backend/tools/secrets.py` | ✅ (#92/#103) | Patron à généraliser en cadre connecteurs (§7) |
+| Web : recherche + fetch + crawl | `backend/tools/web.py` (Tavily/Brave/SerpAPI/Exa/SearXNG, `fetch_url`), `backend/tools/crawler.py` (`crawl_site`) | ✅ | Outils « connaissances hors vault » |
+| Production de documents | `backend/tools/documents.py` (`create_xlsx/docx/csv/pdf`) | ✅ | Actions de l'assistant |
+| Doublons | `backend/tools/duplicates.py` (`find_duplicates`, `merge_duplicate_notes` DANGEROUS) | ✅ (#166) | Hygiène de la mémoire |
+| Skills / slash-commandes | `backend/skills.py` (`/cmd`, `data/skills.json`) | ✅ | Vecteur naturel des prompts de consolidation & briefing |
+| Cache SQLite | `backend/tools/webcache.py` (précédent `sqlite3` stdlib dans `data/`) | ✅ | Patron du store mémoire (§5) |
+| Fournisseurs LLM | `backend/ai.py` (`PROVIDERS` : deepseek, openrouter, gemini, nvidia, qwencloud, xiaomi, mistral, ollama), `reload_ai_config()`, clés `data/api_keys.json` + fallback env | ✅ | Garder le multi-provider ; **retirer le conteneur ollama** (§9) |
+| Audit + redaction | `backend/audit.py`, `backend/tools/audit.py`, `backend/secret_redactor.py` | ✅ | Traçabilité mémoire/connecteurs |
+
+**Gaps** (→ §5–§8) : mémoire sémantique (faits) · miroir markdown · consolidation ·
+cadre connecteurs générique + OAuth2 · Gmail/Calendar/Teams/Discord(in)/Notion/Drive ·
+rappels conversationnels · agent programmé (briefing) · insights proactifs.
+
+---
+
+## 4. Architecture cible
+
+```
+                       ┌────────────────────────────────────────────┐
+                       │              FRONTEND (SPA + PWA + Tauri)  │
+                       │  Assistant panel · Cartes mémoire · Config │
+                       │  « Sources connectées » · Briefings        │
+                       └───────────────┬────────────────────────────┘
+                                       │ REST + SSE (existant)
+┌──────────────────────────────────────▼─────────────────────────────────────┐
+│                          BACKEND obsigate (1 conteneur)                    │
+│                                                                            │
+│  ┌──────────────┐   ┌──────────────────┐   ┌────────────────────────────┐  │
+│  │ agent/loop.py│◄──│ tools/registry.py│◄──│ TOUS les outils V2 (@tool) │  │
+│  │  (run_agent) │   │  risque/scope/   │   │ vault · web · docs (exist.)│  │
+│  └──────┬───────┘   │  audit/limit     │   │ memory.* (nouveau §5)      │  │
+│         │           └──────────────────┘   │ connector.* (§7)           │  │
+│  ┌──────┴────────┐                          │ reminder.* (§8)           │  │
+│  │ ai_chat.py    │                          │ scheduled.* (étendu)      │  │
+│  │ providers API │                          └────────────────────────────┘  │
+│  └──────┬────────┘                                                         │
+│         │                                                                  │
+│  ┌──────▼───────────┐  ┌────────────────────┐  ┌───────────────────────┐   │
+│  │ scheduler.py     │  │ memory/            │  │ connectors/           │   │
+│  │  tick 60 s       │  │  store SQLite      │  │  base OAuth2+PKCE     │   │
+│  │  + agent_prompt  │─►│  (faits)           │  │  gmail/gcal/teams/    │   │
+│  │  (nouv. action)  │  │  consolidator      │  │  discord/notion/drive │   │
+│  └──────┬───────────┘  └─────────┬──────────┘  └───────────┬───────────┘   │
+│         │ notify.broadcast       │ miroir markdown         │ HTTPS API     │
+│         │ + Web Push             ▼                         ▼               │
+│  ┌──────▼──────────┐   ┌────────────────────┐   ┌─────────────────────┐    │
+│  │ Vault Obsidian  │   │ Vault Obsidian     │   │ Services externes   │    │
+│  │ (5 volumes NFS) │   │ 99_Assistant/*.md  │   │ (Google/MS/Discord) │    │
+│  └─────────────────┘   └────────────────────┘   └─────────────────────┘    │
+└────────────────────────────────────────────────────────────────────────────┘
+```
+
+Nouveaux modules backend (alignés sur l'organisation existante) :
+
+```
+backend/
+  memory/
+    store.py          # SQLite data/memory.sqlite3 — CRUD faits + runs
+    recall.py         # fusion recall: facts + sémantique (#70) + épisodes (ai_history)
+    consolidator.py   # job « dreaming » nocturne (prompt + parsing + dédup)
+    mirror.py         # rendu markdown 99_Assistant/ + parse des edits humains
+  connectors/
+    base.py           # ConnectorInterface: id, scopes, authorize_url, exchange,
+                      #   refresh, capabilities(), call() (retry + rate-limit + audit)
+    oauth.py          # flux code + PKCE, redirect /api/connectors/{id}/callback
+    registry.py       # registre des connecteurs installés (comme tools/registry)
+    gmail.py  gcal.py  teams.py  discord.py  notion.py  drive.py
+  routers/
+    connectors.py     # CRUD admin: installation, statut, test de connexion
+    memory.py         # API faits (liste/édit/suppression/validation pending)
+  tools/
+    memory.py         # @tool memory.* (§5.4)
+    reminders.py      # @tool reminder.* (§8.1)
+    connectors.py     # @tool par capability connecteur (§7.4)
+```
+
+---
+
+## 5. Mémoire long terme — #192 (socle), #193 (miroir), #194 (consolidation)
+
+### 5.1 Modèle de données (SQLite, `data/memory.sqlite3`)
+
+Précédent : `webcache.py`. Une seule table applicative + une table d'audit des runs.
+
+```sql
+CREATE TABLE facts (
+  id            TEXT PRIMARY KEY,          -- f-<uuid4>
+  user_id       TEXT NOT NULL,
+  subject       TEXT NOT NULL,             -- ex: "santé", "Projet FlowDeck", "bruno"
+  predicate     TEXT NOT NULL,             -- ex: "rdv", "préférence", "décision"
+  value         TEXT NOT NULL,             -- contenu FR court (< 500 car.)
+  kind          TEXT NOT NULL CHECK (kind IN
+    ('preference','decision','entity','event','habit','goal','open_loop')),
+  confidence    REAL NOT NULL DEFAULT 0.5, -- 0..1 ; < 0.7 → status pending
+  status        TEXT NOT NULL DEFAULT 'confirmed'
+                CHECK (status IN ('pending','confirmed','rejected','expired')),
+  source        TEXT NOT NULL,             -- 'consolidation' | 'user' | 'chat'
+  source_ref    TEXT,                      -- session id ou chemin de note
+  supersedes    TEXT,                      -- id du fait remplacé (dédup temporel)
+  created_at    TEXT NOT NULL, updated_at TEXT NOT NULL,
+  last_seen_at  TEXT NOT NULL,             -- reinforcement par usage
+  expires_at    TEXT                       -- nullable (ex: rdv passé)
+);
+CREATE INDEX idx_facts_subject ON facts(user_id, subject);
+CREATE INDEX idx_facts_status  ON facts(user_id, status);
+
+CREATE TABLE consolidation_runs (
+  id TEXT PRIMARY KEY, started_at TEXT, finished_at TEXT,
+  sessions_consumed INTEGER, notes_changed INTEGER,
+  facts_added INTEGER, facts_updated INTEGER, error TEXT
+);
+```
+
+Règles :
+- **Dédup temporel** : un nouveau fait `(subject, predicate)` avec valeur différente
+  crée une ligne et marque l'ancienne `superseded` (via `supersedes`, status `expired`).
+  Historique conservé, recall = dernier `confirmed` non expiré.
+- **Renforcement** : `last_seen_at` bump quand le fait est réaffirmé en chat ;
+  les facts non revus depuis N jours (180) et non `decision` deviennent `expired`.
+- **PII santé/famille** : `consolidator` force `status='pending'` (validation humaine
+  via cartes) si la note source appartient aux dossiers sensibles configurables
+  (`OBSIGATE_MEMORY_REVIEW_FOLDERS`, ex. `Santé,Famille`).
+- Backup : `data/` étant déjà dans le cycle de backups existant, rien de neuf.
+
+### 5.2 Miroir markdown dans le vault — #193
+
+Dossier **`99_Assistant/`** (créé à la première activation, dans le vault principal
+configurable `OBSIGATE_MEMORY_VAULT=Main`, dossier racine configurable) :
+
+| Fichier | Contenu | Écrit par | Éditable par Bruno |
+|---|---|---|---|
+| `Profil.md` | Préférences/habitus/goals confirmés, groupés par sujet (H2) | mirror (consolidation) | ✅ — les edits sont respectés (§5.3 règles de merge) |
+| `Insights.md` | Détections proactes #201 (boucles ouvertes, engagements, patterns), horodatées | mirror | ✅ (suppression = `rejected` en base) |
+| `Rappels.md` | Table des rappels actifs (liens vers tâches planifiées) | mirror scheduler | lecture seule (UI dédiée) |
+| `Briefings/YYYY-MM-DD.md` | Briefing quotidien #200 | agent programmé | ✅ (archivage, jamais régénéré) |
+| `Journal.md` | Dernières consolidations (nb faits ajoutés/validés) | mirror | lecture seule |
+
+Le miroir utilise des **balises HTML de section** :
+
+```markdown
+<!-- obsigate:managed:preferences -->
+…bloc régénéré…
+<!-- /obsigate:managed:preferences -->
+```
+
+Règle de merge : à chaque écriture, le mirror compare le contenu précédent généré
+(hash stocké en base) avec le contenu actuel du fichier. Si l'utilisateur a modifié
+l'intérieur d'une section gérée → la modification est **re-parse en faits `source='user'`**
+(confiance 1.0, status confirmed) puis la section est régénérée à partir de la base.
+Tout ce qui est hors balises est laissé intact. C'est le mécanisme qui rend la mémoire
+*auditable et contestable* — l'anti-boîte-noire.
+
+### 5.3 Consolidation nocturne (« dreaming ») — #194
+
+Job planifié via le scheduler existant (§8.3), action `agent_prompt` dédiée :
+
+1. **Collecte incrémentale** : sessions `ai_history` créées/modifiées depuis le dernier
+   run + fichiers `.md` modifiés depuis le dernier run (via l'index/watcher mtime) —
+   plafonds : 200 fichiers × 30 Ko (comme bookslm), contenu `redact_file_content()` avant LLM.
+2. **Extraction** (1 appel LLM, provider par défaut = cheap model) : prompt système
+   d'extraction → JSON `[{subject, predicate, value, kind, confidence}]` validé Pydantic ;
+   rejet des valeurs non sourcées.
+3. **Réconciliation** (déterministe, stdlib) : dédup/supersede par `(subject,predicate)`,
+   plancher de confiance, dossiers sensibles → pending.
+4. **Écriture** : `facts` + `mirror.py` → sections gérées de `Profil.md`.
+5. **Cartes de validation** : les faits `pending` deviennent des cartes dans le panneau
+   Assistant (« Valider / Modifier / Oublier »), persistées jusqu'à action.
+
+Coût : 1–3 appels API/nuit (deepseek-chat ≈ quelques centimes). Budget max :
+`OBSIGATE_CONSOLIDATION_MAX_TOKENS` (défaut 30 000/jour) pour bornes dures.
+
+### 5.4 Outils mémoire (registés `@tool`) — #192
+
+| Outil | Risque | Description (schéma) |
+|---|---|---|
+| `memory_recall` | READ | `{query, subject?, kind?}` → faits confirmed pertinents + fusion RRF avec sémantique #70 sur le vault. Injecté **automatiquement** dans le prompt système de chaque chat (voir §5.5). |
+| `memory_save` | WRITE | `{subject, predicate, value, kind, confidence=0.9}` — le modèle propose, la carte de confirmation affiche le fait ; Bruno valide → `source='chat'`. |
+| `memory_update` | WRITE | `{fact_id, value | status}` — correction/revalidation. |
+| `memory_forget` | DANGEROUS | `{fact_id}` — status `rejected`, supprimé du miroir, tracé à l'audit. |
+| `profile_get` | READ | `{section?}` → contenu courant de `Profil.md` (plus riche que le recall brut). |
+
+### 5.5 Injection dans le contexte (le « ça me connaît » quotidien)
+
+Au démarrage de chaque session agent (`bookslm_routes` → futur endpoint `/agent`),
+construction d'un bloc mémoire coiffant le prompt système, budget ≤ 2 500 tokens :
+
+```
+<memoried-context>
+Profil (résumé géré) : préférences, habitudes, objectifs actifs…
+Faits saillants liés au sujet : <memory_recall(query=requête utilisateur)>
+Rappels actifs : <n lignes de Rappels.md>
+Dernier briefing : <3 puces>
+</memoried-context>
+```
+
+Ce bloc est **visible** dans la section « étapes » du panneau (label « Mémoire »),
+comme les autres étapes d'outils — pas de magie cachée.
+
+---
+
+## 6. Rattachement MCP / Desktop / Skills
+
+- Tous les nouveaux outils `@tool` sont automatiquement exposés au **serveur MCP**
+  (`/mcp`, scopes IN_APP+MCP par défaut, propose/apply déjà gérés) → Claude Desktop /
+  Cursor bénéficient gratis de `memory.*`, `reminder.*`, `connector.*`.
+- **Skills `/`** : nouvelles built-in `/profil` (montre Profil.md), `/rappel <texte>`
+  (crée un rappel), `/brief` (régénère le briefing du jour), `/consolider`
+  (déclenche le run de consolidation à la demande), `/connecteurs` (état des sources).
+- **Desktop Tauri** : les connecteurs sans token enregistré n'apparaissent pas dans le
+  registre de schémas envoyés au LLM (`list_tools` filtré par capabilities actives) ;
+  zéro appel réseau au démarrage.
+
+---
+
+## 7. Connecteurs externes — #195 (cadre), #196–#198 (implémentations)
+
+### 7.1 Cadre (`backend/connectors/`)
+
+Décision : **remplacer la logique ad hoc de `connected.py` (Gitea/GitHub par variables
+d'env) par un cadre général** — tout en gardant ces deux sources fonctionnelles
+(migration interne, même UX « Sources connectées » #103 étendue).
+
+Concepts :
+
+- **Connector** = classe (id, label, docs URL, scopes OAuth, capabilities nommées).
+- **Installation** = entrée `data/connectors.json` `{id, type, status, config (public),
+  created_at}` ; secrets dans `data/connector_secrets.json` (0600) ou
+  `OBSIGATE_CONNECTOR_SECRET_<ID>` — **même pattern strict que #168/#103**.
+- **Auth** : soit *token statique* (Discord webhook, Notion key, GitHub), soit
+  **OAuth2 authorization-code + PKCE** (Google, Microsoft) :
+  `GET /api/connectors/{id}/authorize` → redirection → `GET /api/connectors/{id}/callback`
+  (échange + stockage `refresh_token` chiffré avec `data/secret.key` existant) →
+  `POST /api/connectors/{id}/test` (validation par un appel READ bon marché).
+- **Refresh** transparent dans `call()` (anticipation du expiry, 1 retry sur 401).
+- **Capabilities → tools** : chaque capability expose un `@tool` (dynamiquement
+  enregistré si le connecteur est installé), préfixé :
+  `gmail.search_messages`, `gcal.list_events`, `teams.list_chats`…
+  Risque par capability (lecture READ / écriture WRITE / envoi DANGEROUS).
+- **Budget & limites** : rate-limit par connecteur via `tools/ratelimit.py`,
+  timeout httpx 15 s, retry backoff (pattern #92), cache SQLite des réponses GET
+  bornées (pattern `webcache.py`, TTL 5 min pour le contexte de chat).
+- **Audit** : chaque `call()` journalisé (connecteur, capability, args tronqués,
+  latence, statut) via `tools/audit.py`.
+
+### 7.2 Matrice des connecteurs cibles
+
+| Connecteur | Auth | Capabilités (→ outil) | Risque | Phase |
+|---|---|---|---|---|
+| **Google — Calendar** | OAuth2 PKCE | `gcal.list_events` (période, requête), `gcal.get_event`, `gcal.create_event`, `gcal.update_event` | READ, READ, WRITE, WRITE | #196 |
+| **Google — Gmail** | OAuth2 PKCE | `gmail.search_messages` (query `is:unread…`), `gmail.read_message`, `gmail.create_draft`, ~~`gmail.send`~~ | READ, READ, WRITE, 🔴 non exposé v1 | #196 |
+| **Google — Drive** | OAuth2 PKCE | `drive.search`, `drive.read_file` (import md/docx → vault) | READ | #198 (rattache backlog #167) |
+| **Microsoft — Teams / Graph** | Entra ID client, OAuth2 | `teams.list_chats`, `teams.read_messages`, `teams.send_message` | READ, READ, WRITE | #197 |
+| **Microsoft — Outlook** | idem Graph | `outlook.search_messages`, `outlook.list_events` (calendriers persos MS) | READ | #197 (optionnel, même jeton) |
+| **Discord** | webhook (sortie, ✅ #168) + **bot token lecture** (entrée, scopes `read`) | `discord.send` (existant via notify), `discord.list_messages`, `discord.search` (REST, pas de gateway websocket en v1) | WRITE, READ, READ | #198 |
+| **Notion** | API key (user token) | `notion.search`, `notion.read_page`, `notion.append_blocks` | READ, READ, WRITE | #198 |
+| **Slack** | webhook sortie + bot token lecture REST | `slack.send`, `slack.search_messages` | WRITE, READ | option future |
+| **Gitea / GitHub** | token (existant) | migrés sous le cadre | READ | #195 (migration) |
+| **Todoist / tasks externes** | token | — | — | hors v1 ; les tâches restent **dans le vault** (checklists) |
+
+Règle transversale : **la prise de notes reste le vault**. Les connecteurs *nourrissent*
+l'assistant (contexte) et reçoivent des *actions* (événement, brouillon, message) ; ils
+ne remplacent jamais la note. C'est l'inverse des apps chat généralistes.
+
+### 7.3 Utilisation des connecteurs par l'assistant
+
+- L'agent choisit les outils selon les demandes (tool-calling existant, `tool_choice=auto`).
+- **Contexte briefing** (§8.2) : agrège `gcal.list_events(jour)` + rappels + mails
+  non lus (si Gmail connecté) + notes modifiées → note de briefing.
+- **Demande type** : « est-ce que j'ai une réponse du dentiste ? » →
+  `gmail.search_messages(from:...)` → cite le mail → propose la note.
+- **Confidentialité** : le contenu des connecteurs entre dans la conversation mais
+  **jamais** dans la consolidation mémoire par défaut (seuls les faits *explicitement*
+  confirmés par l'utilisateur via `memory_save` entrent en base).
+
+### 7.4 UI « Sources connectées » (#103 étendue)
+
+Page Configurations : carte par connecteur (statut, scopes, bouton Connect/Test/
+Déconnecter), journal des derniers appels (audit filtré), budget tokens. Textes FR/EN.
+
+---
+
+## 8. Rappels, briefing, agent programmé — #199 (rappels), #200 (agent+briefing)
+
+### 8.1 Rappels conversationnels — #199
+
+Le scheduler #170 sait déjà planifier `notify`/`create_file`. Les rappels = **action
+typée de haut niveau**, pour que l'assistant puisse les gérer naturellement :
+
+- Nouvelle action scheduler `reminder` : `{user_id, text, deliver: [channels…],
+  recurring: none|daily|weekly|cron}` → au due : `notify.broadcast` + Web Push +
+  append à `99_Assistant/Rappels.md` (historique `Rappels.md` → section « tenus »).
+- Outils : `reminder_create` (WRITE, `{texte, quand (ISO ou relatif « in 3 weeks »
+  résolu côté serveur par la LLM→date), récurrence, canaux}`), `reminder_list` (READ),
+  `reminder_snooze` (WRITE, +`{task_id, delta}` — le snooze bump `last_snoozed_count`,
+  signal pour #201), `reminder_cancel` (WRITE).
+- UX : panneau Assistant « Cloche » + section latérale dédiée ; les rappels dus sont
+  injectés en contexte mémoire (§5.5) pour que l'assistant puisse en parler de lui-même.
+
+### 8.2 Agent programmé — nouveau type d'action `agent_prompt` — #200
+
+Brique générique manquante : le scheduler doit pouvoir **lancer le run_agent** avec un
+prompt, pas seulement des actions primitives.
+
+- Sécurité de la tâche non interactive (pas de confirmation humaine possible) :
+  **whitelist de capacités** — READ sans limite ; WRITE restreint aux chemins
+  `99_Assistant/**` (le prompt d'un scheduled-agent ne peut écrire ailleurs) ;
+  DANGEROUS et `connectors.*` en écriture **interdits**. Paramètre
+  `allowed_extra_tools: []` pour élargir explicitement à la création.
+- Plafonds : max 8 itérations d'outils, budget tokens par tâche, `last_error` +
+  broadcast `schedule_failure` (déjà en place), `last_run_at` persisté.
+- Le **briefing du matin** = built-in : skill `/brief` + tâche `daily_time 07:00`
+  (fuseau `OBSIGATE_TZ`) → prompt agrégateur (§7.3) → écrit `Briefings/YYYY-MM-DD.md`
+  + notification (canaux de l'utilisateur + Web Push).
+- Autres prompts programmatifs naturels : « résumé hebdo des notes modifiées »,
+  « veille » (crawl d'une page + diff dans une note) — mais chacun reste une tâche
+  créée par l'utilisateur ou l'assistant, pas de magie par défaut.
+
+### 8.3 Le job de consolidation passe par `agent_prompt`
+
+#194 s'implémente comme tâche built-in `daily_time 23:30` + whitelist
+`memory.*`/`profile_get` — l'infrastructure d'ordonnancement de #200 sert la mémoire.
+(Ordre de livraison : #200 avant #194, cf. §10.)
+
+---
+
+## 9. Retrait d'Ollama — #191
+
+Objectif utilisateur : ObsiGate ne doit pas hériter de l'infra (ni Ollama, ni Honcho) ;
+et le conteneur Ollama (1,4 Go+ de poids, 2 modèles, RAM) ne sert plus.
+
+1. `docker-compose.yml` : supprimer le service `ollama`, le volume `ollama_data`,
+   les vars `OLLAMA_BASE_URL`/`OLLAMA_MODEL`, et la mention « port 11434 » de l'en-tête.
+   Idem `docker-compose.test-linux.yml` / `docker-compose.test-win.yml`.
+2. `backend/ai.py` / `model_capabilities.py` : **conserver** le provider `ollama`
+   (option de configuration, utile au desktop hors-ligne qui pointe vers un ollama
+   local de l'utilisateur) mais retirer tout défaut pointant vers le réseau interne.
+   Les tests d'isolation : `OBSIGATE_*` ne référence plus `http://ollama:11434`.
+3. Embeddings : par **sentence-transformers local optionnel** (déjà #70) — le mode
+   par défaut de l'Assistant V2 fonctionne **sans embeddings** (TF-IDF + RRF + faits
+   SQLite), les embeddings étant un raffinement auto-détecté (`SemanticIndex` existe,
+   avec fallback API provider si configurée).
+4. Migration : `docker compose down && up -d` (règle .env connue P17/P29) ; supprimer
+   le volume `ollama_data` (procédure documentée dans le CHANGELOG + ROADMAP de la tache #191).
+
+---
+
+## 10. Phasage & IDs
+
+> Chaque tranche est livrable indépendamment, CI verte + DoD `DELIVERY_WORKFLOW.md`,
+> i18n FR/EN, tests, guide utilisateur `docs/GUIDES/`.
+
+| ID | Tranche | Contenu | Effort | Dépend | Critères d'acceptation |
+|---|---|---|---|---|---|
+| #191 | **Purge Ollama** | compose ×3, docs, notes migration | 0,5 j | — | plus aucun conteneur ollama ; AI editor + agent OK sur deepseek/openrouter/gemini |
+| #192 | **Mémoire socle** | `memory/store.py`, `recall.py`, 5 outils `@tool`, tests | 3–4 j | #191 | recall/save/update/forget fonctionnent en chat ; audit + confirmation OK |
+| #193 | **Miroir markdown** | `mirror.py`, `99_Assistant/`, balises gérées, re-parse edits | 2–3 j | #192 | édition manuelle de Profil.md → faits `source='user'` ; réécritures idempotentes |
+| #200 | **Agent programmé + briefing** | action `agent_prompt` (whitelist), skill `/brief`, tâches built-in | 3–4 j | #192 | briefing 07:00 → note + notif ; WRITE limité `99_Assistant/**` prouvé par tests |
+| #194 | **Consolidation nocturne** | `consolidator.py`, incrémental, pending/cartes, budget tokens | 3–4 j | #200, #193 | 1 nuit test → ≥1 fait utile extrait ; aucun secret extrait (redaction test) ; budget respecté |
+| #199 | **Rappels** | action `reminder`, 4 outils, UI cloche, snooze-count | 2–3 j | #200 | « rappelle-moi dans 3 semaines » → rappel réel ; snooze ≥3 → signal visible #201 |
+| #195 | **Cadre connecteurs** | `connectors/` base+oauth+registry, UI Sources, migration Gitea/GitHub | 4–5 j | — | OAuth2 PKCE de bout en bout avec un provider de test ; secrets 0600 |
+| #196 | **Google Calendar + Gmail** | capabilities §7.2, context briefing étendu | 3–4 j | #195 | agenda du jour cité dans briefing ; recherche mail via chat avec confirmation WRITE nulle |
+| #197 | **Microsoft Teams/Outlook** | Graph client min, capabilities READ + send | 3–4 j | #195 | lire un chat Teams et y répondre via carte de confirmation |
+| #198 | **Discord read + Notion + Drive** | capacités restantes §7.2 | 3–5 j | #195 | import page Notion → note vault ; `drive.read_file` OK |
+| #201 | **Proactivité / insights** | détecteurs stdlib (open loops, snoozes, pourrissement TODO, récurrences) → `Insights.md` + suggestions en contexte | 3–4 j | #194, #199 | un scenario « note à faire > 21 jours » et « snooze ×3 » génèrent des insights réels et acceptables/refusables |
+
+Ordre recommandé : `#191 → #192 → #193 → #200 → #194 → #199` (la mémoire et le
+briefing rendent l'assistant utile **sans** connecteur) puis connecteurs `#195 → #196…`
+et enfin `#201` (le coaching a besoin de la mémoire garnie).
+
+---
+
+## 11. Sécurité & confidentialité (rappel explicite)
+
+- **Secrets** : uniquement `data/connector_secrets.json` (0600, chiffrés `secret.key`)
+  ou env `OBSIGATE_CONNECTOR_SECRET_*` — jamais le compose, jamais git (#168/#103).
+- **SSRF** : toutes les URLs configurées par l'utilisateur passent
+  `validate_webhook_url`/`is_safe_target` ; les endpoints des providers OAuth sont
+  une allowlist codée (accounts.google.com, login.microsoftonline.com…).
+- **Chiffrement au repos** optionnel : même pattern que #172 (backlog existant) —
+  si activé, s'applique à `connector_secrets.json` + `memory.sqlite3`.
+- **Redaction** : `redact_file_content()` systématique avant LLM pour toute note
+  consolidée ; jamais le contenu brut des connecteurs dans les prompts hors
+  appel d'outil explicite.
+- **Consentement par tâche planifiée** : les tâches `agent_prompt` listent leurs
+  capacités autorisées dans l'UI, avec journal `last_run` dépliable.
+- **Effacement** : `memory_forget` + purge des sessions #95 + export de la base
+  (`GET /api/memory/export` JSON) → réversibilité complète RGPD-like.
+
+---
+
+## 12. Risques & arbitrages assumés
+
+| Risque | Mitigation |
+|---|---|
+| Qualité variable de l'extraction de faits → mémoire « bruitée » | seuil confiance + pending/cartes ; dossiers sensibles → validation manuelle ; `last_seen` decay ; effacement facile |
+| Coût LLM (consolidation + briefing quotidiens) | cheap model dédié par var `OBSIGATE_AGENT_BACKGROUND_MODEL` ; budgets durs en tokens ; aggregation déterministe (stdlib) avant LLM |
+| Dérive du scheduler qui exécute des prompts non surveillés | whitelist capacités + budget itérations + plafond chemins ; journal d'audit par tâche |
+| Élargissement du scope backend (main.py déjà volumineux) | nouveaux modules dédiés (`memory/`, `connectors/`) ; aucune logique dans `main.py` ; routers séparés |
+| OAuth app Google/Microsoft à créer manuellement (client id) | guide `docs/GUIDES/CONNECTEURS_GOOGLE_MS.md` pas-à-pas FR/EN ; possible de rester sur tokens statiques Notion/GitHub sans projet cloud |
+| Éditions humaines du miroir non re-parsables (markdown libre) | balises `managed` strictes ; sections hors-balises intouchables ; re-parse = faits, pas diff sémantique |
+| Tauri desktop + connecteurs = surface réseau | capabilities absentes du registre tant que non installées ; offline-first global inchangé |
+
+---
+
+## 13. Définition de terminé (par tranche, conforme DoD dépôt)
+
+Pour chaque ID : tests unitaires backend (+tests de non-régression pour tout bug),
+tests JSDOM si UI, E2E Playwright si flux UI touché, ruff/mypy 0 erreur, i18n FR/EN,
+labels `ai.step.*` pour tout nouvel outil, mise à jour `CHANGELOG.md` `[Unreleased]`,
+`docs/ROADMAP.md` (statut + fiche `docs/features/assistant-v2-<slug>.md` par tranche),
+guide utilisateur `docs/GUIDES/` si exposé à l'utilisateur, CI verte, commit conventionnel
+référençant l'ID.
+
+---
+
+## Annexe A — Variables d'environnement nouvelles
+
+```
+# Mémoire
+OBSIGATE_MEMORY_ENABLED=true
+OBSIGATE_MEMORY_VAULT=Main                 # vault où vit 99_Assistant/
+OBSIGATE_MEMORY_REVIEW_FOLDERS=Santé,Famille   # forcent status=pending
+OBSIGATE_CONSOLIDATION_MODEL=              # cheap model, défaut = provider courant
+OBSIGATE_CONSOLIDATION_MAX_TOKENS=30000
+# Briefing / agent programmé
+OBSIGATE_TZ=America/Toronto
+OBSIGATE_BRIEFING_TIME=07:00
+# Connecteurs (ou UI Sources connectées — stockage prioritaire)
+GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRET     # app Google Cloud (consent screen)
+AZURE_CLIENT_ID / AZURE_CLIENT_SECRET       # app Entra ID
+OBSIGATE_NOTION_API_KEY=
+OBSIGATE_DISCORD_BOT_TOKEN=                 # lecture REST uniquement
+```
+
+## Annexe B — Prompt de consolidation (extrait)
+
+```
+Tu extrais des faits durables à partir de notes et conversations récentes d'un
+journal personnel. Pour chaque fait : subject, predicate, value (une phrase,
+français), kind ∈ preference|decision|entity|event|habit|goal|open_loop,
+confidence 0..1. Règles :
+- Uniquement ce qui est explicitement affirmé ou fortement implicite ;
+- Rien de sensible sans appui textuel direct (santé, finances, familles) ;
+- Jamais de mot de passe, token, numéro personnel (signalés comme refusés) ;
+- Si un fait contredit un fait existant, produit le nouveau avec note de supersede.
+Sortie : JSON strict {facts: [...]} — aucun commentaire.
+```
+
+## Annexe C — Prompt du briefing (extrait)
+
+```
+Contexte fourni : agenda du jour (gcal), rappels dus, mails non lus importants
+(gmail si connecté), notes modifiées hier, faits pending à valider.
+Produis une note markdown Briefings/YYYY-MM-DD.md :
+- Aujourd'hui : événements + rappels (liens vault si applicable)
+- À trancher : 2–4 questions ouvertes détectées dans les notes récentes
+- Mémoire : 1–3 faits nouveaux à valider (citez la source note)
+Pas d'invention. Chaque affirmation cite sa source (chemin ou sujet connecteur).
+```

docs/Assistant-V2/Asistant-V2-résumé.md

@@ -0,0 +1,239 @@
+Je vais analyser la solution Assistant V2. Commençons par explorer la structure du projet et localiser les références à "Assistant V2".
+
+
+
+Il y a un dossier `docs/Assistant-V2/` avec plusieurs documents de spécification. Explorons-le en détail.
+
+
+
+Let me lire le document principal et les documents de phase.
+
+
+
+Continuons la lecture du document principal puis des phases.
+
+
+
+Maintenant, lisons les documents de phase V2.1. Vérifions d'abord leur taille.
+
+
+
+Ces documents sont volumineux. Je vais déléguer le résumé des phases 2 à 5 à des sous-agents en parallèle, pendant que je lis moi-même la phase 0 (fondations) et la phase 1, et que je vérifie l'état réel du code.
+
+
+
+
+
+The sub-agents reference a parent document `ASSISTANT-V2.1.md`. Let me check whether it exists, read phases 0 and 1 myself, and inspect the actual backend state.
+
+
+
+Now let me read phase 1 and verify the actual codebase state — whether any of this exists (memory store, runs, policies) and how it's tracked in the roadmap.
+
+
+
+Excellent picture forming. Let me verify the missing parent document references, and how (if at all) this is registered in the roadmap/todolist.
+
+
+
+Key finding: IDs may collide with existing roadmap items. Let me inspect the roadmap's current/upcoming sections and the highest IDs in use.
+
+
+
+Let me do a final quick check on dependencies and existing data stores to ground the component list.
+
+
+
+J'ai lu l'intégralité de la documentation `docs/Assistant-V2/` (7 documents), vérifié l'état réel du code, et croisé le tout avec `ROADMAP.md`, `ISSUES_TODOLIST.md` et les conventions `AGENTS.md`. Voici l'analyse complète.
+
+---
+
+## 0. Verdict en une phrase
+
+**Assistant V2 (et sa suite V2.1) est aujourd'hui une conception de très bonne qualité, mais 100 % non implémentée, non enregistrée dans le Roadmap, et dont le plan d'IDs est cassé par des collisions avec des features déjà livrées.** Le contenu technique est solide et réutilise finement l'existant ; la dette est d'abord méthodologique et documentaire, pas architecturale.
+
+---
+
+## 1. Cartographie des documents
+
+| Fichier | Génération | Statut déclaré | IDs couverts |
+|---|---|---|---|
+| `docs/Assistant-V2/ASSISTANT-V2.md` (528 l.) | **V2** — 2026-10-08 | « Spécification (non implémentée) » | #191 → #201 |
+| `assistant-v21-phase-0-socle-sur.md` (279 l.) | **V2.1** — 2026-10-09 | « Prêt à implémenter » | #191,#192,#193,#206,#213 + amorce #212 |
+| `assistant-v21-phase-1-le-travail.md` (276 l.) | V2.1 | Prêt à implémenter | #202,#203,#204,#205 |
+| `assistant-v21-phase-2-temps-reel.md` | V2.1 | Prêt à implémenter | #200,#194,#199,#208,#214 |
+| `assistant-v21-phase-3-le-monde.md` | V2.1 | Prêt à implémenter | #195,#196,#197,#198,#207 |
+| `assistant-v21-phase-4-les-gens.md` | V2.1 | Prêt à implémenter | #211,#209,#201 |
+| `assistant-v21-phase-5-extension.md` (160 l.) | V2.1 | Cadre prêt | #210,#212 |
+
+**Fait saillant n°1 — document parent manquant.** Les 5 phases V2.1 s'appuient toutes sur un `ASSISTANT-V2.1.md` (§2 P1–P16, §6.1, §8.2, §9.2/9.3, §10.2, §13.2, §15, §16, §19, §21). **Ce fichier n'existe nulle part dans le dépôt.** Conséquence directe : toutes les références croisées sont pendantes — notamment les schémas exacts des tables `tasks`/`inbox_items`/`facts`/`entities`/`agent_runs`, les règles de politique §15.2, et surtout **les définitions des golden tasks G1→G14** (§16.1) qui sont pourtant le critère d'acceptation central de chaque phase. On ne peut pas implémenter les phases « telles quelles » sans ce parent.
+
+**Fait saillant n°2 — collision d'IDs.** Le Roadmap (v2.63.0) a déjà consommé ces ID :
+
+- `#191` = « Chat — suppression de post, DM, link preview OG » (livré 2.60.0)
+- `#192` = « Chat — boîte auto-agrandissante, accusé ✓✓ » (livré 2.61.0)
+- `#194` = « Dossier personnel par utilisateur » (🔵 **en cours**, fiche `docs/features/user-home-194.md`)
+
+Or V2.1 assigne #191 = purge Ollama, #192 = mémoire socle, #194 = consolidation nocturne. **Ce sont des collisions avec du code déjà publié**, ce qui viole la règle n°1 d'`AGENTS.md` (« ID stable, jamais réutilisé »).
+
+**Fait saillant n°3 — plan non enregistré.** Aucune des 7 docs n'est référencée dans `ROADMAP.md`, dans la cartographie documentaire d'`AGENTS.md`, ni dans `docs/features/`. Le programme entier vit dans une bulle documentaire non branchée sur le processus de livraison.
+
+---
+
+## 2. Résumé de la solution
+
+### Vision (4 piliers)
+Transformer ObsiGate d'un « portail de notes avec assistant » en **second cerveau conversationnel autonome** :
+1. **Il se souvient** — mémoire long terme structurée (faits, préférences, entités, décisions), consolidée la nuit, **auditable en markdown dans le vault** (anti-boîte-noire).
+2. **Il agit** — sur le vault **et** les services externes connectés (Gmail, Google Agenda, Teams, Discord, Notion, Drive…).
+3. **Il anticipe** — rappels conversationnels, briefing quotidien, détection de boucles ouvertes et d'engagements non tenus.
+4. **Il centralise** — ObsiGate devient le point d'entrée unique (desktop Tauri, MCP externe, PWA mobile → *ce même* cerveau).
+
+### Principes directeurs
+- **V2 (P1–P9)** : autonomie du stack (1 conteneur, Ollama retiré) · zéro framework d'agent externe · un outil = un `@tool` typé · mémoire = markdown d'abord · humain dans la boucle · secrets jamais committés · i18n FR/EN · desktop Tauri offline-first · réutilisation de la sécurité existante.
+- **V2.1 (ajout majeur)** : insère **dès la phase 0** deux mécanismes qui rendent tout le reste délégable :
+  - **Moteur de politiques** (#213) — décision **déterministe** `autorisé | approbation_run | approbation_renforcée | refusé` = f(risque × niveau d'autonomie × provenance × sensibilité × réversibilité). **Jamais de LLM dans le chemin d'autorisation.**
+  - **Exécution fiable** (#206) — *« un run est l'unité de tout »* : plans avant écriture, approbation par run, `agent_runs`/`agent_steps`, post-conditions (`verify`), inverses (`inverse`), idempotence, reprise après crash, annulation (undo).
+
+Le delta V2 → V2.1 est significatif et pertinent : la V2 donnait de la mémoire et des connecteurs **sans** le socle de sécurité/exécution. La V2.1 corrige cela en prerequisite. Mais la V2.1 introduit aussi ~2× plus de périmètre.
+
+### Phasage et effort (source : docs)
+
+| Phase | Thème | Tranches | Effort |
+|---|---|---|---|
+| **0** | Socle sûr (purge Ollama, mémoire, miroir, politiques, runs) | #191,#192,#193,#213,#206, amorce #212 | 15–19 j |
+| **1** | Le travail (tâches, Aujourd'hui, planification, capture) | #202,#203,#204,#205 | 14–18 j |
+| **2** | Le temps réel (agent programmé, consolidation, rappels, automations, rituels) | #200,#194,#199,#208,#214 | 14–19 j |
+| **3** | Le monde (connecteurs, sync, client MCP) | #195,#196,#197,#198,#207 | 17–23 j |
+| **4** | Les gens (personnes & engagements, voix, insights) | #211,#209,#201 | 9–13 j |
+| **5** | L'extension (packs A–G + éval continue) | #210,#212 | 3–5 j/chantier + continu |
+
+**Total cœur = ≈ 69–92 jours** de développement, plus l'extension. C'est un **programme de plusieurs mois**, pas une feature.
+
+---
+
+## 3. Les composantes à mettre en place
+
+### 3.1 Backend — nouveaux modules
+
+```mermaid
+graph TD
+    L[agent/loop.py existant] --> P[agent/policies.py]
+    L --> R[agent/runs.py]
+    P --> REG[tools/registry.py étendu verify/inverse]
+    M[memory/ store, entities, recall, compiler, mirror, consolidator] --> T1[tools/memory.py]
+    C[connectors/ base, oauth, registry, sync, ical/caldav/imap, mcp_client] --> T2[tools/connectors.py]
+    A[automations/ bus, engine, detectors] --> T3[tools/reminders.py]
+    K[tasks/ model, store, rrule, planner] --> T4[tools/tasks.py + planner.py]
+    I[inbox/store.py] --> T5[tools/inbox.py]
+    G[people/ + voice/] --> T6[tools/people.py, commitment, voice]
+```
+
+| Module | Rôle |
+|---|---|
+| `backend/memory/{store,entities,recall,compiler,mirror,consolidator}.py` | faits bi-temporels, entités/relations, recall RRF, compileur de contexte, miroir markdown, consolidation nocturne |
+| `backend/agent/policies.py` | moteur de politiques déterministe |
+| `backend/agent/runs.py` | `agent_runs`/`agent_steps`, plans, idempotence, reprise, undo |
+| `backend/connectors/{base,oauth,registry,sync,ical,caldav,imap,mcp_client}.py` | cadre connecteurs OAuth2+PKCE + replis zéro-OAuth + sync incrémentale + client MCP |
+| `backend/tasks/{model,store,rrule,planner}.py` | parseur de tâches markdown, index, RRULE, moteur de planification |
+| `backend/inbox/store.py`, `backend/automations/{bus,engine,detectors}.py` | capture, bus d'événements, automatisations, détecteurs d'insights |
+| `backend/tools/{memory,connectors,reminders,tasks,planner,inbox,people,voice}.py` | outils `@tool` |
+| `backend/routers/{memory,runs,delegations,today,tasks,plans,approvals,inbox,connectors,automations,reminders,commitments}.py` | API REST |
+
+### 3.2 Stores de données (tous dans `data/`, JSON ou SQLite reconstructible)
+
+- `data/memory.sqlite3` — `facts` (bi-temporel : `entity_id, valid_from, valid_to, recorded_at, sensitivity, provenance_trust`, `kind` étendu à `procedure`), `entities`, `relations`, `consolidation_runs`.
+- `data/assistant.sqlite3` — `agent_runs`, `agent_steps`, `delegations`, `approvals`, `inbox_items`, `commitments`, `plans`, `automation_runs`, `event_log`.
+- `data/tasks.sqlite3` — index des tâches (reconstructible).
+- `data/connectors_cache.sqlite3` — `sync_state`, `synced_objects` (extraits bornés, jamais le corps complet).
+- `data/connectors.json` (public) + `data/connector_secrets.json` (0600, chiffré `secret.key`).
+
+### 3.3 Artefacts vault — `99_Assistant/`
+
+`Profil.md` (balises `<!-- obsigate:managed:* -->`, re-parsées en faits `source='user'`), `Insights.md`, `Rappels.md`, `Personnes.md`, `Journal.md`, `Briefings/YYYY-MM-DD.md`, `Plans/YYYY-MM-DD.md`, `Automatisations/*.md`, `Revues/`.
+
+### 3.4 Frontend (vanilla JS, zéro build — contrainte à respecter)
+
+Vue **Aujourd'hui**, **file d'approbations unifiée**, **centre de contrôle** (runs, délégations, budgets, santé des index), page Configurations étendue **« Sources connectées »**, cartes mémoire/pending, panneau cloche rappels, vue Automatisations + dry-run, registre des packs. i18n FR **et** EN obligatoire.
+
+### 3.5 Infra & config
+
+- Retrait Ollama : `docker-compose.yml` + `.test-linux` + `.test-win` (service, volume `ollama_data`, `OLLAMA_BASE_URL/MODEL`, port 11434).
+- Variables : `OBSIGATE_MEMORY_*`, `OBSIGATE_CONSOLIDATION_*`, `OBSIGATE_TZ`, `OBSIGATE_BRIEFING_TIME`, `OBSIGATE_NOTIFY_DAILY_BUDGET`, `GOOGLE_CLIENT_ID/SECRET`, `AZURE_CLIENT_ID/SECRET`, `OBSIGATE_NOTION_API_KEY`, `OBSIGATE_DISCORD_BOT_TOKEN`, `OBSIGATE_RUN_MAX_*`.
+- Pas de nouvelle dépendance lourde nécessaire : `httpx` et `mcp` sont déjà présents.
+
+---
+
+## 4. État réel du code (vérifié, pas déduit)
+
+| Élément cité par les specs | Réalité constatée |
+|---|---|
+| `backend/agent/loop.py` (`run_agent`) | ✅ existe (`DEFAULT_MAX_ITERATIONS=10`, `STOP_*`, propose/apply) |
+| `backend/tools/registry.py` (`@tool`, `ToolRisk`) | ✅ existe — mais **pas de `verify`/`inverse`/`data_classes`** (donc P0-T12 est bien un vrai travail) |
+| `backend/scheduler.py` (actions, schedules) | ✅ existe — actions `create_file`/`append_to_file`/`notify`, schedules `interval_hours`/`daily_time`/`once_at` |
+| `backend/notify.py` (`broadcast`) | ✅ existe |
+| `backend/mcp/server.py` (propose/apply) | ✅ existe |
+| `data/secret.key`, chiffrement, `0600` | ✅ pattern présent (`auth/jwt_handler.py`) |
+| **`backend/memory/`, `backend/connectors/`, `policies.py`, `runs.py`** | ❌ **inexistants** |
+| **`memory.sqlite3`, `assistant.sqlite3`, `agent_runs`** | ❌ **inexistants** |
+| Ollama dans les compose | ✅ **toujours présent** (les 3 files) |
+
+Conclusion : les specs décrivent correctement le socle existant (bon signe), et tout ce qui est « nouveau » est effectivement à construire. Le statut « non implémenté » du doc V2 est exact.
+
+---
+
+## 5. Points forts de la conception
+
+- **Réutilisation maximale de l'existant** : boucle agent, registre `@tool`, MCP, scheduler, notify, Web Push, recherche TF-IDF+sémantique — rien de tout cela n'est refait. La V2.1 branche proprement les nouvelles capacités.
+- **Anti-boîte-noire** : mémoire auditable en markdown, éditions humaines re-parsées comme faits `source='user'` confiance 1.0. C'est la vraie différenciation face à ChatGPT-Memory.
+- **Sécurité pensée tôt** : moteur de politiques déterministe, provenance/taint, whitelist des runs non interactifs, refus des envois externes sans relecture, traitement du contenu externe comme *données* (anti-injection), budgets durs.
+- **Coût maîtrisé** : consolidation déterministe avant LLM, cheap model dédié, budgets tokens, règle « lire le cache pendant que sa sync dort ».
+- **Dégradabilité** : chaque phase fonctionne sans les suivantes (la V2.1 insiste : phase 4 complète sans même un connecteur), connecteurs absents du registre si non installés (offline-first Tauri).
+- **DoD aligné sur le dépôt** : golden tasks, i18n FR/EN, fiches features, CHANGELOG/ROADMAP, ruff/mypy.
+
+---
+
+## 6. Pistes d'amélioration
+
+### 🔴 Bloquantes (à traiter avant d'écrire une ligne de code)
+
+1. **Réécrire/écrire le document parent `ASSISTANT-V2.1.md`.** Sans lui, les schémas `tasks`/`inbox_items`/`facts`/`entities`/`agent_runs`, les règles de politique §15.2 et **les définitions des golden tasks G1→G14** n'existent pas. Options : (a) reconstituer le parent à partir des 5 phases + de la V2, ou (b) fusionner les phases en un document unique auto-suffisant. **Recommandé : (b)**, car maintenir 6 documents cohérents pour ~90 jours de travail va dériver.
+2. **Renuméroter tout le bloc d'IDs.** #191, #192, #194 sont déjà pris (chat, user-home). Proposer un bloc contigu réservé (ex. `#215→#238`) et le figer, puis remapper V2 et V2.1. Décider aussi de la convention unique : les docs mélangent `#NNN` (roadmap) et `P0-Tnn`/`P2-Tnn` (tickets) sans mapping explicite — à trancher et documenter.
+3. **Enregistrer le programme dans le Roadmap et la cartographie documentaire.** Créer les entrées `ROADMAP.md` (statut 🔵/⚪) et les fiches `docs/features/`, ajouter `docs/Assistant-V2/` à la table d'`AGENTS.md`. Aujourd'hui le programme viole la règle « ID stable avant de coder ».
+4. **Décider du sort de la doc V2.** La V2 **contredit** la V2.1 : V2 dit « `gmail.send` non exposé v1 », V2.1 phase 3 l'expose en DANGEROUS. V2 propose une table `facts` sans bi-temporalité/entités que V2.1 remplace. Garder les deux crée un piège pour l'implémenteur. **Recommandé : marquer `ASSISTANT-V2.md` comme « superseded »** et pointer vers la V2.1.
+
+### 🟡 Importantes (qualité d'implémentation)
+
+5. **Trancher le séquençage par valeur, pas par phases.** Les phases sont bien dessinées, mais ~90 j avant le premier bénéfice visible est risqué. **Recommandé : livrer d'abord un « vertical slice » de la seule phase 0** (purge Ollama + mémoire + miroir + runs + politiques) — c'est là que vivent 80 % du risque technique et 100 % des prérequis de sécurité. Ne pas commencer les phases 1–5 avant d'avoir prouvé la phase 0.
+6. **Concurrence SQLite / writer unique.** Les specs ajoutent 4–5 bases manipulées par la boucle agent, le watcher, le scheduler (tick 60 s) et les handlers HTTP, dans **un seul process**. À cadrer explicitement : mode WAL, discipline « un seul écrivain par store », verrous, et reprise. Ce n'est évoqué nulle part et c'est une source classique de corruption.
+7. **Qualité de l'extraction de faits = le composant le plus risqué.** C'est le seul endroit où « le modèle décide ». Recommander : (a) un **dry-run de consolidation** obligatoire avant activation (existe pour automations, à généraliser), (b) validation Pydantic stricte + rejet des valeurs non sourcées, (c) métrique « faits rejetés/acceptés » dès la phase 0, (d) un mode « extracteur désactivé » par défaut la première semaine.
+8. **Fuites multi-utilisateurs via le miroir.** La mémoire est `user_id` par utilisateur, mais le miroir vit dans **un vault** `99_Assistant/`. Si le vault est partagé, `Profil.md`/`Personnes.md` exposent la vie privée d'un user à un autre. À trancher : vault mémoire **par utilisateur** (le plus sûr, cohérent avec `home-<user>`), ou sections par user + ACL. À documenter et tester.
+9. **Chiffrement au repos et `0600` sous Windows.** Le pattern `data/connector_secrets.json` en `0600` est POSIX. `os.chmod` ne pose pas d'ACL sous Windows, alors que le desktop Tauri est multi-OS. Prévoir une stratégie (ACL via `pywin32`, ou DPAPI, ou au minimum documenter la limite). #172 est cité comme dépendance mais pas défini ici.
+10. **Golden tasks non branchées au CI.** `AGENTS.md` impose les 5 jobs CI (`lint/test/security/build/e2e`). Les golden tasks (`tests/golden/`) nécessitent un job dédié + des **simulateurs HTTP par fournisseur** (prévus en phase 3). À cadrer dès la phase 0 (harnais) pour ne pas découvrir le problème en phase 3. La phase 5 **oublie complètement l'E2E** alors qu'elle crée une UI (registre des packs) — non conforme à la DoD du dépôt.
+11. **Friction OAuth.** Créer des apps Google Cloud / Entra ID est le principal frein d'installation. Bonne idée des specs : les **replis zéro-OAuth (iCal/CalDAV/IMAP)**. Recommander d'en faire le **chemin par défaut** et OAuth une option avancée, plutôt que l'inverse — cela dérisque toute la phase 3.
+
+### 🟢 Confort / simplifications
+
+12. **Mutualiser les stores.** `tasks.sqlite3`, `connectors_cache.sqlite3`, `memory.sqlite3` et `assistant.sqlite3` pourraient être **un seul** `assistant.sqlite3` (WAL) : moins de fichiers, moins de cycles de vie, un seul point de backup. Le « reconstructible séparément » se gère par table. À évaluer.
+13. **FTS5 natif** pour l'index des tâches et la recherche mémoire, plutôt qu'un index plein-texte maison — SQLite le fournit déjà.
+14. **Unifier rappel = tâche enrichie** (déjà proposé en V2.1 §7.2) : excellent, à confirmer comme décision figée pour éviter toute tentation de second store.
+15. **Instrumenter les métriques #212 dès la phase 0** (budget de contexte mémoire, faits acceptés/rejetés, temps de décision quotidien). Les specs le promettent ; en faire un vrai tableau de bord tôt évite les optimisations à l'aveugle.
+16. **Formaliser les critères de sortie de chaque phase** (les phases 0–4 en ont, la 5 non) et une **décision unique** sur les « décisions ouvertes » du parent (activation de l'envoi, fournisseur de transcription, gestionnaire de tâches externe) — ces 3 décisions conditionnent plusieurs tickets et ne sont pas tranchées.
+17. **Points ambigus relevés par phase** (à lever dans le parent) : schéma `consolidation_runs` jamais défini (phase 2) ; format de `allowed_extra_tools` et de `ctx: rappel` ; emplacement du réglage `candidats connecteurs` (`off|candidats`) ; modalités MCP (stdio vs HTTP) et algorithme de plafonnement de risque ; dédup multi-calendriers (tolérance fuseaux/récurrences) ; granularité Notion→index ; format de persistance des packs (`data/` ?).
+
+---
+
+## 7. Recommandation de prochaines étapes
+
+1. **Décider du plan de renumérotation** et réserver un bloc d'IDs contigu.
+2. **Consolider la doc** : écrire le parent V2.1 (ou fusionner), marquer la V2 comme superseded, lever les ~15 ambiguïtés ci‑dessus.
+3. **Enregistrer** le programme dans `ROADMAP.md` + `docs/features/` + `AGENTS.md`.
+4. **Commencer par le vertical slice de la phase 0** (purge Ollama + mémoire + miroir + runs + politiques + harnais golden), et **ne pas** démarrer les phases 1–5 avant que la phase 0 soit verte en CI.
+
+---
+
+Souhaites-tu que je rédige :
+- le **document de synthèse consolidé** (parent V2.1 auto-suffisant) à partir des 5 phases et de la V2, ou
+- une **proposition de renumérotation** concrète (mapping `ancien ID → nouveau ID`) prête à coller dans le Roadmap ?
+
+Je peux aussi produire un `docs/features/assistant-v2-index.md` qui sert de plan-maître et référence les 7 documents actuellement orphelins.

docs/Assistant-V2/assistant-v21-phase-0-socle-sur.md

@@ -0,0 +1,278 @@
+# Assistant V2.1 ObsiGate — Phase 0 : Socle sûr (purge, mémoire, politiques, exécution fiable)
+
+| Champ | Valeur |
+|---|---|
+| Phase | **0 sur 5** — fondation de toute la solution |
+| Document parent | `ASSISTANT-V2.1.md` — en particulier §2 (P1–P16), §5, §9, §10, §15, §16, §19 |
+| Version | 1.0 — 9 octobre 2026 |
+| Auteur | Spark, pour Bruno |
+| Statut | Prêt à implémenter |
+| Tranches | **#191** (purge Ollama), **#192** (mémoire socle amendée), **#193** (miroir markdown), **#213** (politiques & taint), **#206** (exécution fiable), amorce de **#212** (harnais golden tasks) |
+| Effort estimé | 15–19 jours (dont 1–2 j d'amorce #212 ; le solde de #212 est continu, phases 1–5) |
+| Prérequis | ObsiGate actuel : boucle agent `backend/agent/loop.py`, registre `backend/tools/registry.py`, scheduler #170, notifications #168, Web Push #67, recherche #70 — tels que décrits dans l'inventaire V2.1 §4 |
+| Dépendances | Aucune (première phase) |
+| Débloque | Phase 1 (tâches et planification s'appuient sur les runs et la mémoire), et toutes les écritures externes ultérieures (#213/#206 sont le prérequis de sécurité des phases 3–4) |
+
+> **Résultat visible à la fin de cette phase.** Le conteneur Ollama a disparu. L'assistant possède une mémoire long terme : il enregistre des faits (avec historique bi-temporel), des entités (personnes, projets, lieux) et des procédures, les montre dans `99_Assistant/Profil.md` — éditable à la main, les éditions étant reprises comme des faits de confiance maximale — et les injecte dans chaque conversation via un compileur de contexte dont chaque section cite son origine. Surtout, **tout ce que l'assistant exécute devient un run persistant** : plan affiché avant les écritures, approbation par run, étapes journalisées avec preuves de post-condition, reprise sans doublon après interruption, annulation quand l'inverse existe. Et un moteur de politiques déterministe décide ce qui est autorisé, approuvé ou refusé — jamais le modèle.
+
+---
+
+## Table des matières
+
+1. [Objectif et principe directeur](#1-objectif-et-principe-directeur)
+2. [Périmètre](#2-périmètre)
+3. [État d'entrée — ce qui existe](#3-état-dentrée--ce-qui-existe)
+4. [Modèle de données](#4-modèle-de-données)
+5. [Tickets de travail](#5-tickets-de-travail)
+6. [API livrée par la phase](#6-api-livrée-par-la-phase)
+7. [Comportements détaillés](#7-comportements-détaillés)
+8. [Tests et golden tasks](#8-tests-et-golden-tasks)
+9. [Critères d'acceptation de la phase](#9-critères-dacceptation-de-la-phase)
+10. [Risques spécifiques et vigilance](#10-risques-spécifiques-et-vigilance)
+11. [Ordre d'exécution](#11-ordre-dexécution)
+12. [Définition de « terminé »](#12-définition-de--terminé-)
+
+---
+
+## 1. Objectif et principe directeur
+
+Le principe : **on ne donne pas plus de pouvoir à l'assistant avant d'avoir rendu son pouvoir actuel sûr, traçable et réversible.** La V2 livrait la mémoire puis les connecteurs ; la V2.1 intercale, dès la phase 0, les deux mécanismes qui rendent toutes les phases suivantes délégables : le **moteur de politiques** (#213 — qui a le droit de faire quoi, avec quelles données, venues d'où) et l'**exécution fiable** (#206 — plan, preuves, reprise, annulation).
+
+Corollaires qui guident chaque ticket :
+
+- **La mémoire est un index du vault, pas un silo.** Faits confirmés → miroir markdown ; la base ne détient en propre que les états de travail (`pending`, historique de runs).
+- **Un run est l'unité de tout.** Conversation, tâche planifiée (phase 2), automatisation (phase 2), MCP : à la fin de la phase, toute exécution d'outils par un agent produit une ligne `agent_runs` et ses `agent_steps`. Les journaux épars d'aujourd'hui convergent là.
+- **La politique est déterministe.** Risque du registre × niveau d'autonomie × provenance × sensibilité × réversibilité → décision. Aucun appel LLM dans le chemin d'autorisation, jamais.
+- **Pas de succès sans preuve.** Un run n'est `succeeded` que si ses post-conditions vérifiables sont vraies (§7.3).
+
+## 2. Périmètre
+
+### 2.1 Inclus
+
+- #191 : retrait du service/volume Ollama des trois compose, défauts provider nettoyés, notes de migration (repris tel quel de la V2 §9).
+- #192 : `backend/memory/` — store SQLite amendé (faits bi-temporels, sensibilité, provenance, procédures), entités et relations, recall et **compileur de contexte** (§9.4 du parent), outils `memory.*`, `entity_resolve`, `procedure_get`, API mémoire, cartes de validation des faits `pending` (forme simple — la file unifiée arrive en phase 1, #203).
+- #193 : `mirror.py`, dossier `99_Assistant/`, `Profil.md` à balises gérées avec re-parse des éditions humaines, `Journal.md` des consolidations, `Personnes.md` en **coquille** (le peuplement riche est en phase 4, #211).
+- #213 : provenance/taint sur tous les contenus entrant dans un contexte ou un run, moteur de politiques `backend/agent/policies.py` évalué avant chaque appel d'outil, règles du §15.2 du parent, journal des refus, tests d'injection.
+- #206 : plans d'exécution, `agent_runs`/`agent_steps` dans `data/assistant.sqlite3`, idempotence et reprise, post-conditions déclarées dans le registre (`verify`), inverses (`inverse`), niveaux d'autonomie 0–3 et délégations bornées datées, API runs + progression SSE.
+- #212 (amorce) : harnais de golden tasks (`tests/golden/`, fixtures de vault, connecteurs simulés) et les scénarios G3, G6, G7 de la phase.
+
+### 2.2 Exclu (phases ultérieures)
+
+- La **consolidation nocturne** (#194) : la phase 0 livre le store, le recall et la création de faits en conversation ; l'extraction automatique nocturne arrive en phase 2, quand `agent_prompt` (#200) existe.
+- La **vue Aujourd'hui**, la file d'approbations unifiée et le centre de contrôle complet (#203, phase 1) : la phase 0 livre les cartes mémoire simples et une liste de runs basique dans les Configurations.
+- Les **tâches** (#202, phase 1) et tout connecteur (#195+, phase 3).
+- La politique « contenu connecteur » est livrée comme **mécanisme** (provenances `connector:<id>` reconnues) ; son premier usage réel est en phase 3.
+
+## 3. État d'entrée — ce qui existe
+
+| Élément | État | Rôle en phase 0 |
+|---|---|---|
+| Boucle agent + tool calling natif | ✅ `backend/agent/loop.py`, `backend/ai_chat.py` | Moteur des runs ; étendu, pas remplacé (P2) |
+| Registre `@tool` (risque/scope/confirmation/audit/rate-limit) | ✅ `backend/tools/registry.py` | Reçoit les champs `verify` et la provenance ; la politique s'y branche |
+| Historique de conversation persistant | ✅ #95, `backend/ai_history.py` | Mémoire épisodique brute (source future de #194) |
+| Recherche TF-IDF + sémantique RRF | ✅ #70 | Recall : fusion faits + recherche |
+| Cache SQLite (patron) | ✅ `backend/tools/webcache.py` | Modèle des stores SQLite de la phase |
+| Audit + redaction des secrets | ✅ `backend/audit.py`, `secret_redactor.py` | Journal des runs et des refus ; args toujours redactés |
+| Providers LLM multi-fournisseurs | ✅ `backend/ai.py` | Routage par type de job : amorce posée (§16.3 du parent), table complète en phases suivantes |
+| Ollama comme conteneur | ✅ présent | **Retiré** par #191 ; le provider `ollama` reste une option de configuration (desktop local) |
+
+## 4. Modèle de données
+
+Repris du parent : `facts` amendée (§9.2 — `entity_id`, `valid_from`, `valid_to`, `recorded_at`, `sensitivity`, `provenance_trust`, `kind` étendu à `procedure`), `entities` et `relations` (§9.3), `consolidation_runs` (créée dès cette phase, alimentée en phase 2), `agent_runs` et `agent_steps` (§10.2), auxquelles s'ajoute la table des délégations :
+
+```sql
+CREATE TABLE delegations (
+  id TEXT PRIMARY KEY, user_id TEXT NOT NULL,
+  domain TEXT NOT NULL,              -- 'vault'|'tasks'|'email'|'calendar'|…
+  level INTEGER NOT NULL,            -- niveau accordé (0–3, §10.4 du parent)
+  scope_json TEXT,                   -- périmètre : chemins, connecteur, budgets
+  granted_at TEXT NOT NULL, review_at TEXT NOT NULL,  -- défaut +90 j
+  status TEXT NOT NULL DEFAULT 'active'  -- active|expired|revoked
+);
+```
+
+Stores : `data/memory.sqlite3` (faits, entités, relations, runs de consolidation) et `data/assistant.sqlite3` (runs, steps, délégations ; recevra `inbox_items`, `commitments`, `approvals` en phases 1 et 4 — le fichier est créé ici, les tables arrivent avec leurs tranches).
+
+Règles transverses : toute table porte `user_id` ; aucun secret ni contenu brut de connecteur dans ces bases ; les args d'étapes sont stockés **redactés** ; les stores sont reconstructibles ou journalisés (jamais de contenu de Bruno irremplaçable hors du vault — P4).
+
+## 5. Tickets de travail
+
+*Convention : chaque ticket est indépendamment testable ; « Fichiers » donne les points d'ancrage d'après la V2.1 — à confirmer contre le code réel au démarrage du ticket.*
+
+### Purge Ollama — #191
+
+**P0-T01 — Retrait du conteneur Ollama.**
+Fichiers : `docker-compose.yml`, `docker-compose.test-linux.yml`, `docker-compose.test-win.yml`, docs d'installation.
+Travail : supprimer service, volume `ollama_data`, variables `OLLAMA_BASE_URL`/`OLLAMA_MODEL` et mentions du port 11434 ; procédure de suppression du volume documentée dans le CHANGELOG.
+Acceptation : `docker compose config` ne connaît plus Ollama ; l'instance démarre et l'agent fonctionne sur deepseek/openrouter/gemini.
+
+**P0-T02 — Défauts provider nettoyés.**
+Fichiers : `backend/ai.py`, `model_capabilities.py`, tests d'isolation.
+Travail : conserver le provider `ollama` comme option explicite (desktop), retirer tout défaut pointant vers le réseau interne ; le mode par défaut de la mémoire fonctionne sans embeddings (TF-IDF + RRF + faits).
+Acceptation : aucun test ni défaut ne référence `http://ollama:11434` ; la recherche sémantique se dégrade proprement sans sentence-transformers.
+
+### Mémoire socle — #192
+
+**P0-T03 — Store mémoire : faits amendés, entités, relations.**
+Fichiers : nouveau `backend/memory/store.py` (patron `webcache.py`), création/ouverture de `data/memory.sqlite3`.
+Travail : DDL du §4 ; CRUD faits avec clôture bi-temporelle (supersede = `valid_to`, jamais d'écrasement) ; planchers de confiance V2 (< 0,7 → `pending`) ; dossiers sensibles configurables → `pending` + `sensitivity='sensitive'` ; renforcement `last_seen_at` et decay par `kind` (les `procedure` et `decision` ne décroissent pas).
+Acceptation : G7 passe (changement de dentiste : ancien fait clos, nouveau actif, requête historique datée correctement répondue) ; aucun fait `sensitive` créé directement en `confirmed`.
+
+**P0-T04 — Entités et résolution de noms.**
+Fichiers : `backend/memory/entities.py`.
+Travail : CRUD entités (person/place/project/org/topic, alias) ; `resolve(name)` → candidates scorées ; **ambiguïté = pas de fusion** (renvoyer les candidates, la décision est une carte, phase 2 pour la consolidation) ; relations bi-temporelles.
+Acceptation : deux « Marie » distinctes coexistent sans fusion ; une relation fermée n'apparaît plus dans le recall actuel mais reste interrogeable à date.
+
+**P0-T05 — Recall et compileur de contexte.**
+Fichiers : `backend/memory/recall.py`, `backend/memory/compiler.py`.
+Travail : score explicite et journalisé (RRF × confiance × fraîcheur × boost entité, parent §9.4) ; assemblage du bloc `<assistant-context>` à budget adaptatif (défaut 2 500 tokens) avec sections profil/procédures, entités du sujet, faits liés, engagements (vide cette phase), dernier briefing (absent cette phase — section omise proprement) ; chaque section cite son origine ; le bloc est visible dans les étapes du panneau avec le détail du score au survol.
+Acceptation : un fait sous le seuil n'entre pas dans le bloc ; le même bloc est reproduit à l'identique pour la même requête et le même état (déterminisme de structure) ; aucun contenu `sensitivity='sensitive'` dans un contexte destiné à un outil externe.
+
+**P0-T06 — Outils mémoire et API.**
+Fichiers : `backend/tools/memory.py`, `backend/routers/memory.py`.
+Travail : les 5 outils V2 (`memory_recall`, `memory_save`, `memory_update`, `memory_forget`, `profile_get`) + `entity_resolve` (READ) et `procedure_get` (READ) ; `memory_save` passe par la politique (approbation selon niveau, défaut 2) ; endpoints CRUD faits (liste/filtre statut, validation `pending`, édition, oubli) et export JSON complet du domaine mémoire.
+Acceptation : un fait proposé en chat apparaît en carte, validé il est au miroir (T08) et au recall suivant ; `memory_forget` le retire du recall et du miroir, avec trace d'audit.
+
+### Miroir markdown — #193
+
+**P0-T07 — Miroir `Profil.md` à balises gérées.**
+Fichiers : `backend/memory/mirror.py`.
+Travail : création de `99_Assistant/` dans le vault mémoire (`OBSIGATE_MEMORY_VAULT`, mode multi-utilisateur du §5.3 du parent) ; rendu des sections gérées (préférences, procédures, objectifs connus) ; hash de section stocké en base ; écritures idempotentes (rendu deux fois = fichier identique).
+Acceptation : supprimer un fait validé régénère le miroir sans toucher au hors-balises ; deux rendus consécutifs produisent un diff vide.
+
+**P0-T08 — Re-parse des éditions humaines.**
+Travail : avant chaque écriture, comparer le hash stocké au contenu courant ; une section modifiée à la main est re-parsée en faits `source='user'`, confiance 1.0, `confirmed`, puis régénérée ; une suppression dans le miroir = fait `rejected` en base ; le hors-balises n'est jamais touché.
+Acceptation : éditer `Profil.md` à la main (ajout + suppression) puis déclencher un rendu donne des faits conformes aux éditions, sans perte du texte libre hors balises.
+
+**P0-T09 — `Personnes.md` (coquille) et `Journal.md`.**
+Travail : `Personnes.md` rendu depuis les entités personnes (nom, type de relation, dernière interaction connue) — en lecture structurée simple cette phase ; `Journal.md` alimenté par les événements mémoire (faits ajoutés/validés/rejetés, rendus du miroir) en lecture seule.
+Acceptation : une entité personne créée en T04 apparaît au miroir ; le journal trace chaque validation de carte.
+
+### Politiques & taint — #213
+
+**P0-T10 — Provenance de bout en bout.**
+Fichiers : `backend/agent/loop.py`, `backend/tools/registry.py`, `backend/ai_chat.py`.
+Travail : chaque contenu entrant dans un contexte ou un résultat d'outil reçoit une provenance (`user`, `vault`, `connector:<id>`, `web`, `mcp:<serveur>`, `automation`) portée dans les messages et les steps ; les résultats d'outils sont sanitisés (redaction existante) et étiquetés avant retour au modèle ; les prompts système distinguent explicitement blocs « instructions » et blocs « données ».
+Acceptation : un test d'intégration montre la provenance présente sur chaque résultat d'outil d'un run ; aucun résultat n'est injecté sans étiquette.
+
+**P0-T11 — Moteur de politiques.**
+Fichiers : nouveau `backend/agent/policies.py` ; branchement dans le registre (évaluation **avant** chaque appel d'outil).
+Travail : décision déterministe `autorisé | approbation_run | approbation_renforcée | refusé` = f(risque registre, niveau d'autonomie du domaine, provenance, sensibilité des données, réversibilité) ; règles du parent §15.2 (une instruction de contenu non-`user` ne crée/lève aucune approbation ; action externe justifiée uniquement par un contenu non-`user` → refus + carte ; données `private|sensitive` interdites vers web/connecteurs en écriture/MCP externe) ; journal des refus avec motif, lisible dans l'audit.
+Acceptation : G3 passe (courriel piégé simulé → refus, carte à Bruno, zéro appel d'envoi) ; la décision est couverte par des tests unitaires exhaustifs sur la matrice des facteurs (aucun LLM dans le chemin).
+
+**P0-T12 — Registre étendu : `verify`, inverses, sensibilité des paramètres.**
+Fichiers : `backend/tools/registry.py`, outils existants (annotations).
+Travail : champs optionnels du décorateur `@tool` : `verify` (post-condition vérifiable), `inverse` (constructeur d'inverse ou `None` explicite), `data_classes` (classes de données acceptées en entrée) ; annoter les outils vault et documents existants ; un outil d'écriture sans `verify` déclaré est listé dans un rapport de couverture (pas bloquant cette phase, bloquant pour les outils externes des phases 3+).
+Acceptation : le rapport de couverture existe et est revu ; `create_file`/`edit_file` déclarent leur post-condition et leur inverse (backup).
+
+### Exécution fiable — #206
+
+**P0-T13 — Stores de runs.**
+Fichiers : `backend/agent/runs.py`, `data/assistant.sqlite3`.
+Travail : DDL `agent_runs`/`agent_steps` du parent §10.2 ; cycle de vie complet des statuts ; écriture des steps au fil de l'exécution par la boucle existante (toute exécution d'outils crée ou rattache un run, `origin` renseignée) ; plafonds : itérations et budget tokens existants + durée murale et nombre d'écritures (`OBSIGATE_RUN_MAX_WALL_SECONDS`, `OBSIGATE_RUN_MAX_WRITES`).
+Acceptation : tuer le processus pendant un run laisse un run `running` orphelin détectable au redémarrage (marqué `paused` reprenable, jamais `succeeded`).
+
+**P0-T14 — Plans d'exécution et approbation par run.**
+Travail : pour toute demande ≥ 2 écritures ou 1 outil DANGEROUS, génération d'un plan (étapes : outil, args résumés, effet attendu, post-condition, inverse) persisté dans `plan_json` ; affichage dans le panneau avant la première écriture ; validation en un clic = approbation du run entier (pas par étape) ; un plan refusé n'exécute rien et le run passe `cancelled` avec motif.
+Acceptation : une demande multi-écritures ne produit aucun effet avant validation ; le plan affiché correspond exactement aux steps exécutés ensuite.
+
+**P0-T15 — Idempotence et reprise.**
+Travail : `idempotency_key` par step d'écriture (hash run+seq+args) respectée par les outils de création (vérification d'existence par clé en métadonnée) ; reprise d'un run interrompu à la première step non `done`, re-vérification des post-conditions incertaines, steps WRITE incertaines → `awaiting_approval` plutôt que rejeu aveugle.
+Acceptation : G6 passe (run tué à mi-parcours, repris : aucun doublon créé, état final vérifié).
+
+**P0-T16 — Vérification et annulation.**
+Travail : exécution des `verify` après chaque step d'écriture ; statut final `succeeded` seulement si toutes les post-conditions vérifiables sont vraies, sinon `partially_succeeded` détaillé ; « Annuler ce run » exécute les inverses sûrs en ordre décroissant comme un run lié ; absence d'inverse affichée comme telle (« non annulable »).
+Acceptation : un outil dont la post-condition échoue (fixture) produit `partially_succeeded`, jamais `succeeded` ; l'annulation d'un run de création de fichiers restaure l'état initial via les backups.
+
+**P0-T17 — Niveaux d'autonomie et délégations.**
+Fichiers : réglages Configurations, `delegations` (§4).
+Travail : niveaux 0–3 par domaine (défauts : vault = 2, tout domaine externe = 0/1 selon existence) ; création de délégation bornée (périmètre + budget + `review_at` +90 j) depuis une approbation (« toujours autoriser ce périmètre ») ou les Configurations ; expiration automatique → retour au niveau inférieur ; **aucun niveau ne couvre** paiements, envois externes sans relecture, suppressions définitives, changements de sécurité (codé en politique, pas en réglage).
+Acceptation : une délégation expirée cesse de s'appliquer sans intervention ; tenter de déléguer un envoi externe est refusé par l'UI et par l'API.
+
+**P0-T18 — API runs et progression.**
+Fichiers : `backend/routers/runs.py`.
+Travail : `GET /api/runs` (filtres statut/origine), `GET /api/runs/{id}` (plan, steps, preuves), actions `pause`/`resume`/`cancel`/`undo` ; progression en SSE sur le flux existant ; liste de runs basique dans les Configurations (le centre de contrôle complet est en phase 1).
+Acceptation : un run en cours est observable en direct ; pause puis reprise depuis l'API aboutit au même résultat qu'une exécution continue.
+
+### Évaluation — amorce #212
+
+**P0-T19 — Harnais golden tasks.**
+Fichiers : `tests/golden/` (fixtures de vault, connecteurs simulés, harnais d'exécution headless).
+Travail : infrastructure de scénarios rejouables en CI (état initial → demande → assertions sur les stores, le vault et les runs) ; livrer G3 (injection), G6 (reprise), G7 (bi-temporalité) ; gabarit documenté pour les phases suivantes (chaque phase ajoute les siens).
+Acceptation : les trois scénarios tournent en CI et échouent si le comportement régresse (démontré par mutation volontaire en développement).
+
+### Finitions
+
+**P0-T20 — i18n, docs, guides.**
+Travail : clés FR/EN pour tout libellé nouveau (`ai.step.*` mémoire/runs/politiques, cartes, réglages d'autonomie) ; fiches `docs/features/` pour #191, #192/#193, #213, #206 ; guide utilisateur « Mémoire et contrôle de l'assistant » ; CHANGELOG + ROADMAP.
+Acceptation : DoD du §12 vérifiée point par point.
+
+## 6. API livrée par la phase
+
+| Route | Rôle | Ticket |
+|---|---|---|
+| `GET/POST/PATCH /api/memory/facts` | CRUD faits, validation des `pending` | P0-T06 |
+| `GET /api/memory/entities` · `/api/memory/export` | Entités ; export du domaine mémoire | P0-T04/T06 |
+| `GET /api/runs` · `GET /api/runs/{id}` | Liste et détail (plan, steps, preuves) | P0-T18 |
+| `POST /api/runs/{id}/pause|resume|cancel|undo` | Pilotage d'un run | P0-T18 |
+| `GET/POST/DELETE /api/delegations` | Délégations bornées par domaine | P0-T17 |
+
+Toutes suivent l'authentification et les permissions par vault existantes ; les nouveaux outils `@tool` sont exposés au MCP automatiquement (scopes IN_APP+MCP, propose/apply déjà gérés).
+
+## 7. Comportements détaillés
+
+### 7.1 Qui peut faire quoi
+
+La mémoire, les runs et les délégations sont **par utilisateur** (`user_id` partout, parent §5.3). Un administrateur ne voit pas la mémoire d'un autre utilisateur ; l'audit montre les refus de politique sans le contenu sensible qui les a motivés.
+
+### 7.2 Fait `pending` : durée de vie
+
+Un fait `pending` reste en carte jusqu'à action (valider/éditer/oublier) — pas d'expiration silencieuse. Au-delà de 30 jours, il est regroupé dans un rappel hebdomadaire unique (pas une notification par fait ; le budget d'interruption P15 s'applique dès cette phase aux cartes).
+
+### 7.3 Post-conditions : la règle du succès
+
+`verify` absent ≠ succès présumé : le step est marqué `verified = NULL` et le run ne peut prétendre qu'à `succeeded` si **aucun** step d'écriture n'est simultanément `done` et non vérifié *alors qu'un `verify` existait*. Le rapport de couverture (P0-T12) rend la dette visible au lieu de la cacher.
+
+### 7.4 Reprise après crash du conteneur
+
+Au démarrage, tout run `running` sans heartbeat récent passe `paused` avec le motif `interrupted` ; la reprise est manuelle (API ou panneau) cette phase — la reprise automatique des runs `origin='scheduled'` arrive avec #200 en phase 2.
+
+## 8. Tests et golden tasks
+
+- Unitaires : store mémoire (clôture bi-temporelle, decay, planchers), résolution d'entités (ambiguïté), moteur de politiques (matrice complète des facteurs), idempotence (rejouer une step ne crée pas de doublon), miroir (idempotence du rendu, re-parse).
+- Intégration : run complet avec plan → approbation → exécution → vérification ; kill en cours de run → reprise ; édition manuelle de `Profil.md` → faits `source='user'`.
+- Golden tasks de la phase : **G3** (injection), **G6** (reprise), **G7** (bi-temporalité) — définitions au parent §16.1.
+- Non-régression : l'assistant actuel (sans mémoire activée) se comporte à l'identique ; `OBSIGATE_MEMORY_ENABLED=false` éteint la phase proprement.
+
+## 9. Critères d'acceptation de la phase
+
+1. Le conteneur Ollama n'existe plus et l'assistant fonctionne sur les providers API.
+2. Un fait dit en conversation, validé par carte, est dans `Profil.md`, au recall de la conversation suivante, et son remplacement ultérieur conserve l'historique interrogeable à date.
+3. Éditer `Profil.md` à la main modifie la mémoire (source `user`, confiance 1.0) ; rien hors balises n'est jamais écrasé.
+4. Un run multi-écritures affiche son plan, n'exécute rien avant approbation, prouve chaque post-condition, et un run tué reprend sans doublon.
+5. Le scénario d'injection G3 est refusé par la politique, journalisé, et présenté à Bruno en carte.
+6. Les golden tasks G3/G6/G7 sont verts en CI.
+
+## 10. Risques spécifiques et vigilance
+
+| Risque | Vigilance |
+|---|---|
+| Le compileur de contexte consomme le budget du modèle en silence | Le bloc est plafonné, son détail est visible (P0-T05) ; la métrique « tokens de contexte mémoire / conversation » est journalisée dès cette phase (alimente #212) |
+| Approbation par run trop grossière (tout ou rien) | Le plan affiche chaque step ; un step peut être **exclu** du plan avant validation (case par step) — l'approbation reste unique, le périmètre est ajustable |
+| Le miroir et une édition collaborative (Yjs) se marchent dessus | Le miroir écrit via le même chemin de sauvegarde que l'éditeur (backup préalable) et compare les hashs avant/après (règle durcie en phase 2 pour la consolidation) |
+| Dérive du périmètre : vouloir les tâches dès la phase 0 | Les tâches sont la phase 1 ; la phase 0 ne livre que les fondations qu'elles consommeront (runs, politique, mémoire) |
+
+## 11. Ordre d'exécution
+
+```
+P0-T01 → T02                       (#191, indépendant, à faire en premier)
+P0-T03 → T04 → T05 → T06           (#192)
+P0-T07 → T08 → T09                 (#193, après T03/T06)
+P0-T10 → T11 → T12                 (#213, T10 tôt : la provenance sert les runs)
+P0-T13 → T14 → T15 → T16 → T17 → T18   (#206, après T11)
+P0-T19 (harnais tôt, scénarios au fil des tickets) → P0-T20 (clôture)
+```
+
+## 12. Définition de « terminé »
+
+DoD V2 §13 (tests unitaires + non-régression, JSDOM si UI, ruff/mypy 0 erreur, i18n FR/EN, CHANGELOG, ROADMAP, fiche par tranche, guide si exposé, CI verte, commit conventionnel référençant l'ID) **plus** les ajouts V2.1 (parent §21) : golden tasks du périmètre vertes ; toute écriture déclare sa post-condition et son inverse ou son absence ; toute source de contenu déclare sa provenance.

docs/Assistant-V2/assistant-v21-phase-1-le-travail.md

@@ -0,0 +1,275 @@
+# Assistant V2.1 ObsiGate — Phase 1 : Le travail (tâches, Aujourd'hui, planification, capture)
+
+| Champ | Valeur |
+|---|---|
+| Phase | **1 sur 5** — le premier jalon « assistant personnel » |
+| Document parent | `ASSISTANT-V2.1.md` — en particulier §6 (tâches), §7 (planification), §8 (capture), §14 (UX) |
+| Version | 1.0 — 9 octobre 2026 |
+| Auteur | Spark, pour Bruno |
+| Statut | Prêt à implémenter |
+| Tranches | **#202** (tâches, projets, objectifs), **#203** (vue Aujourd'hui, file d'approbations unifiée, centre de contrôle), **#204** (moteur de planification), **#205** (capture universelle & Inbox) |
+| Effort estimé | 14–18 jours |
+| Prérequis | Phase 0 terminée : mémoire (#192/#193), politiques (#213), runs persistants et niveaux d'autonomie (#206) |
+| Dépendances | #202 ← #193 ; #203 ← #202, #206 ; #204 ← #202 ; #205 ← #202. **Pas de dépendance à #200** : voir §7.1 pour la résolution explicite |
+| Débloque | Phase 2 (rappels liés aux tâches, revues ritualisées, briefing-plan), phase 4 (engagements rattachés aux tâches et aux personnes) |
+
+> **Résultat visible à la fin de cette phase.** L'assistant planifie et agit sur le vault **sans aucun connecteur**. Les tâches vivent dans les notes (checklists enrichies), indexées et interrogeables ; un projet sans prochaine action se voit. Chaque matin, Bruno peut demander son **plan du jour** : agenda du vault + tâches dues + capacité déclarée → proposition en blocs de temps qui **signale la surcharge au lieu de la cacher**, négociable en conversation. L'écran **Aujourd'hui** montre le plan, les priorités, la file unique de tout ce qui attend sa décision, et l'activité de l'assistant. Et tout ce qui lui passe par la tête se capture en 5 secondes (panneau, mobile, voix) dans une **Inbox** que l'assistant trie en propositions validables.
+
+---
+
+## Table des matières
+
+1. [Objectif et principe directeur](#1-objectif-et-principe-directeur)
+2. [Périmètre](#2-périmètre)
+3. [État d'entrée — ce que la phase 0 a livré](#3-état-dentrée--ce-que-la-phase-0-a-livré)
+4. [Modèle de données](#4-modèle-de-données)
+5. [Tickets de travail](#5-tickets-de-travail)
+6. [API livrée par la phase](#6-api-livrée-par-la-phase)
+7. [Comportements détaillés](#7-comportements-détaillés)
+8. [Tests et golden tasks](#8-tests-et-golden-tasks)
+9. [Critères d'acceptation de la phase](#9-critères-dacceptation-de-la-phase)
+10. [Risques spécifiques et vigilance](#10-risques-spécifiques-et-vigilance)
+11. [Ordre d'exécution](#11-ordre-dexécution)
+12. [Définition de « terminé »](#12-définition-de--terminé-)
+
+---
+
+## 1. Objectif et principe directeur
+
+Le principe : **le travail est un objet, pas un texte (P10).** À la fin de la phase, rien d'important pour Bruno n'existe seulement « dans une conversation » ou « quelque part dans une note » : c'est une tâche datée, un projet avec une prochaine action, ou un item d'inbox en attente de tri.
+
+Corollaires :
+
+- **Markdown d'abord, comme la mémoire.** La tâche vit sur sa ligne, dans la note du projet ; l'index SQLite est reconstructible et tout désaccord se résout en faveur de la note.
+- **Le plan propose, il n'ordonne pas.** Le moteur calcule (déterministe), le modèle rédige et négocie ; la validation est humaine (ou déléguée bornée, phase 0).
+- **La surcharge se dit.** Si les tâches retenues dépassent la capacité, le plan le signale et propose des reports explicites. Un plan irréaliste est un défaut du système.
+- **Une seule file de décisions.** Faits `pending`, plans, triages : tout passe par la même file (#203), pour que « ce que l'assistant attend de moi » tienne en un écran et moins de 5 minutes par jour.
+
+## 2. Périmètre
+
+### 2.1 Inclus
+
+- #202 : syntaxe de tâche (états, attributs `[due::] [pri::] [est::] [ctx::] [energy::] [every::]`), parseur et réécriture de lignes, index `data/tasks.sqlite3` maintenu par le watcher, projets et objectifs par frontmatter, récurrence **RRULE** (sous-ensemble RFC 5545), outils `task.*`/`project.*`/`goal_review`, API tâches.
+- #203 : `GET /api/today` et la vue Aujourd'hui (plan, priorités, file de décisions, inbox, activité) ; file d'approbations unifiée `approvals` (migration des cartes mémoire de la phase 0) ; centre de contrôle v1 (runs, délégations, budgets, reconstruction d'index).
+- #204 : moteur de planification déterministe (scoring explicable, capacité et créneaux protégés tirés du profil), plan du jour en note `Plans/YYYY-MM-DD.md` + objet plan, time blocking dans les trous d'agenda, négociation par `plan_update`, replanification du reste de journée, agrégats de revue (jour/semaine) — le plan automatique du matin est livré comme **tâche intégrée typée** du scheduler (§7.1), la généralisation `agent_prompt` restant en phase 2.
+- #205 : Inbox (store, API, outil `inbox_add`), canaux de capture (panneau ⚡, préfixe `+` au chat, Web Share Target PWA, API/MCP), triage assisté par cartes (tâche/note/rappel/fait candidat/événement/à jeter), file hors-ligne rejouée avec horodatage de capture.
+
+### 2.2 Exclu (phases ultérieures)
+
+- Les **rappels** comme objets livrés à heure dite (#199, phase 2) : le triage peut *proposer* un rappel, sa création effective attend #199 ; en phase 1, la proposition est convertie en tâche due datée (comportement documenté dans l'UI de la carte).
+- Le **briefing** (#200, phase 2) et les **rituels** complets (#214, phase 2) : la phase livre le plan et les données de revue ; leur mise en rituel automatique est en phase 2.
+- Tout **agenda externe** : l'« agenda » de la phase = événements notés dans le vault (notes datées, section Temps du profil) ; l'écriture des blocs dans Google/Outlook arrive en phase 3 avec les connecteurs. Les blocs du plan vivent dans la note du plan.
+- La transcription vocale (#209, phase 4) : la capture voix de la phase utilise la dictée du navigateur quand elle existe, sinon un texte saisi.
+
+## 3. État d'entrée — ce que la phase 0 a livré
+
+| Élément | Usage en phase 1 |
+|---|---|
+| Runs persistants, plans, approbations par run (#206) | Le triage, la génération de plan et ses ajustements sont des runs ; la file d'approbations consomme les demandes d'approbation des runs |
+| Moteur de politiques (#213) | Toute création de tâche/note depuis l'inbox ou un plan passe par la politique (provenance incluse) |
+| Mémoire et compileur de contexte (#192) | Le plan consomme capacité et créneaux protégés depuis le profil ; le compileur reçoit la section « Aujourd'hui » (plan résumé, tâches dues) |
+| Miroir à balises gérées (#193) | Même patron pour `Plans/`, `Taches.md` et les sections gérées des notes projets |
+| Watcher et index du vault | Source des événements de re-parse des tâches |
+
+## 4. Modèle de données
+
+Repris du parent : table `tasks` (§6.1 — id ancré, états, projet/objectif, échéances, priorité, estimation, contexte, énergie, `rrule`, `waiting_on`, source), table `inbox_items` (§8.2). Ajouts de la phase :
+
+```sql
+CREATE TABLE plans (
+  id TEXT PRIMARY KEY, user_id TEXT NOT NULL,
+  date TEXT NOT NULL,                    -- jour local du plan
+  status TEXT NOT NULL DEFAULT 'proposed'  -- proposed|validated|in_progress|closed
+    CHECK (status IN ('proposed','validated','in_progress','closed')),
+  capacity_min INTEGER NOT NULL,         -- capacité retenue pour ce jour
+  blocks_json TEXT,                      -- blocs : tâche/événement, début, fin, source
+  overload_json TEXT,                    -- surcharge calculée + reports proposés
+  note_path TEXT,                        -- 99_Assistant/Plans/YYYY-MM-DD.md
+  created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+);
+CREATE TABLE approvals (
+  id TEXT PRIMARY KEY, user_id TEXT NOT NULL,
+  type TEXT NOT NULL,        -- fait|plan|envoi|action_write|action_dangerous|
+                             -- triage|contradiction|delegation_review
+  run_id TEXT,               -- run demandeur (nullable pour les cartes mémoire)
+  payload_json TEXT NOT NULL,          -- ce qui est à décider, affichable tel quel
+  status TEXT NOT NULL DEFAULT 'pending'  -- pending|approved|rejected|expired
+    CHECK (status IN ('pending','approved','rejected','expired')),
+  created_at TEXT NOT NULL, decided_at TEXT, expires_at TEXT
+);
+CREATE INDEX idx_approvals_pending ON approvals(user_id, status, created_at);
+```
+
+`approvals` vit dans `data/assistant.sqlite3` (créé en phase 0). Une approbation **périmée ne s'exécute jamais** : à l'expiration, le run demandeur est notifié et l'action associée est abandonnée (journalisé).
+
+## 5. Tickets de travail
+
+*Convention : chaque ticket est indépendamment testable ; « Fichiers » donne les points d'ancrage d'après la V2.1 — à confirmer contre le code réel au démarrage du ticket.*
+
+### Tâches & projets — #202
+
+**P1-T01 — Syntaxe et parseur de tâches.**
+Fichiers : nouveau `backend/tasks/model.py`.
+Travail : grammaire des états (`[ ] [/] [x] [-] [!]` + motif « bloqué : » en sous-ligne) et des attributs entre crochets (tous optionnels, ordre libre, texte libre préservé) ; parse d'un fichier markdown → tâches avec position (ligne) ; réécriture d'une ligne à l'identique hors la modification demandée (aucune reformatage parasite) ; ancrage `t-<uuid4>` en commentaire HTML discret **seulement** pour les tâches référencées (rappel, run, plan).
+Acceptation : aller-retour parse → réécriture sans changement = fichier identique au caractère près ; les checklists Obsidian existantes du vault de test sont lues sans perte.
+
+**P1-T02 — Index des tâches et watcher.**
+Fichiers : `backend/tasks/store.py`, `data/tasks.sqlite3`, branchement au watcher existant.
+Travail : DDL du parent §6.1 ; re-parse incrémental par fichier modifié ; reconstruction complète à la demande (bouton centre de contrôle) et au démarrage si l'index est absent/corrompu ; le désaccord se résout en faveur de la note.
+Acceptation : créer/modifier/cocher une tâche dans l'éditeur met l'index à jour en < 2 s ; supprimer l'index et redémarrer le reconstruit à l'identique.
+
+**P1-T03 — Projets et objectifs.**
+Travail : détection par frontmatter (`obsigate: projet|objectif`) ou dossier projets configurable ; état du projet (actif/pause/terminé/archivé), prochaine action = première tâche ouverte liée ; calcul « projet sans prochaine action » exposé à l'index et à l'API (le détecteur d'insight est en phase 4, la donnée est ici) ; objectifs : horizon, mesure, projets liés.
+Acceptation : un projet actif sans tâche ouverte est retourné par `project_status` avec le drapeau `no_next_action = true`.
+
+**P1-T04 — Récurrence RRULE.**
+Fichiers : `backend/tasks/rrule.py` (stdlib + `zoneinfo`, sous-ensemble RFC 5545 : `FREQ`, `INTERVAL`, `BYDAY`, `BYMONTHDAY`, `COUNT`, `UNTIL`).
+Travail : ancrage à l'**heure murale** dans `OBSIGATE_TZ` (jamais un timestamp UTC figé) ; à la complétion d'une occurrence, création de la suivante selon le mode (série/instance) ; dates de fin respectées.
+Acceptation : « tous les mar/jeu pendant 8 semaines » produit exactement 16 occurrences ; le passage à l'heure d'hiver ne décale aucune heure murale (tests sur `America/Toronto`).
+
+**P1-T05 — Outils tâches et API.**
+Fichiers : `backend/tools/tasks.py`, `backend/routers/tasks.py`.
+Travail : `task_list` (filtres today/overdue/project/context/waiting), `task_create` (note cible : note du projet, sinon `99_Assistant/Taches.md`), `task_update`, `task_complete` (avec récurrence T04), `project_status`, `goal_review` ; endpoints REST miroirs + recherche plein texte sur les titres.
+Acceptation : une tâche créée en conversation se retrouve dans la note, dans l'index et dans la réponse de `task_list(filter=today)` si elle est due ce jour.
+
+### Aujourd'hui & approbations — #203
+
+**P1-T06 — Agrégat `GET /api/today`.**
+Fichiers : `backend/routers/today.py`.
+Travail : assemblage lecture seule : plan du jour + capacité restante, 3 priorités, compteurs file de décisions, inbox (nombre, plus ancien), tâches dues/en retard, activité des runs (24 h), alertes (index périmé, run en échec) ; chaque section porte ses liens d'objet ; temps de réponse cible < 300 ms sur le vault de test (agrégats indexés, aucun balayage de fichiers).
+Acceptation : l'agrégat est cohérent avec les endpoints de détail (tests croisés) ; aucune section ne fait échouer les autres (dégradation par section).
+
+**P1-T07 — Vue Aujourd'hui.**
+Fichiers : frontend (SPA), patron de la maquette du parent §14.1.
+Travail : sections plan/priorités/décisions/inbox/activité ; actions sur place (valider un bloc, reporter une tâche, ouvrir la file) sans quitter l'écran ; états vides honnêtes (« pas de plan : en proposer un ») ; responsive et PWA (c'est l'écran d'accueil mobile de l'assistant).
+Acceptation : tests JSDOM sur les sections et les actions ; l'écran reste utilisable avec zéro connecteur, zéro plan et une inbox vide.
+
+**P1-T08 — File d'approbations unifiée.**
+Fichiers : `backend/routers/approvals.py`, migration des cartes mémoire.
+Travail : table `approvals` (§4) ; les cartes `pending` de la phase 0 (faits) sont re-présentées comme des approvals de type `fait` sans perte d'état ; regroupement par run et par lot (dépliable) ; expiration honorée ; historique des décisions dans l'audit ; badge de compteur partagé (Aujourd'hui, panneau, Configurations).
+Acceptation : un fait `pending`, un plan à valider et un lot de triages coexistent dans une seule file triée par ancienneté ; approuver un lot de 12 items crée 12 décisions tracées, pas une.
+
+**P1-T09 — Centre de contrôle v1.**
+Travail : page Configurations « Assistant » : runs (liste/détail/reprise/annulation — déjà en phase 0, ici intégrés), délégations et niveaux par domaine, budgets (tokens, et compteur d'approbations du jour), santé des index (tâches, mémoire) + bouton « reconstruire l'index des tâches », liens vers les miroirs `99_Assistant/`.
+Acceptation : chaque compteur affiché correspond à une métrique journalisée (pas d'affichage décoratif) ; la reconstruction d'index est un run visible.
+
+### Planification — #204
+
+**P1-T10 — Moteur de scoring et capacité.**
+Fichiers : `backend/tasks/planner.py`.
+Travail : entrées déterministes (§7.1 du parent) : événements du vault, tâches dues + en retard, capacité déclarée (réglage + section « Temps » du profil : heures de focus, créneaux protégés), rituels absents cette phase ; scoring explicable (échéance > priorité > âge > lien objectif ; pénalité d'énergie incompatible, règle issue du profil uniquement) ; chaque tâche retenue ou écartée porte sa **raison** affichable.
+Acceptation : à entrées égales, plan proposé identique (déterminisme) ; la raison d'exclusion d'une tâche est consultable et correcte.
+
+**P1-T11 — Génération du plan du jour.**
+Travail : objet `plans` (§4) + note `99_Assistant/Plans/YYYY-MM-DD.md` à balises gérées ; time blocking dans les trous d'agenda (durée estimée, défaut 45 min **marqué estimé**) ; calcul de surcharge : si la somme dépasse la capacité, `overload_json` liste les reports proposés (jamais de compression silencieuse) ; rédaction LLM (1 appel, modèle de routage « planification ») avec citation de la source de chaque ligne.
+Acceptation : G2 passe (journée surchargée → surcharge signalée, reports proposés, aucun bloc inventé) ; la note du plan et l'objet plan restent synchronisés après édition des blocs gérés.
+
+**P1-T12 — Négociation et replanification.**
+Fichiers : `backend/tools/planner.py` (`plan_today`, `plan_propose`, `plan_update`, `plan_review`).
+Travail : ajustements conversationnels (« déplace X à demain », « je n'ai que 2 h ») → réécriture de la proposition, revalidation ; replanification du **reste de journée** uniquement, diff lisible (« X glisse à 15 h 30, Y reporté ») ; seuil d'impact : tout report d'une tâche `pri: haute+` exige validation.
+Acceptation : une replanification ne touche jamais un bloc passé ; le diff affiché correspond exactement aux changements appliqués à la validation.
+
+**P1-T13 — Revues : agrégats jour et semaine.**
+Travail : `plan_review(period)` déterministe sans LLM : fait/pas fait/reporté (avec compteur de reports par tâche — la donnée du détecteur « reportée ≥ 3 fois » de la phase 4), projets sans prochaine action, progrès objectifs ; rédaction de la note de revue de semaine (le rituel automatisé est en phase 2, la fonction est ici, appelable à la demande et par skill `/revue`).
+Acceptation : une tâche reportée 3 fois est comptée 3 fois, avec ses dates ; la revue ne contient aucun chiffre non traçable à l'index.
+
+**P1-T14 — Déclenchement du plan sans #200.**
+Travail : tâche intégrée typée du scheduler existant (`action: plan_propose`, heure configurable, défaut 07:00, politique de rattrapage simple : si l'occurrence du jour manque, proposer à la première ouverture d'Aujourd'hui) ; skill `/planjour` ; **aucune** utilisation d'`agent_prompt` générique (phase 2).
+Acceptation : à 7 h, la proposition du jour existe ; conteneur arrêté à 7 h puis rouvert à 9 h → la proposition est générée à l'ouverture, datée du jour, sans doublon.
+
+### Capture & Inbox — #205
+
+**P1-T15 — Store Inbox et outil d'ajout.**
+Fichiers : `backend/inbox/store.py`, `backend/tools/inbox.py`, `data/assistant.sqlite3`.
+Travail : table `inbox_items` (parent §8.2) ; `inbox_add` (WRITE sans classement — la capture ne décide rien), `inbox_list` ; `POST /api/inbox` authentifié, exposé au MCP ; horodatage de capture conservé séparément de l'horodatage de synchronisation.
+Acceptation : un item ajouté par API, par chat et par MCP a la même forme et le même statut initial `new`.
+
+**P1-T16 — Canaux de capture.**
+Travail : bouton « ⚡ Capture » du panneau (aucun appel LLM) ; préfixe `+` dans le chat général et le chat de fichier ; Web Share Target de la PWA (titre + URL + texte) ; bouton capture de la vue Aujourd'hui mobile ; dictée navigateur si disponible (sinon saisie texte).
+Acceptation : capture mobile de bout en bout en < 5 s (mesuré sur le parcours PWA) ; une capture ne déclenche aucun run LLM (vérifié au journal).
+
+**P1-T17 — Triage assisté.**
+Fichiers : `backend/tools/inbox.py` (`inbox_triage`), prompt de triage (annexe B.1 du parent).
+Travail : proposition typée par item (tâche avec échéance **uniquement si énoncée ou déductible d'une date explicite** — aucune date inventée ; note avec dossier proposé ; rappel → tâche datée cette phase, §2.2 ; fait candidat → pipeline mémoire `pending` ; événement vault ; à jeter) ; présentation en cartes dans la file unifiée (type `triage`), validation/correction/rejet unitaire ou en lot pour les évidents ; application = un run par lot, via la politique (provenance `inbox`).
+Acceptation : G4 passe (compte rendu collé dans l'inbox → tâches datées + proposition d'engagement en cartes, rien créé sans validation) ; un item sans date explicite produit une tâche **sans** échéance.
+
+**P1-T18 — Hors-ligne.**
+Travail : les captures PWA hors-ligne entrent dans la file IndexedDB existante avec leur horodatage d'origine et sont rejouées à la reconnexion ; la résolution des dates relatives (« demain ») se fait à la date de **capture** ; sur Tauri hors-ligne, même file locale ; le triage différé (serveur injoignable) ne perd ni ne duplique aucun item.
+Acceptation : capture hors-ligne puis reconnexion = un seul item, daté de la capture ; rejouer deux fois la file ne crée aucun doublon (clé d'idempotence par item).
+
+### Finitions
+
+**P1-T19 — Skills et surfaces conversationnelles.**
+Travail : skills `/planjour`, `/revue`, `/trier`, `/taches` ; section « Aujourd'hui » du compileur de contexte (plan résumé + tâches dues, budget borné) ; libellés `ai.step.*` pour les outils tâches/plan/inbox.
+Acceptation : « qu'est-ce que j'ai aujourd'hui ? » en conversation répond depuis l'agrégat Aujourd'hui, sources citées, sans accès fichier direct.
+
+**P1-T20 — i18n, docs, guides.**
+Travail : clés FR/EN (vue Aujourd'hui, cartes, plans, inbox) ; fiches `docs/features/` pour #202–#205 ; guide utilisateur « Tâches, plan du jour et capture » ; CHANGELOG + ROADMAP.
+Acceptation : DoD du §12 vérifiée point par point.
+
+## 6. API livrée par la phase
+
+| Route | Rôle | Ticket |
+|---|---|---|
+| `GET /api/today` | Agrégat de la vue Aujourd'hui | P1-T06 |
+| `GET/POST/PATCH /api/tasks` · `/api/tasks/{id}/complete` | CRUD et complétion des tâches (miroir des outils) | P1-T05 |
+| `GET /api/projects` · `GET /api/projects/{id}/status` | Projets et leur état calculé | P1-T03/T05 |
+| `GET /api/plans/{date}` · `POST /api/plans/{date}/propose|update|validate` | Plan du jour | P1-T11/T12 |
+| `GET /api/approvals` · `POST /api/approvals/{id}/decide` · `POST /api/approvals/decide-batch` | File de décisions unifiée | P1-T08 |
+| `GET/POST /api/inbox` · `POST /api/inbox/{id}/triage` | Capture et triage | P1-T15/T17 |
+
+## 7. Comportements détaillés
+
+### 7.1 Dépendance #204 → #200 : résolution
+
+Le tableau des tranches du parent donnait #204 dépendant de #200 (`agent_prompt`), alors que l'ordre des phases place #200 en phase 2. **Résolution adoptée dans les documents de phase** : le plan du matin n'a pas besoin d'un prompt libre — c'est une fonction typée. La phase 1 le livre comme tâche intégrée du scheduler (P1-T14) ; la phase 2 généralise (#200 : `agent_prompt` arbitraire, briefing comme amorce rédactionnelle du plan) sans changer le comportement du plan. Le parent est corrigé en conséquence (§19.2 : dépendance de #204 = #202, #193).
+
+### 7.2 Tâche ou rappel ?
+
+En phase 1, il n'existe qu'un objet daté : la tâche. La carte de triage qui propose « rappel » crée une tâche due avec `ctx: rappel` ; en phase 2, #199 rattache la livraison (push/canaux, snooze, escalade) à ces mêmes tâches — aucune migration d'objets, un enrichissement de comportement.
+
+### 7.3 Édition concurrente d'une ligne de tâche
+
+Si la ligne d'une tâche a changé dans la note entre la lecture et la réécriture demandée par un outil (édition humaine entre-temps), l'outil refuse avec un conflit lisible et relit l'état courant — jamais d'écrasement. Le backup automatique existant couvre les écritures.
+
+### 7.4 Capacité et créneaux protégés
+
+La capacité vient d'abord du réglage, puis de la section « Temps » de `Profil.md` si Bruno l'édite (source `user`, prioritaire). Le moteur n'infère **jamais** une capacité depuis l'historique sans la proposer en carte (ce serait une procédure — phase 2 via la consolidation, validation humaine).
+
+## 8. Tests et golden tasks
+
+- Unitaires : parseur (aller-retour sans perte), RRULE (16 occurrences, heure d'hiver), scoring (déterminisme, raisons), surcharge (aucune compression), approvals (expiration, lots).
+- Intégration : tâche créée par 3 surfaces → même objet ; plan généré → négocié → validé → revu ; capture hors-ligne → synchro → triage.
+- Golden tasks de la phase : **G2** (surcharge), **G4** (triage d'un compte rendu) — définitions au parent §16.1 ; plus deux scénarios locaux : « tâche créée en chat visible aux 3 surfaces » et « plan du matin après redémarrage » (P1-T14).
+
+## 9. Critères d'acceptation de la phase
+
+1. Une tâche créée en conversation, dans l'éditeur ou par triage d'inbox est le **même objet** dans la note, l'index et Aujourd'hui.
+2. Le plan d'une journée surchargée signale la surcharge et propose des reports ; aucun bloc n'est inventé et aucune tâche n'est compressée en silence.
+3. La file de décisions contient faits, plans et triages ; le temps de décision quotidien est mesuré et affiché au centre de contrôle.
+4. Une capture mobile prend moins de 5 secondes ; une capture hors-ligne n'est ni perdue ni dupliquée.
+5. Aucun connecteur n'est requis pour l'ensemble de la phase.
+
+## 10. Risques spécifiques et vigilance
+
+| Risque | Vigilance |
+|---|---|
+| Friction de la syntaxe d'attributs dans les notes | Tous les attributs sont optionnels ; une checklist ordinaire reste une tâche valide (échéance absente = jamais proposée comme « due ») |
+| L'index et les notes divergent (édition externe, Syncthing) | Reconstruction complète toujours disponible ; les conflits de ligne sont des refus lisibles (§7.3), pas des écrasements |
+| Le plan du jour est ignoré s'il arrive trop tard | Proposition à 7 h **et** à la première ouverture d'Aujourd'hui ; la métrique « plans validés/modifiés/ignorés » est suivie dès cette phase (#212) |
+| La file de décisions devient un deuxième travail | Lots, expiration, et métrique du temps de décision : au-delà de 5 min/jour en moyenne, c'est un signal de défaut à traiter (parent §20) |
+
+## 11. Ordre d'exécution
+
+```
+P1-T01 → T02 → T03 → T04 → T05        (#202 — T04 peut paralléliser après T01)
+P1-T06 → T07 ; P1-T08 ; P1-T09        (#203 — T08 après T05, T06 après T11 pour le plan réel,
+                                        mais livrable avant avec section plan vide honnête)
+P1-T10 → T11 → T12 → T13 → T14        (#204)
+P1-T15 → T16 → T17 → T18              (#205)
+P1-T19 → T20                          (finitions)
+```
+
+## 12. Définition de « terminé »
+
+DoD du document de phase 0 §12, inchangée, plus : les golden tasks G2 et G4 vertes en CI ; la reconstruction d'index démontre l'égalité index ↔ notes sur le vault de test.

docs/Assistant-V2/assistant-v21-phase-2-temps-reel.md

@@ -0,0 +1,254 @@
+# Assistant V2.1 ObsiGate — Phase 2 : Le temps réel (agent programmé, consolidation, rappels, automatisations, rituels)
+
+| Champ | Valeur |
+|---|---|
+| Phase | **2 sur 5** — l'assistant devient proactif, dans un budget |
+| Document parent | `ASSISTANT-V2.1.md` — en particulier §9.5–9.6 (consolidation), §12 (automatisations), §13.3 (rituels), §14.4 (budget d'interruption) |
+| Version | 1.0 — 9 octobre 2026 |
+| Auteur | Spark, pour Bruno |
+| Statut | Prêt à implémenter |
+| Tranches | **#200** (agent programmé + briefing), **#194** (consolidation nocturne), **#199** (rappels), **#208** (automatisations événementielles & recettes), **#214** (rituels & habitudes) |
+| Effort estimé | 14–19 jours |
+| Prérequis | Phase 0 (runs #206, politiques #213, mémoire #192/#193) et phase 1 (tâches #202, plan #204, inbox #205, file d'approbations #203) terminées |
+| Dépendances | #200 ← #192, #206 ; #194 ← #200, #193 ; #199 ← #200, #202 ; #208 ← #206, #202 ; #214 ← #204, #208 |
+| Débloque | Phase 3 (les automatisations et le briefing consommeront les événements connecteurs), phase 4 (la proactivité #201 s'appuie sur les détecteurs et le budget livrés ici) |
+
+> **Résultat visible à la fin de cette phase.** L'assistant travaille **quand Bruno n'est pas là** — de façon bornée, journalisée et révocable. Le scheduler sait lancer l'agent (`agent_prompt` à whitelist) : le briefing du matin devient l'amorce rédigée du plan du jour. Chaque nuit, la consolidation extrait faits, entités et contradictions des conversations et des notes, en cartes validables, sous budget de tokens. Les rappels sont de vrais objets livrés à heure dite (push, canaux, escalade, snooze compté) et peuvent être **contextuels** (« quand j'ouvre le projet X »). Les automatisations réagissent aux événements du vault et des tâches, avec dry-run et circuit-breaker. Et les rituels — matin, soir, semaine — tiennent la boucle : rien ne glisse en silence d'un jour à l'autre.
+
+---
+
+## Table des matières
+
+1. [Objectif et principe directeur](#1-objectif-et-principe-directeur)
+2. [Périmètre](#2-périmètre)
+3. [État d'entrée](#3-état-dentrée)
+4. [Modèle de données](#4-modèle-de-données)
+5. [Tickets de travail](#5-tickets-de-travail)
+6. [API livrée par la phase](#6-api-livrée-par-la-phase)
+7. [Comportements détaillés](#7-comportements-détaillés)
+8. [Tests et golden tasks](#8-tests-et-golden-tasks)
+9. [Critères d'acceptation de la phase](#9-critères-dacceptation-de-la-phase)
+10. [Risques spécifiques et vigilance](#10-risques-spécifiques-et-vigilance)
+11. [Ordre d'exécution](#11-ordre-dexécution)
+12. [Définition de « terminé »](#12-définition-de--terminé-)
+
+---
+
+## 1. Objectif et principe directeur
+
+Le principe : **l'autonomie se prouve en journal, pas en promesse.** Tout ce que la phase ajoute d'automatique — un run planifié, une consolidation, une automatisation — est un run ordinaire de la phase 0 : visible, plafonné, reprenable, annulable, et soumis au moteur de politiques et au **budget d'interruption** (P15).
+
+Corollaires :
+
+- **Pas de magie par défaut.** Chaque tâche planifiée et chaque automatisation est créée par Bruno ou proposée en carte puis validée ; l'installation ne crée que le briefing-plan (désactivable) et la consolidation (désactivable).
+- **Les actions primitives d'abord.** Une automatisation qui peut s'exprimer sans LLM (créer une tâche, notifier, classer) ne doit pas appeler de LLM : c'est plus fiable, gratuit et auditable.
+- **L'échec est un état, pas un silence.** Échec de run planifié = journal + notification de synthèse au briefing suivant ; échecs répétés d'une automatisation = suspension + insight, jamais une boucle d'erreurs.
+
+## 2. Périmètre
+
+### 2.1 Inclus
+
+- #200 : action scheduler `agent_prompt` (whitelist de capacités V2 renforcée : READ libre ; WRITE restreint aux chemins déclarés, défaut `99_Assistant/**` ; DANGEROUS et écritures connecteurs interdits ; `allowed_extra_tools` explicite), plafonds (8 itérations par défaut, budget tokens par tâche), runs `origin='scheduled'` unifiés au modèle de la phase 0 (reprise des runs planifiés interrompus), briefing du matin comme amorce rédactionnelle du plan (skill `/brief`), tâches intégrées déclarées dans l'UI avec leurs capacités.
+- #194 : consolidation nocturne complète (parent §9.5) : collecte incrémentale (sessions, notes, tâches clôturées, revues), extraction LLM sous budget dur, résolution d'entités, contradictions explicites vers la file d'approbations, candidats connecteurs en réglage `off|candidats` (mécanisme livré ; les sources arrivent en phase 3), journal dans `Journal.md`.
+- #199 : action scheduler `reminder` et livraison multi-canal (Web Push + `notify.broadcast` existant), outils `reminder_*`, RRULE (moteur de la phase 1), rattachement aux tâches (une tâche due peut être livrée comme rappel — §7.2 du document phase 1), snooze compté, escalade optionnelle, section Rappels d'Aujourd'hui.
+- #208 : bus d'événements interne (vault, tâches, inbox, runs, horloge, webhooks entrants), moteur d'automatisations (note markdown à frontmatter structuré : déclencheur → conditions → actions primitives ou `agent_prompt` borné), gardes (`frequence_max` obligatoire, dédup par clé d'événement, profondeur d'enchaînement ≤ 2, circuit-breaker à 3 échecs), dry-run sur événements passés, scheduler amendé (cron complet, politique de rattrapage `misfire`, idempotence par occurrence), activation des **rappels contextuels** de #199 sur le bus, catalogue initial de recettes (annexe D du parent) en modèles.
+- #214 : rituels livrés comme recettes assemblées sur l'existant (briefing/plan du matin, revue du soir à reports explicites, revue de semaine, inbox zéro) ; habitudes = tâches récurrentes rattachées à un objectif avec compteur de série ; série cassée → au plus un insight hebdomadaire.
+
+### 2.2 Exclu (phases ultérieures)
+
+- Les événements `connector.*` : le bus les **déclare** dès cette phase (schéma d'événement), le moteur de sync qui les émet est en phase 3. Aucune automatisation livrée ne dépend d'un connecteur.
+- Les détecteurs d'insights complets (#201, phase 4) : la phase livre les **données** (snooze compté, reports comptés, séries) et le canal `Insights.md` ; les détecteurs métier sont en phase 4.
+- Les engagements (#211, phase 4) : la consolidation peut déjà émettre des faits `open_loop` (V2) ; leur promotion en objets suivis est en phase 4.
+
+## 3. État d'entrée
+
+| Élément | Usage en phase 2 |
+|---|---|
+| Scheduler #170 (`interval_hours`/`daily_time`/`once_at`, actions primitives) | Socle étendu, jamais remplacé ; les tâches existantes des utilisateurs continuent de fonctionner |
+| Runs et politiques (phase 0) | Tout travail automatique est un run sous politique ; les plafonds par tâche s'ajoutent aux plafonds par run |
+| Tâches RRULE, plan, revues (phase 1) | Les rappels s'appuient sur l'index des tâches ; le briefing-plan consomme le plan ; les rituels appellent `plan_review` |
+| File d'approbations (phase 1) | Contradictions de consolidation, propositions d'automatisations et faits `pending` y convergent |
+| Notifications #168 + Web Push #67 | Bras de livraison des rappels et des alertes, sous budget d'interruption |
+
+## 4. Modèle de données
+
+Pas de nouvelle base : extensions de `data/assistant.sqlite3` et du fichier des tâches planifiées existant.
+
+```sql
+CREATE TABLE automation_runs (          -- journal d'exécution des automatisations
+  id TEXT PRIMARY KEY, automation_id TEXT NOT NULL,  -- note d'automatisation
+  event_key TEXT NOT NULL,              -- clé de déduplication de l'événement
+  run_id TEXT,                          -- run phase 0 associé (si agent_prompt)
+  outcome TEXT NOT NULL,                -- fired|skipped_freq|skipped_cond|failed|dry_run
+  created_at TEXT NOT NULL
+);
+CREATE UNIQUE INDEX idx_autorun_event ON automation_runs(automation_id, event_key);
+CREATE TABLE event_log (                -- journal échantillonné du bus
+  id TEXT PRIMARY KEY, type TEXT NOT NULL, payload_summary TEXT,
+  created_at TEXT NOT NULL
+);
+```
+
+Les automatisations elles-mêmes sont des **notes** (`99_Assistant/Automatisations/<nom>.md`, frontmatter du parent §12.2) : pas de table de définition, un index en mémoire reconstruit par le watcher, comme les tâches. Les compteurs du circuit-breaker vivent en base (état, pas contenu).
+
+Amendement du scheduler : chaque tâche planifiée gagne `cron_expr` (optionnel), `misfire` (`skip|run_once|run_all`, défaut `run_once` pour les tâches `agent_prompt` et `reminder`, `skip` sinon) et `idempotency_scope` (tâche + occurrence) ; l'ancien format reste lisible (migration douce au chargement, réécriture au premier enregistrement).
+
+## 5. Tickets de travail
+
+*Convention : chaque ticket est indépendamment testable ; « Fichiers » donne les points d'ancrage d'après la V2.1 — à confirmer contre le code réel au démarrage du ticket.*
+
+### Agent programmé & briefing — #200
+
+**P2-T01 — Action `agent_prompt` dans le scheduler.**
+Fichiers : `backend/scheduler.py`, `backend/tools/scheduled.py`.
+Travail : nouveau type d'action lançant `run_agent` avec un prompt, une whitelist de capacités (défaut du parent §12.2 : READ libre, WRITE `99_Assistant/**`, DANGEROUS et écritures externes interdits, `allowed_extra_tools` explicite par tâche), plafonds propres (itérations, tokens) ; la tâche déclare ses capacités dans l'UI des tâches planifiées (liste lisible, pas du JSON brut).
+Acceptation : une tâche `agent_prompt` tentant d'écrire hors de son périmètre échoue proprement, l'échec est journalisé et visible ; aucune tâche existante (#170) n'est affectée.
+
+**P2-T02 — Unification aux runs et reprise.**
+Travail : chaque exécution planifiée crée un `agent_runs` (`origin='scheduled'`, `origin_ref` = tâche) ; un run planifié interrompu par redémarrage est repris selon les règles de la phase 0 (steps WRITE incertaines → approbation) ou marqué échoué avec motif, selon sa politique de rattrapage ; `last_run_at`/`last_error` persistés et broadcast `schedule_failure` existant conservé.
+Acceptation : tuer le conteneur pendant le briefing puis le relancer donne un run unique, repris ou échoué explicitement — jamais un briefing en double ni un silence.
+
+**P2-T03 — Briefing-plan du matin.**
+Travail : la tâche intégrée de génération de plan (phase 1, P1-T14) est rebranchée : le plan déterministe reste produit par le moteur #204 ; #200 ajoute l'**amorce rédactionnelle** (skill `/brief` : synthèse du plan, faits `pending` du jour, points d'attention) écrite dans `Briefings/YYYY-MM-DD.md` et notifiée selon les canaux et le budget ; en cas d'agenda externe absent, le briefing le dit (données du vault uniquement).
+Acceptation : à l'heure configurée, `Briefings/` contient la note du jour citant ses sources ; `/brief` régénère à la demande sans dupliquer le plan.
+
+### Consolidation nocturne — #194
+
+**P2-T04 — Collecte incrémentale.**
+Fichiers : `backend/memory/consolidator.py`.
+Travail : sessions créées/modifiées depuis le dernier run + notes modifiées (index/watcher, plafonds 200 fichiers × 30 Ko) + tâches clôturées et revues de la période ; `redact_file_content()` systématique avant tout envoi LLM ; watermark persisté dans `consolidation_runs` (un run interrompu reprend sa fenêtre, pas plus).
+Acceptation : un second run sans nouveauté consomme zéro token LLM ; le watermark avance seulement sur succès de l'étape d'écriture.
+
+**P2-T05 — Extraction et réconciliation.**
+Travail : prompt d'extraction du parent (annexe B amendée : `procedure`, entité principale, marqueur `contradiction`) ; validation Pydantic stricte de la sortie (rejet des faits non sourcés) ; étape déterministe de résolution d'entités (liaison ou proposition) ; réconciliation : supersede bi-temporel, contradictions avec `decision`/`procedure` → carte `contradiction` dans la file unifiée (jamais de supersede automatique), dossiers sensibles → `pending`.
+Acceptation : G5 passe (un secret présent dans les notes n'est jamais extrait ; un fait santé est en `pending`) ; une contradiction produit une carte avec les deux sources citées.
+
+**P2-T06 — Écriture, cartes et budget.**
+Travail : écriture des faits + miroir avec protection de course (hash comparé avant **et après** l'appel LLM ; section éditée entre-temps = écriture abandonnée pour cette section, replanifiée) ; faits `pending` → file d'approbations ; budget dur `OBSIGATE_CONSOLIDATION_MAX_TOKENS` (arrêt propre, watermark partiel journalisé) ; compte rendu dans `Journal.md` ; réglage candidats connecteurs (§9.6 du parent) présent, défaut `off`, sans source cette phase.
+Acceptation : une nuit de test sur le vault fixture produit ≥ 1 fait utile et respecte le budget ; éditer `Profil.md` pendant le run ne perd ni l'édition ni le fait.
+
+**P2-T07 — Déclenchement.**
+Travail : tâche intégrée `daily_time 23:30` (configurable, `OBSIGATE_TZ`) via #200 (whitelist `memory.*`) ; skill `/consolider` à la demande ; le run apparaît dans le centre de contrôle avec ses compteurs (faits ajoutés/validés/rejetés — métriques #212).
+Acceptation : la consolidation est visible, désactivable, et son coût de la nuit est affiché le lendemain dans Aujourd'hui (activité de l'assistant).
+
+### Rappels — #199
+
+**P2-T08 — Action `reminder` et outils.**
+Fichiers : `backend/tools/reminders.py`, scheduler.
+Travail : action typée `{user_id, text, deliver:[channels], rrule?}` ; outils `reminder_create` (dates relatives résolues côté serveur et **confirmées dans la carte** — « dans 3 semaines » affiche la date absolue avant création), `reminder_list`, `reminder_snooze` (compteur persisté), `reminder_cancel` ; les rappels sont des tâches de l'index phase 1 vues par le scheduler de livraison (§7.2).
+Acceptation : G1 passe (« rappelle-moi d'appeler le dentiste dans 3 semaines » → livraison à la bonne date, heure murale, fuseau Toronto).
+
+**P2-T09 — Livraison, escalade, section Rappels.**
+Travail : à l'échéance : Web Push + `notify.broadcast` sur les canaux choisis + trace dans l'historique de `Rappels.md` (vue générée) ; acquittement (depuis la notification, Aujourd'hui ou en conversation) ; escalade optionnelle des rappels `critique` (canal externe si non acquitté après N minutes) ; les rappels dus entrent dans le compileur de contexte (section Aujourd'hui) ; snooze ≥ 3 sur le même rappel = donnée exposée aux insights (phase 4), pas de notification supplémentaire.
+Acceptation : un rappel non acquitté critique escalade une fois, puis s'arrête ; un rappel ordinaire n'émet qu'une livraison par occurrence (idempotence du scheduler amendé, P2-T13).
+
+### Automatisations événementielles — #208
+
+**P2-T10 — Bus d'événements.**
+Fichiers : `backend/automations/bus.py`.
+Travail : émission depuis le watcher (`vault.file.*`), l'index des tâches (`task.created|completed|overdue`), l'inbox, les runs (`run.finished`), l'horloge (`schedule.tick`), les webhooks entrants existants ; schéma `connector.object.*` déclaré (aucun émetteur cette phase) ; journal échantillonné `event_log` ; bus en mémoire, aucun broker externe (P1).
+Acceptation : chaque type d'événement déclaré a au moins un test d'émission ; un abonné lent ne bloque pas l'émetteur (file bornée, perte journalisée).
+
+**P2-T11 — Moteur d'automatisations.**
+Fichiers : `backend/automations/engine.py`.
+Travail : chargement des notes `Automatisations/*.md` (frontmatter validé, erreurs de schéma = automatisation désactivée + carte explicative, jamais de crash) ; évaluation déclencheur → conditions déterministes → actions : primitives (`task_create`, `reminder_create`, `create_file`/`append_to_file` dans le périmètre, `notify`, classement inbox) ou `agent_prompt` (via #200, whitelist propre à l'automatisation) ; chaque exécution est journalisée (`automation_runs`) et, si LLM, un run phase 0.
+Acceptation : l'exemple du parent §12.2 (forme sans connecteur : « note modifiée dans Projets/ → tâche de relecture ») fonctionne de bout en bout ; une automatisation mal formée est signalée, pas silencieusement ignorée.
+
+**P2-T12 — Gardes : fréquence, dédup, circuit-breaker, dry-run.**
+Travail : `frequence_max` obligatoire (refus d'activation sans elle) ; dédup par clé d'événement (index unique §4) ; profondeur d'enchaînement ≤ 2 (`automation → run → automation` au-delà = refus journalisé) ; 3 échecs consécutifs → suspension + insight dans `Insights.md` ; **dry-run** : rejouer les événements des 7 derniers jours et afficher ce qui *aurait* été fait, sans aucun effet.
+Acceptation : G8 passe (déclencheur répété 5 fois le même jour avec `frequence_max: 1/jour` → 1 exécution, 4 ignorées journalisées) ; le dry-run ne crée ni tâche ni notification (vérifié aux stores).
+
+**P2-T13 — Scheduler amendé.**
+Travail : expressions cron complètes en plus des modes existants ; politique `misfire` (§4) ; idempotence par (tâche, occurrence) ; file des échecs avec rejeu manuel depuis les Configurations ; ancrage heure murale `zoneinfo` pour les horaires quotidiens.
+Acceptation : une occurrence ratée pendant un arrêt du conteneur suit sa politique au redémarrage (test par horloge simulée) ; aucune occurrence n'est livrée deux fois.
+
+**P2-T14 — Rappels contextuels et recettes initiales.**
+Travail : déclencheurs d'ouverture (note/projet ouvert → rappels `ctx` correspondants proposés dans le panneau, pas de push) rattachés au bus ; publication des recettes de l'annexe D du parent livrables sans connecteur (briefing-plan, revues, veille de page par `fetch_url` + diff, anniversaires depuis les entités connues, entretien récurrent) comme modèles d'automatisations/skills pré-remplis, activables un par un.
+Acceptation : la recette « veille de page » détecte un changement et produit une note + un item d'activité, sans notification hors budget.
+
+### Rituels & habitudes — #214
+
+**P2-T15 — Rituels assemblés.**
+Travail : les rituels sont des recettes (pas un moteur nouveau) : matin = briefing-plan (P2-T03) ; soir = revue du jour (`plan_review`) avec **reports explicites** des tâches non faites (nouvelle date choisie ou retour au projet — l'assistant propose, Bruno tranche en un écran) ; semaine = revue de semaine (phase 1) + focus proposés (3 projets max) ; inbox zéro = triage en lot en fin de journée ; chaque rituel est activable/désactivable séparément, à heure configurable.
+Acceptation : une tâche non faite trois soirs de suite n'a jamais glissé silencieusement : chaque report est daté et motivé dans l'historique de la tâche.
+
+**P2-T16 — Habitudes et séries.**
+Travail : une habitude = tâche récurrente RRULE liée à un objectif (phase 1) ; série calculée par l'index (occurrences faites / attendues, fenêtre glissante) ; affichage dans la revue de semaine et la note de l'objectif ; série cassée → au plus **un** insight hebdomadaire regroupé (P15), jamais de rappel quotidien de culpabilisation.
+Acceptation : la série d'une habitude « 3×/semaine » est calculée correctement sur 4 semaines de fixture, semaines incomplètes (en cours) exclues du jugement.
+
+### Finitions
+
+**P2-T17 — Budget d'interruption : mécanique.**
+Travail : compteur quotidien des notifications sortantes de l'assistant (briefing = 1 ; alertes jusqu'à `OBSIGATE_NOTIFY_DAILY_BUDGET`, défaut 3 ; rappels demandés par Bruno hors budget ; `critique` peut dépasser, 1/jour max) ; sévérités `critique|normale|info` (l'info attend la revue du soir) ; chaque notification porte son pourquoi et le lien de l'objet ; compteur visible au centre de contrôle. Les **détecteurs** qui consommeront ce budget sont en phase 4 (#201) ; la mécanique s'applique dès cette phase aux rappels et aux échecs de runs planifiés.
+Acceptation : un scénario générant 6 alertes normales en un jour en livre 3 et range les autres dans la revue du soir (vérifié au journal).
+
+**P2-T18 — i18n, docs, guides.**
+Travail : clés FR/EN (tâches planifiées et leurs capacités, automatisations, rappels, rituels) ; fiches `docs/features/` pour #200, #194, #199, #208, #214 ; guide « Automatisations et rituels » + pas-à-pas de création d'une automatisation ; CHANGELOG + ROADMAP.
+Acceptation : DoD du §12 vérifiée point par point.
+
+## 6. API livrée par la phase
+
+| Route | Rôle | Ticket |
+|---|---|---|
+| `GET/POST/PATCH /api/scheduler/tasks` (étendu) | Tâches planifiées : `agent_prompt`, cron, `misfire`, capacités affichées | P2-T01/T13 |
+| `POST /api/scheduler/tasks/{id}/run` (existant) | Exécution manuelle — produit un run unifié | P2-T02 |
+| `GET /api/automations` · `POST /api/automations/{id}/dry-run|enable|disable` | Automatisations : état, journal, dry-run | P2-T11/T12 |
+| `GET/POST /api/reminders` · `POST /api/reminders/{id}/snooze|cancel|ack` | Rappels (miroir des outils) | P2-T08/T09 |
+| `GET /api/memory/consolidation` | Derniers runs de consolidation et leurs compteurs | P2-T06 |
+
+## 7. Comportements détaillés
+
+### 7.1 Une tâche planifiée se relit comme un contrat
+
+L'UI des tâches planifiées affiche pour chaque tâche `agent_prompt` : le prompt, la whitelist effective, les plafonds, le dernier run (lien) et son résultat. Ce qui n'est pas affiché n'est pas autorisé : la whitelist par défaut ne s'étend que par `allowed_extra_tools` explicite, tracé dans l'audit.
+
+### 7.2 Rappel = tâche + livraison
+
+Il n'y a pas de second store de rappels : un rappel est une tâche de l'index portant `ctx: rappel` ou créée par `reminder_create`, à laquelle le scheduler rattache une **livraison** (canaux, acquittement, snooze, escalade). `Rappels.md` est une vue générée de l'index. Compléter la tâche acquitte le rappel ; snoozer décale la tâche (historique conservé).
+
+### 7.3 Le dry-run est un droit, pas une option cachée
+
+Toute automatisation peut être dry-runée avant activation **et** à tout moment ensuite, sur une fenêtre choisie. Le résultat du dry-run fait partie de son journal : une automatisation jamais dry-runée porte un badge « jamais testée » dans les Configurations.
+
+### 7.4 Consolidation et vie privée
+
+La consolidation ne lit que le vault et les conversations de l'utilisateur propriétaire (jamais inter-utilisateurs) ; les dossiers sensibles configurables forcent `pending` quelle que soit la confiance extraite ; les compteurs de validation (faits acceptés/rejetés) alimentent la métrique de dégradation du consolidateur (#212 : un taux de rejet en hausse durable est un signal, affiché au centre de contrôle).
+
+## 8. Tests et golden tasks
+
+- Unitaires : whitelist `agent_prompt` (tentatives d'évasion), watermark de consolidation, gardes d'automatisation (fréquence, dédup, profondeur), cron + `misfire` par horloge simulée, séries d'habitudes.
+- Intégration : nuit de consolidation complète sur fixture ; briefing après redémarrage ; rappel critique avec escalade ; automatisation de veille avec changement de page simulé.
+- Golden tasks de la phase : **G1** (rappel à 3 semaines), **G5** (secret jamais extrait, fait santé `pending`), **G8** (`frequence_max`) — définitions au parent §16.1.
+
+## 9. Critères d'acceptation de la phase
+
+1. Le briefing du matin paraît à l'heure, cite ses sources, et un redémarrage du conteneur ne produit ni doublon ni silence.
+2. Une nuit de consolidation produit des faits et des cartes traçables, respecte son budget dur, et ne perd aucune édition humaine concurrente.
+3. « Dans 3 semaines » devient un rappel livré à la bonne date ; le snooze répété est compté et visible.
+4. Une automatisation se dry-rune sans effet, s'active, respecte sa `frequence_max`, et se suspend proprement après 3 échecs.
+5. Aucune notification de la phase ne sort sans pourquoi ni lien, et le budget quotidien est tenu et affiché.
+
+## 10. Risques spécifiques et vigilance
+
+| Risque | Vigilance |
+|---|---|
+| `agent_prompt` devient un cheval de Troie de périmètre | Whitelist par tâche affichée comme contrat (§7.1) ; toute extension est un événement d'audit ; DANGEROUS structurellement absent des whitelists |
+| La consolidation dégrade la mémoire en silence | Compteurs de validation suivis (#212) ; bouton « relire le Journal » dans Aujourd'hui ; possibilité de suspendre la consolidation sans perdre les faits |
+| Les automatisations notifient trop (mort par mille alertes) | Budget d'interruption dès cette phase (P2-T17), sévérité `info` rangée en revue, `frequence_max` obligatoire |
+| Dérive horaire (DST) sur rappels et rituels | Ancrage heure murale partout ; tests d'horloge sur les deux changements d'heure de `America/Toronto` |
+
+## 11. Ordre d'exécution
+
+```
+P2-T01 → T02 → T03          (#200 — le briefing rebranche la tâche intégrée de la phase 1)
+P2-T04 → T05 → T06 → T07    (#194 — après T01 : la consolidation est une tâche agent_prompt)
+P2-T13 (scheduler amendé, tôt : il sert T08 et T11)
+P2-T08 → T09                (#199)
+P2-T10 → T11 → T12 → T14    (#208 — T14 après T09 pour les rappels contextuels)
+P2-T15 → T16                (#214 — après T03, T11 et le plan de la phase 1)
+P2-T17 (budget — avant T09/T14 en pratique) → P2-T18 (clôture)
+```
+
+## 12. Définition de « terminé »
+
+DoD du document de phase 0 §12, inchangée, plus : les golden tasks G1, G5 et G8 vertes en CI ; chaque tâche planifiée et chaque automatisation livrée affiche son contrat (capacités, plafonds, budget) dans l'UI.

docs/Assistant-V2/assistant-v21-phase-3-le-monde.md

@@ -0,0 +1,244 @@
+# Assistant V2.1 ObsiGate — Phase 3 : Le monde (connecteurs, synchronisation, client MCP)
+
+| Champ | Valeur |
+|---|---|
+| Phase | **3 sur 5** — l'assistant se branche sur les services de Bruno |
+| Document parent | `ASSISTANT-V2.1.md` — en particulier §11 (connecteurs, sync, replis, envoi encadré, client MCP), §9.6 (candidats mémoire), §15 (politiques) |
+| Version | 1.0 — 9 octobre 2026 |
+| Auteur | Spark, pour Bruno |
+| Statut | Prêt à implémenter |
+| Tranches | **#195** (cadre connecteurs + moteur de sync), **#196** (Google Calendar + Gmail + replis zéro-OAuth), **#197** (Microsoft Teams/Outlook), **#198** (Discord lecture + Notion + Drive), **#207** (ObsiGate client MCP) |
+| Effort estimé | 17–23 jours |
+| Prérequis | Phase 0 (politiques #213 — provenance et règles d'envoi ; runs #206), phase 1 (plan et tâches qui consomment l'agenda), phase 2 (bus d'événements #208 qui consomme la sync) |
+| Dépendances | #195 ← — ; #196, #197 ← #195, #213 ; #198 ← #195 ; #207 ← #195, #213 |
+| Débloque | Phase 4 (engagements détectés dans les courriels en mode candidats, préparation de réunions sur agenda réel), phase 5 (packs Communication/Voyages complets) |
+
+> **Résultat visible à la fin de cette phase.** Le plan du jour voit le **vrai agenda** et les vrais courriels. Les connecteurs Google, Microsoft, Discord, Notion et Drive sont installés via le cadre unifié « Sources connectées » : OAuth2 + PKCE quand il le faut, mais aussi des **replis sans aucun projet cloud** (iCal, CalDAV, IMAP) qui débloquent l'agenda et le courriel dès l'installation. Un moteur de **synchronisation incrémentale** maintient un état local frais que consomment le plan, les rappels et les automatisations (événements `connector.object.*` enfin émis). L'assistant cherche et lit le courriel, crée des brouillons, et **envoie** — uniquement sur approbation renforcée du texte final exact, jamais depuis une tâche planifiée. Enfin, ObsiGate devient **client MCP** : les serveurs MCP externes de Bruno entrent dans le même registre, sous les mêmes politiques.
+
+---
+
+## Table des matières
+
+1. [Objectif et principe directeur](#1-objectif-et-principe-directeur)
+2. [Périmètre](#2-périmètre)
+3. [État d'entrée](#3-état-dentrée)
+4. [Modèle de données](#4-modèle-de-données)
+5. [Tickets de travail](#5-tickets-de-travail)
+6. [API livrée par la phase](#6-api-livrée-par-la-phase)
+7. [Comportements détaillés](#7-comportements-détaillés)
+8. [Tests et golden tasks](#8-tests-et-golden-tasks)
+9. [Critères d'acceptation de la phase](#9-critères-dacceptation-de-la-phase)
+10. [Risques spécifiques et vigilance](#10-risques-spécifiques-et-vigilance)
+11. [Ordre d'exécution](#11-ordre-dexécution)
+12. [Définition de « terminé »](#12-définition-de--terminé-)
+
+---
+
+## 1. Objectif et principe directeur
+
+Le principe : **la prise de notes reste le vault ; les connecteurs nourrissent et exécutent, ils ne remplacent rien** (hérité de la V2, conservé). La phase ajoute deux corollaires propres à la V2.1 :
+
+- **Un état frais ou un aveu d'état périmé.** Le plan, les déclencheurs et les réponses s'appuient sur le cache synchronisé ; si la sync a échoué, l'assistant le dit (« agenda non synchronisé depuis 2 h ») au lieu de planifier sur du vide.
+- **L'écriture externe est un privilège d'exécution, pas une capacité de fond.** Créer un événement, un brouillon ou envoyer suit les niveaux d'autonomie et la politique de provenance (phase 0) : rien d'externe ne part d'un contenu lu sans validation humaine du résultat final.
+
+## 2. Périmètre
+
+### 2.1 Inclus
+
+- #195 : cadre `backend/connectors/` (interface, registre, installations, secrets 0600/env, OAuth2 code + PKCE, refresh transparent, retry/backoff, rate-limit par connecteur, audit de chaque `call()`) ; migration des sources Gitea/GitHub existantes sous le cadre (même UX) ; UI « Sources connectées » étendue (statut, scopes, test, journal d'appels, budget) ; **moteur de sync incrémentale** (collections déclarées, curseurs, webhooks fournisseurs quand disponibles sinon polling adaptatif, cache d'objets normalisés, émission des événements bus, page santé des syncs).
+- #196 : Google Calendar (lire/écrire) et Gmail (chercher/lire/brouillon/**envoyer** selon §7.3) sur le même consentement ; **replis zéro-OAuth** : iCal (lecture), CalDAV (lecture/écriture), IMAP (lecture courriel) ; guide d'installation Google pas-à-pas FR/EN.
+- #197 : Microsoft Graph — Teams (lire les salons choisis, envoyer en WRITE confirmé) et Outlook (courriel et calendriers, envoi selon §7.3) sur le même jeton Entra ID.
+- #198 : Discord en lecture par bot REST (pas de gateway en v1) en plus du webhook de sortie existant ; Notion (rechercher/lire/appendre, sync vers l'index de recherche) ; Drive (rechercher/lire, import vers le vault).
+- #207 : client MCP (serveurs déclarés par Bruno ; outils préfixés `mcp.<serveur>.*` dans le registre ; niveau de confiance par serveur ; empreinte de schéma et suspension en cas de changement).
+
+### 2.2 Exclu (phases ultérieures)
+
+- La **détection d'engagements dans les courriels** en production (#211, phase 4) : la phase livre le réglage candidats mémoire (§9.6 du parent, défaut `off`) et le pipeline ; l'activation métier est en phase 4.
+- Les packs qui consomment ces connecteurs au-delà du socle (Voyages, Communication avancée — phase 5).
+- Slack (option future, inchangé depuis la V2), l'envoi SMTP direct (l'envoi passe par les APIs Google/Microsoft), toute écriture Discord autre que le webhook existant.
+- La visioconférence et l'enregistrement de réunions : phase 4 (#209) pour la préparation et les comptes rendus, sur l'agenda livré ici.
+
+## 3. État d'entrée
+
+| Élément | Usage en phase 3 |
+|---|---|
+| Sources connectées Gitea/GitHub (#92/#103), `connected.py`, `secrets.py` | Précédent à généraliser ; migration sans perte d'UX |
+| Moteur de politiques + provenance (#213, phase 0) | Toute donnée connecteur entre avec `connector:<id>` ; les règles d'envoi et de sensibilité s'appliquent telles quelles |
+| Runs et approbation renforcée (phase 0/1) | Envois et écritures externes sont des steps de runs, approuvés dans la file unifiée |
+| Plan, tâches, automatisations (phases 1–2) | Consommateurs de l'agenda synchronisé et des événements `connector.object.*` |
+| Scheduler amendé (phase 2) | Les jobs de sync sont des tâches planifiées système (visibles, journalisées) |
+
+## 4. Modèle de données
+
+```sql
+-- data/connectors_cache.sqlite3 (reconstructible par re-sync complète)
+CREATE TABLE sync_state (
+  user_id TEXT NOT NULL, connector_id TEXT NOT NULL, collection TEXT NOT NULL,
+  cursor TEXT,                          -- token/page/date du fournisseur
+  last_sync_at TEXT, last_error TEXT, status TEXT NOT NULL DEFAULT 'ok',
+  PRIMARY KEY (user_id, connector_id, collection)
+);
+CREATE TABLE synced_objects (
+  user_id TEXT NOT NULL, connector_id TEXT NOT NULL,
+  external_id TEXT NOT NULL, type TEXT NOT NULL,   -- event|message|chat|page|file
+  title TEXT, starts_at TEXT, ends_at TEXT,
+  participants_json TEXT, excerpt TEXT,            -- extrait borné, JAMAIS le corps complet
+  link TEXT, updated_at TEXT NOT NULL,
+  PRIMARY KEY (user_id, connector_id, external_id)
+);
+```
+
+Installations et secrets : fichiers existants du patron V2 (`data/connectors.json` pour le public, `data/connector_secrets.json` 0600 ou variables `OBSIGATE_CONNECTOR_SECRET_<ID>` ; jetons OAuth chiffrés avec `data/secret.key`). Les collections synchronisables et leurs fenêtres (agenda ±30 j ; courriel : dossiers choisis, 14 j glissants ; Teams : salons choisis) sont déclarées par chaque connecteur, réglables dans l'UI.
+
+## 5. Tickets de travail
+
+*Convention : chaque ticket est indépendamment testable ; « Fichiers » donne les points d'ancrage d'après la V2.1 — à confirmer contre le code réel au démarrage du ticket. Les fournisseurs sont développés et testés contre des **simulateurs** (le harnais golden de la phase 0), les appels réels étant vérifiés en recette manuelle documentée par connecteur.*
+
+### Cadre & sync — #195
+
+**P3-T01 — Interface connecteur et registre.**
+Fichiers : `backend/connectors/base.py`, `backend/connectors/registry.py`, `backend/connectors/oauth.py`.
+Travail : `ConnectorInterface` (id, label, URL de doc, scopes, capabilities nommées, collections synchronisables) ; installation/désinstallation ; flux OAuth2 code + PKCE générique (endpoints d'allowlist codée par fournisseur) avec redirect `/api/connectors/{id}/callback`, échange + stockage du refresh token chiffré, refresh anticipé et 1 retry sur 401 dans `call()` ; auth par token statique pour les connecteurs qui s'y prêtent ; timeouts httpx 15 s, retry backoff, rate-limit par connecteur, cache GET court (TTL 5 min) pour le contexte de chat.
+Acceptation : un connecteur de test (fixture OAuth complète) s'installe, se teste, se rafraîchit et se désinstalle de bout en bout ; aucun secret n'apparaît dans les logs ni les retours d'outils (redaction vérifiée).
+
+**P3-T02 — UI Sources connectées et migration Gitea/GitHub.**
+Fichiers : `backend/routers/connectors.py`, page Configurations.
+Travail : cartes par connecteur (statut, scopes accordés, boutons Connecter/Tester/Déconnecter, journal des derniers appels depuis l'audit, budget) ; migration interne de `connected.py` : Gitea/GitHub deviennent deux connecteurs du cadre, configurations existantes relues sans ressaisie ; les outils historiques gardent leurs noms.
+Acceptation : une installation avec Gitea/GitHub configurés « à l'ancienne » fonctionne après migration sans intervention ; la page montre les appels récents des deux sources.
+
+**P3-T03 — Moteur de synchronisation incrémentale.**
+Fichiers : `backend/connectors/sync.py`, jobs scheduler système.
+Travail : pour chaque installation et collection : sync initiale bornée puis incrémentale par curseur ; réception webhook fournisseur quand le connecteur le déclare (Google/Microsoft), sinon polling adaptatif (défaut 15 min, ralenti la nuit, accéléré à l'approche d'un événement) ; normalisation des objets (§4) ; émission `connector.object.created|updated` sur le bus de la phase 2 ; erreurs → `last_error` + statut, jamais d'exception silencieuse ; re-sync complète manuelle depuis l'UI.
+Acceptation : un événement créé côté fournisseur (simulateur) apparaît dans le cache et émet l'événement bus en moins d'un cycle de polling ; la suppression côté fournisseur retire l'objet du cache (pas de fantôme dans le plan).
+
+**P3-T04 — Santé des connecteurs.**
+Travail : agrégation par connecteur (dernière sync, retard, taux d'erreur, quota estimé) exposée dans la carte et au centre de contrôle ; signal de dégradation consommé par le plan et le briefing (le consommateur affiche « données périmées » avec l'âge) ; un connecteur déconnecté retire ses outils du registre présenté au modèle (`list_tools` filtré par capabilities actives, comme le prévoit la V2 pour Tauri).
+Acceptation : couper la sync (simulateur en échec) fait apparaître l'âge des données dans le plan du jour suivant, sans bloquer le plan.
+
+### Google — #196
+
+**P3-T05 — Calendar : lecture et écriture.**
+Travail : capabilities `gcal.list_events` (READ), `gcal.get_event` (READ), `gcal.create_event` (WRITE), `gcal.update_event` (WRITE), toutes avec post-conditions `verify` (relecture de l'événement) et inverses (suppression de l'événement créé) ; le plan du jour (phase 1) bascule sa source d'agenda sur le cache synchronisé quand le connecteur est actif ; les blocs validés du plan peuvent être écrits dans l'agenda (option « plan → agenda », désactivée par défaut).
+Acceptation : « bloque 2 h jeudi pour la présentation » crée l'événement vérifié, visible au plan ; le désactiver (déconnexion) rend le plan à sa source vault sans erreur.
+
+**P3-T06 — Gmail : chercher, lire, brouillonner.**
+Travail : `gmail.search_messages` (syntaxe du fournisseur), `gmail.read_message`, `gmail.create_draft` (WRITE, inverse = suppression du brouillon) ; citation systématique dans les réponses (expéditeur, date, lien) ; le contenu lu porte la provenance `connector:gmail` et ne peut pas, seul, justifier une action externe (politique phase 0 — test dédié).
+Acceptation : « ai-je une réponse du dentiste ? » répond depuis le cache + lecture à la demande, avec citation ; aucun fait mémoire n'est créé depuis un courriel sans passer par le mode candidats (§9.6, défaut `off`).
+
+**P3-T07 — Envoi encadré.**
+Travail : `gmail.send` (DANGEROUS) selon le parent §11.4 : brouillon d'abord (T06), carte d'approbation **renforcée** sur le texte final exact (destinataires, objet, corps ; toute modification régénère la carte), interdiction structurelle depuis tâches planifiées et automatisations (la politique refuse avant même la carte), journalisation en step de run avec inverse = néant affiché.
+Acceptation : les trois refus sont prouvés par tests (envoi en tâche planifiée ; envoi dont le corps est une copie d'un courriel reçu sans reformulation validée ; envoi après modification du brouillon sans nouvelle carte) ; un envoi approuvé part une fois (idempotence).
+
+**P3-T08 — Replis zéro-OAuth : iCal, CalDAV, IMAP.**
+Fichiers : `backend/connectors/ical.py`, `caldav.py`, `imap.py`.
+Travail : iCal par URL secrète (lecture, sync par le moteur T03) ; CalDAV (lecture + création/màj d'événements, mot de passe d'application comme secret) ; IMAP (lecture : recherche et lecture, collections = dossiers choisis) ; ces connecteurs apparaissent dans la même matrice et la même UI, avec leurs limites affichées (« lecture seule » pour iCal/IMAP).
+Acceptation : un agenda iCloud/Nextcloud de test est lisible dans le plan sans aucun projet Google/Microsoft ; un compte IMAP de test répond à `mail.search` en lecture seule (toute tentative d'écriture est absente du registre, pas seulement refusée).
+
+### Microsoft — #197
+
+**P3-T09 — Graph : socle et Teams.**
+Travail : client Graph minimal (auth Entra ID via le cadre OAuth, pagination, erreurs typées) ; `teams.list_chats` (READ, salons choisis), `teams.read_messages` (READ), `teams.send_message` (WRITE avec confirmation affichant le salon et le texte exact — même régime que l'envoi courriel, adapté : pas de brouillon côté Teams, la carte tient lieu de relecture).
+Acceptation : lire un salon et y répondre via carte fonctionne sur tenant de test ; un salon non choisi n'est ni synchronisé ni lisible par l'outil.
+
+**P3-T10 — Outlook : courriel et calendriers.**
+Travail : `outlook.search_messages`, `outlook.read_message`, `outlook.create_draft`, `outlook.send` (même ticket de politique que P3-T07 — factoriser, ne pas dupliquer la logique d'approbation), `outlook.list_events` alimentant le cache d'agenda au même titre que gcal (le plan fusionne les calendriers actifs en signalant la source de chaque événement).
+Acceptation : un plan peut mélanger événements Google et Outlook sans doublon quand le même événement existe des deux côtés (dédup par titre+horaires signalée en carte, jamais de fusion silencieuse).
+
+### Discord, Notion, Drive — #198
+
+**P3-T11 — Discord en lecture.**
+Travail : bot token (secret) ; `discord.list_messages` et `discord.search` en REST sur les salons choisis ; le webhook de sortie existant (#168) devient la capability `discord.send` du connecteur (WRITE via notify, pas de doublon de code) ; pas de gateway websocket (limite affichée : pas de temps réel, sync par polling).
+Acceptation : la recherche dans un salon de test retrouve un message cité ; les salons non choisis sont inaccessibles aux outils.
+
+**P3-T12 — Notion : lire, appendre, synchroniser la recherche.**
+Travail : API key (token interne) ; `notion.search`, `notion.read_page`, `notion.append_blocks` (WRITE confirmé) ; les pages choisies sont synchronisées vers l'**index de recherche** d'ObsiGate (elles deviennent trouvables par la recherche et le recall, marquées `connector:notion` — jamais copiées dans le vault sans demande explicite d'import).
+Acceptation : « cherche dans Notion et dans mes notes » répond des deux sources distinguées ; un append est vérifié par relecture.
+
+**P3-T13 — Drive : chercher, lire, importer.**
+Travail : `drive.search`, `drive.read_file` (Docs/Sheets convertis en texte/markdown via l'API) ; import explicite vers le vault (`drive.read_file` → proposition de note, propose/apply existant) rattaché au backlog d'import ; lecture seule stricte (aucune écriture Drive cette phase).
+Acceptation : importer un document Drive crée une note du vault citant sa source ; l'original Drive n'est jamais modifié.
+
+### Client MCP — #207
+
+**P3-T14 — Branchement de serveurs MCP externes.**
+Fichiers : `backend/connectors/mcp_client.py`.
+Travail : déclaration de serveurs (URL/transport, authentification par secret) ; découverte des outils à la connexion ; enregistrement dynamique préfixé `mcp.<serveur>.*` avec risque déclaré par le serveur **plafonné** par la politique (un outil déclaré READ par le serveur mais à effets inconnus démarre au niveau d'autonomie 0–1) ; les contenus MCP portent la provenance `mcp:<serveur>` ; aucun contenu `sensitivity ∈ {private, sensitive}` n'est transmissible à un outil MCP externe (politique phase 0, test dédié).
+Acceptation : un serveur MCP de test expose un outil utilisable en conversation au niveau 1 ; tenter de lui passer un fait `sensitive` est refusé et journalisé.
+
+**P3-T15 — Empreintes de schéma et suspension.**
+Travail : empreinte (hash canonique du schéma de chaque outil) stockée à la validation du serveur ; à chaque session, comparaison : un schéma modifié suspend l'outil (retiré du registre présenté au modèle) et crée une carte de revalidation montrant le diff de schéma ; la revalidation est manuelle, par serveur.
+Acceptation : modifier le schéma d'un outil du serveur de test suspend exactement cet outil, pas les autres, et l'assistant explique la suspension au lieu d'échouer en silence.
+
+### Finitions
+
+**P3-T16 — Guides d'installation des fournisseurs.**
+Travail : `docs/GUIDES/CONNECTEURS_GOOGLE_MS.md` pas-à-pas FR/EN (création des applications Google Cloud et Entra ID, écrans de consentement, URI de redirection) + section replis zéro-OAuth (où trouver l'URL iCal, créer un mot de passe d'application) ; fiches `docs/features/` pour #195–#198 et #207 ; clés i18n des Sources connectées et des cartes d'envoi.
+Acceptation : un lecteur suivant le guide seul aboutit à un connecteur Google testé vert ; DoD du §12 pour le reste.
+
+## 6. API livrée par la phase
+
+| Route | Rôle | Ticket |
+|---|---|---|
+| `GET /api/connectors` · `POST /api/connectors/{id}/install|test|disconnect` | Installations et statut | P3-T01/T02 |
+| `GET /api/connectors/{id}/authorize` · `GET /api/connectors/{id}/callback` | Flux OAuth2 + PKCE | P3-T01 |
+| `GET /api/connectors/{id}/health` · `POST /api/connectors/{id}/sync` | Santé et re-sync manuelle | P3-T03/T04 |
+| `GET/POST /api/connectors/mcp-servers` · `POST /api/connectors/mcp-servers/{id}/revalidate` | Serveurs MCP externes et revalidation | P3-T14/T15 |
+
+Les capabilities connecteurs sont des outils `@tool` ordinaires (donc exposés au serveur MCP d'ObsiGate sous les mêmes politiques) ; il n'y a pas d'API REST par capability.
+
+## 7. Comportements détaillés
+
+### 7.1 Ce que la sync ne fait jamais
+
+Le corps complet d'un courriel n'est **jamais** synchronisé (extrait borné seulement) ; rien de synchronisé n'entre dans le vault ni dans la mémoire sans le pipeline candidats (§9.6, défaut `off`) ; désinstaller un connecteur purge son cache et ses curseurs (les secrets sont retirés, l'audit conserve la trace des appels passés sans contenu).
+
+### 7.2 Fuseaux et calendriers multiples
+
+Les événements synchronisés conservent leur fuseau d'origine ; le plan les projette dans `OBSIGATE_TZ` en affichant l'heure d'origine quand elle diffère (voyage). Un événement « toute la journée » reste ancré à sa date, jamais converti en minuit UTC décalé.
+
+### 7.3 L'envoi, en une phrase
+
+**Brouillon toujours, envoi jamais sans le texte final sous les yeux, et jamais en automatique** : ces trois règles sont codées dans la politique (phase 0) et testées en P3-T07/T10 ; le réglage d'activation de l'envoi (décision ouverte n° 2 du parent) peut le désactiver par connecteur sans toucher au code.
+
+### 7.4 Tauri et hors-ligne
+
+Sans token installé, les capabilities sont absentes du registre présenté au modèle (pas d'outils fantômes) ; hors-ligne, l'assistant répond depuis le cache synchronisé en annonçant son âge ; aucune tentative réseau n'a lieu au démarrage (P8 du parent).
+
+## 8. Tests et golden tasks
+
+- Simulateurs : chaque fournisseur a un double HTTP (réponses figées + scénarios d'erreur : 401, 429, pagination, webhook) utilisé en CI ; aucun test CI ne dépend d'un vrai compte.
+- Recette manuelle : par connecteur, un pas-à-pas de vérification sur compte réel, archivé dans la fiche de tranche (captures expurgées).
+- Golden tasks nouvelles de la phase : **G9** — « événement créé côté fournisseur → présent au plan, et plan honnête si la sync tombe » ; **G10** — « envoi refusé en tâche planifiée, accepté en interactif sur texte exact » ; **G11** — « schéma d'outil MCP modifié → outil suspendu, autres intacts ». (Numérotation à la suite de G1–G8 du parent.)
+- Non-régression : les sources Gitea/GitHub et les canaux de notification existants fonctionnent à l'identique après migration au cadre.
+
+## 9. Critères d'acceptation de la phase
+
+1. Google **ou** un repli zéro-OAuth suffit à alimenter le plan en agenda réel ; la fraîcheur des données est affichée, jamais présumée.
+2. Une recherche de courriel répond avec citation ; un brouillon se crée ; un envoi n'a lieu que sur approbation renforcée du texte final, et jamais en planifié.
+3. Désinstaller un connecteur retire ses outils, purge son cache et ses secrets, et dégrade proprement les consommateurs (plan, briefing).
+4. Un serveur MCP externe fonctionne sous politique ; un changement de schéma suspend l'outil concerné avec une carte de revalidation.
+5. G9, G10 et G11 sont verts en CI sur simulateurs.
+
+## 10. Risques spécifiques et vigilance
+
+| Risque | Vigilance |
+|---|---|
+| Création des applications OAuth = friction d'installation | Les replis zéro-OAuth (P3-T08) débloquent l'usage avant tout projet cloud ; le guide T16 est testé par un lecteur naïf |
+| Quotas et changements d'API des fournisseurs | Tout passe par `call()` (rate-limit, backoff, audit) ; les échecs de sync dégradent, ne cassent pas (§7, P3-T04) |
+| Double agenda = double vérité | Le cache distingue les sources ; la dédup d'affichage est signalée, jamais silencieuse (P3-T10) |
+| Un connecteur compromis devient un canal d'injection | La provenance `connector:<id>` et les règles de la phase 0 s'appliquent à 100 % du contenu sync et lu ; les extraits synchronisés sont traités comme des données, jamais des instructions |
+
+## 11. Ordre d'exécution
+
+```
+P3-T01 → T02 → T03 → T04        (#195 — la sync avant les connecteurs qui s'en servent)
+P3-T05 → T06 → T07 ; T08        (#196 — T08 indépendant, parallélisable après T01)
+P3-T09 → T10                    (#197 — T10 réutilise la politique d'envoi de T07)
+P3-T11 ; T12 ; T13              (#198 — parallélisables entre eux)
+P3-T14 → T15                    (#207 — après T01 et la politique phase 0)
+P3-T16                          (clôture)
+```
+
+## 12. Définition de « terminé »
+
+DoD du document de phase 0 §12, inchangée, plus : recette manuelle sur compte réel archivée par connecteur ; toute capability d'écriture déclare sa post-condition et son inverse (exigence du parent §21) ; les golden tasks G9–G11 vertes en CI.

docs/Assistant-V2/assistant-v21-phase-4-les-gens.md

@@ -0,0 +1,204 @@
+# Assistant V2.1 ObsiGate — Phase 4 : Les gens (personnes & engagements, voix & réunions, proactivité complète)
+
+| Champ | Valeur |
+|---|---|
+| Phase | **4 sur 5** — l'assistant connaît les gens, tient les promesses, et ne parle qu'à bon escient |
+| Document parent | `ASSISTANT-V2.1.md` — en particulier §13.2 (personnes & engagements), §17 (voix & réunions), §9.6 (candidats connecteurs), §14.4 (budget d'interruption) |
+| Version | 1.0 — 9 octobre 2026 |
+| Auteur | Spark, pour Bruno |
+| Statut | Prêt à implémenter |
+| Tranches | **#211** (personnes & engagements), **#209** (voix, transcription & réunions), **#201** (proactivité / insights, forme complète) |
+| Effort estimé | 9–13 jours |
+| Prérequis | Phase 0 (entités #192, miroir `Personnes.md` en coquille #193), phase 1 (tâches #202, file d'approbations #203), phase 2 (consolidation #194, budget d'interruption, automatisations #208) ; phase 3 recommandée (l'agenda réel et les courriels candidats donnent leur pleine valeur à #211 et à la préparation de réunions) mais **non bloquante** : la phase fonctionne sur le vault seul, dégradée proprement |
+| Dépendances | #211 ← #192, #202 ; #209 ← #205, #211 ; #201 ← #194, #199, #202, #211 |
+| Débloque | Phase 5 (les packs Communication, Maison & admin et Voyages consomment personnes, engagements et cycle de réunion) |
+
+> **Résultat visible à la fin de cette phase.** L'assistant sait **qui sont les gens** : entités personnes peuplées, notes dédiées quand Bruno le veut, anniversaires, dernières interactions sourcées. Il tient les **engagements dans les deux sens** — ce que Bruno a promis et ce qu'on lui doit — détectés en conversation ou dans les courriels (en candidats validables, jamais en silence), suivis en revue, avec des **relances rédigées en brouillon**. La **voix** devient une entrée de premier rang : dictée, notes vocales transcrites et triées, et cycle de réunion complet (préparation avec historique des participants → compte rendu structuré → actions datées avec responsables). Enfin, la **proactivité #201** arrive en forme complète : détecteurs branchés sur tâches, engagements, plans et habitudes, publiés dans `Insights.md` et consommés sous le budget d'interruption — utiles ou silencieux.
+
+---
+
+## Table des matières
+
+1. [Objectif et principe directeur](#1-objectif-et-principe-directeur)
+2. [Périmètre](#2-périmètre)
+3. [État d'entrée](#3-état-dentrée)
+4. [Modèle de données](#4-modèle-de-données)
+5. [Tickets de travail](#5-tickets-de-travail)
+6. [API livrée par la phase](#6-api-livrée-par-la-phase)
+7. [Comportements détaillés](#7-comportements-détaillés)
+8. [Tests et golden tasks](#8-tests-et-golden-tasks)
+9. [Critères d'acceptation de la phase](#9-critères-dacceptation-de-la-phase)
+10. [Risques spécifiques et vigilance](#10-risques-spécifiques-et-vigilance)
+11. [Ordre d'exécution](#11-ordre-dexécution)
+12. [Définition de « terminé »](#12-définition-de--terminé-)
+
+---
+
+## 1. Objectif et principe directeur
+
+Le principe : **les gens ne sont pas des données à aspirer, ce sont des relations à servir.** Chaque information sur une personne a une source que Bruno peut voir (il l'a dite, écrite, ou validée depuis un courriel candidat) ; rien n'est importé en masse, rien n'est inféré sur une personne à partir de signaux indirects, et les coordonnées restent `sensitivity='private'` — jamais transmises à un outil externe ou à un envoi sans que Bruno les ait lui-même fournies dans ce contexte.
+
+Corollaires :
+
+- **Un engagement n'existe que validé.** Détecter n'est pas enregistrer : toute détection (chat, courriel, compte rendu) produit une carte ; la création silencieuse est structurellement impossible (le pipeline n'a pas de chemin d'écriture sans approval de type `fait`/`triage`).
+- **La proactivité se juge à son taux d'acceptation.** Un insight refusé ou ignoré de façon répétée doit faire taire son détecteur (seuil relevé, puis suspension proposée) — la métrique décide, pas l'entêtement du système.
+
+## 2. Périmètre
+
+### 2.1 Inclus
+
+- #211 : peuplement des entités personnes (miroir `Personnes.md` complet, notes dédiées optionnelles par personne), outils `people.*` ; table `commitments` (parent §13.2) et outils/API associés ; détection d'engagements en conversation (carte) et via les candidats connecteurs (§9.6 du parent — activation du réglage par connecteur, défaut `off`) ; suivi (revue du soir, échéance, relance rédigée en brouillon, clôture en un clic) ; anniversaires depuis les attributs des entités (recette de la phase 2 activée sur données réelles).
+- #209 : dictée dans les surfaces existantes ; enregistrement audio déposé (PWA, chat, pièce jointe) → transcription par le fournisseur **choisi explicitement** dans les Configurations (décision ouverte n° 3 du parent : défaut proposé = API du provider LLM déjà configuré ; aucun envoi audio par défaut sans ce choix) ; notes vocales comme items d'inbox `kind='voice'` (transcrites, résumées en une ligne, triées) ; cycle de réunion : note de préparation (participants = entités, historique sourcé, engagements ouverts avec eux, documents liés), capture optionnelle dans la note (dictée ou audio déposé), compte rendu structuré selon la procédure par défaut (résumé, décisions, actions) avec extraction des actions en **tâches datées à responsables nommés dans le texte uniquement**, décisions proposées à la mémoire en cartes, rappels de consentement à la capture.
+- #201 : détecteurs complets (projet sans prochaine action ; tâche reportée ≥ 3 fois ; engagement échu ; note « à faire » vieillissante > 21 j ; snooze ≥ 3 sur un rappel ; série d'habitude cassée ; inbox vieillissante) tournant en tâche planifiée légère et à la demande ; publication dans `Insights.md` (sections gérées, suppression = rejet du détecteur pour cet objet) ; suggestions injectées au compileur de contexte (bornées, sourcées) ; consommation stricte du budget d'interruption (phase 2) ; retour d'acceptation mesuré par détecteur avec auto-ajustement (§7.3).
+
+### 2.2 Exclu (phases ultérieures / jamais)
+
+- Tout **enrichissement externe** de profils (réseaux sociaux, bases tierces) : hors périmètre durable, pas seulement ajourné — contraire au principe du §1.
+- L'import en masse d'un carnet d'adresses : un connecteur contacts en lecture pourra être un pack de la phase 5, avec validation personne par personne ; rien ici ne l'anticipe en base.
+- L'enregistrement automatique de réunions (bot qui rejoint les appels) : la capture est toujours déclenchée par Bruno dans la note.
+- Le diagnostic ou le conseil santé à partir d'habitudes ou de personnes : hors périmètre (rappelé dans les procédures des packs concernés).
+
+## 3. État d'entrée
+
+| Élément | Usage en phase 4 |
+|---|---|
+| Entités/relations + `Personnes.md` coquille (phase 0) | Le modèle est là ; la phase peuple, outille et met en usage |
+| Consolidation (phase 2) | Émet déjà faits `open_loop` et candidats entités ; la phase branche la promotion en engagements et les cartes associées |
+| Candidats connecteurs (mécanisme phases 2–3, défaut `off`) | Première source réelle : les engagements et rendez-vous lus dans les courriels choisis |
+| Inbox et triage (phase 1) | Les notes vocales sont des items comme les autres ; les comptes rendus déposés se trient vers tâches/engagements |
+| Agenda réel (phase 3, optionnel) | La préparation de réunion part des événements ; sans connecteur, elle part des notes de réunion du vault |
+
+## 4. Modèle de données
+
+Table `commitments` du parent §13.2 (dans `data/assistant.sqlite3`) — reprise sans changement, avec la règle : `source` ∈ {`chat`, `consolidation`, `connector`, `meeting`, `manual`} et `source_ref` obligatoire sauf `manual`.
+
+Attributs d'entité personne utilisés par la phase (dans `attrs_json`, schéma libre mais documenté) : `anniversaire` (MM-JJ ou AAAA-MM-JJ), `role` (texte libre de Bruno), `canal_prefere` (texte), `derniere_interaction` (calculé, jamais saisi par le modèle). Les coordonnées (courriel, téléphone) ne sont **pas** des attributs libres : champs dédiés `contact_json` chiffrés au repos quand le chiffrement #172 est actif, `sensitivity='private'` dans tous les cas, exclus des exports par défaut et du compileur de contexte sauf conversation concernant explicitement la personne.
+
+Transcriptions : l'audio est un fichier temporaire de `data/` supprimé après transcription réussie (sauf réglage explicite « conserver les audios ») ; la transcription vit dans la note ou l'item d'inbox, jamais dans une base séparée.
+
+## 5. Tickets de travail
+
+*Convention : chaque ticket est indépendamment testable ; « Fichiers » donne les points d'ancrage d'après la V2.1 — à confirmer contre le code réel au démarrage du ticket.*
+
+### Personnes & engagements — #211
+
+**P4-T01 — Personnes : miroir complet et notes dédiées.**
+Fichiers : `backend/memory/mirror.py` (extension), `backend/tools/people.py`.
+Travail : `Personnes.md` peuplé (par personne : relations connues, anniversaire, dernières interactions sourcées avec dates, engagements ouverts la concernant) ; création optionnelle d'une note dédiée par personne (dossier configurable, créée uniquement sur demande explicite ou validation de carte) ; outils `people_list` (READ), `people_get` (READ — coordonnées masquées par défaut, révélées seulement en conversation la concernant), `people_note_add` (WRITE — ligne datée dans la note dédiée).
+Acceptation : aucune coordonnée n'apparaît dans `Personnes.md` (miroir = relations et contexte, pas carnet d'adresses) ; un test le vérifie sur fixture contenant des coordonnées.
+
+**P4-T02 — Engagements : store, outils, API.**
+Fichiers : `backend/tools/people.py` (suite), `backend/routers/commitments.py` ou extension du routeur approvals/today.
+Travail : table `commitments` (§4) ; outils `commitment_list` (READ — ouverts, échus d'abord), `commitment_create` (WRITE via carte), `commitment_close` (WRITE — `done|dropped`, motif libre), `commitment_followup` (READ — état et dernière relance) ; section « Engagements » d'Aujourd'hui (échus en tête) et de la revue du soir ; clôture en un clic depuis la carte, Aujourd'hui ou la conversation.
+Acceptation : un engagement échu non clos apparaît à la revue du soir le jour J, puis en insight (#201) à J+2 s'il est toujours ouvert — pas avant, pas en notification dédiée (budget).
+
+**P4-T03 — Détection en conversation et en consolidation.**
+Travail : en conversation, les formulations d'engagement (« je vais envoyer X à Marie vendredi », « Karim doit me rendre Y ») produisent une carte de création pré-remplie (direction, personne résolue ou proposée, échéance **uniquement si énoncée**) ; en consolidation, les faits `open_loop` validés sont proposés en promotion vers `commitments` (une carte, pas une conversion automatique) ; résolution de personne ambiguë = carte de choix (règle de la phase 0).
+Acceptation : sur un corpus de 20 formulations de test, aucune création sans carte et aucune échéance inventée ; une promotion refusée ne se représente pas au run suivant (mémoire de rejet).
+
+**P4-T04 — Candidats connecteurs et relances.**
+Travail : activation du réglage `memoire: candidats` par connecteur (défaut `off`, UI Sources connectées) : les engagements détectés dans les collections synchronisées choisies deviennent des candidats `pending` sourcés (lien vers l'objet) dans la file unifiée ; relance : à l'échéance + délai configurable, proposition de brouillon de relance (prompt de l'annexe B.3 du parent) via `gmail.create_draft`/`outlook.create_draft` quand le connecteur existe, sinon texte proposé dans la carte ; l'envoi suit le régime de la phase 3 (§11.4 du parent), sans exception.
+Acceptation : avec le réglage `off`, zéro candidat produit (test) ; avec `on`, un courriel fixture « je vous enverrai le devis jeudi » produit exactement un candidat sourcé ; la relance n'est jamais envoyée par la tranche.
+
+### Voix & réunions — #209
+
+**P4-T05 — Transcription : fournisseur et surfaces.**
+Fichiers : `backend/tools/voice.py` (ou module `backend/voice/`), Configurations.
+Travail : réglage du fournisseur de transcription (choix explicite obligatoire avant le premier envoi audio ; choix proposés : API du provider LLM configuré disposant d'une offre voix, sinon aucun — pas de moteur ajouté au conteneur, P1) ; dictée navigateur branchée sur le champ de capture, le panneau et l'éditeur ; enregistrement et dépôt d'audio (PWA, chat, pièce jointe) → file de transcription (run visible) → texte ; suppression de l'audio après succès sauf réglage contraire ; durées et tailles plafonnées et affichées.
+Acceptation : sans fournisseur choisi, l'UI explique et ne transmet rien ; une transcription est un run journalisé avec son coût ; l'audio d'un test est absent de `data/` après traitement (réglage par défaut).
+
+**P4-T06 — Notes vocales vers l'Inbox.**
+Travail : un audio déposé devient un item `kind='voice'` : transcription, résumé en une ligne (cheap model), puis triage ordinaire de la phase 1 (les dates relatives se résolvent à l'horodatage de l'**enregistrement**) ; la carte de triage montre la transcription complète repliable, jamais le seul résumé.
+Acceptation : « rappelle-moi demain d'appeler le dentiste » en note vocale produit une proposition de tâche à la bonne date ; une note vocale ambiguë reste un item texte, pas une action devinée.
+
+**P4-T07 — Préparation de réunion.**
+Fichiers : skill `/reunion-prep`, outil de préparation (agrégateur READ).
+Travail : à partir d'un événement (phase 3) ou d'une note de réunion : participants résolus en entités, historique (notes liées, derniers comptes rendus avec eux), engagements ouverts les concernant (T02), documents rassemblés (liens), points probables **uniquement sourcés** (ordres du jour passés, tâches ouvertes du projet) ; sortie = note de préparation dans le vault, générée en run, relue par Bruno avant la réunion.
+Acceptation : la préparation d'une réunion fixture ne contient aucune affirmation sans source ; un participant inconnu est signalé comme tel, pas « enrichi ».
+
+**P4-T08 — Compte rendu et extraction d'actions.**
+Travail : transcription (dictée en direct dans la note, ou audio déposé) → compte rendu structuré selon la procédure par défaut (modifiable, mémoire procédurale phase 0) : résumé, décisions, actions ; extraction selon le prompt de l'annexe B.2 du parent : responsable = personne **nommée dans le texte**, échéance = **énoncée**, le reste part en `a_clarifier` ; propositions en file unifiée : tâches (créées dans la note projet ou la note de réunion), décisions → faits mémoire `pending`, suivis → brouillons ; écran de capture avec rappel de consentement, et aucune capture ne peut être déclenchée par une automatisation (politique).
+Acceptation : le scénario G4-bis (transcription fixture avec 3 actions dont 1 sans date et 1 sans responsable) produit 3 propositions exactes : 1 tâche datée complète, 1 sans échéance, 1 en `a_clarifier` — aucune invention.
+
+### Proactivité complète — #201
+
+**P4-T09 — Détecteurs.**
+Fichiers : `backend/automations/detectors.py` (nouveau), tâche planifiée légère.
+Travail : les sept détecteurs du §2.1, déterministes sur les index (tâches, engagements, inbox, habitudes, notes) — seul le détecteur « note à faire vieillissante » utilise un balayage de contenu borné ; chaque détection produit un objet insight {détecteur, objet, preuve, proposition d'action} ; exécution nocturne (avec la consolidation, sans coût LLM sauf rédaction optionnelle) et à la demande (`/insights`).
+Acceptation : chaque détecteur a une fixture positive et une négative ; aucun détecteur n'émet deux fois pour le même objet et le même état (dédup par empreinte objet+état).
+
+**P4-T10 — Publication et consommation des insights.**
+Travail : `Insights.md` en sections gérées (suppression d'un item = rejet pour cet objet, alimentant le compteur du détecteur) ; injection bornée au compileur de contexte (≤ 3, sourcés, seulement s'ils concernent le sujet de la conversation) ; actions proposées en un clic (créer la prochaine action du projet, clore ou relancer l'engagement, découper la tâche reportée) — toujours des cartes/runs ordinaires ; consommation du budget d'interruption : les insights ne notifient **jamais** directement, ils attendent le briefing ou Aujourd'hui (sévérité `info` par construction).
+Acceptation : une semaine de fixture produit des insights consultables sans produire une seule notification push d'insight.
+
+**P4-T11 — Boucle d'acceptation des détecteurs.**
+Travail : compteurs par détecteur (émis, acceptés, rejetés, ignorés 3 fois) au centre de contrôle ; règles d'auto-ajustement : taux d'acceptation < 20 % sur 20 émissions → seuil du détecteur relevé automatiquement (journalisé) ; < 10 % ensuite → proposition de suspension en carte (jamais de suspension silencieuse) ; réactivation manuelle toujours possible.
+Acceptation : un détecteur fixture bruyant voit son seuil relevé après 20 émissions majoritairement rejetées, et l'événement est visible au centre de contrôle.
+
+### Finitions
+
+**P4-T12 — i18n, docs, guides, vie privée.**
+Travail : clés FR/EN (personnes, engagements, réunions, insights) ; fiches `docs/features/` pour #211, #209, #201 ; guide « Personnes, engagements et réunions » incluant la page des réglages de confidentialité (candidats connecteurs, fournisseur de transcription, conservation des audios) ; extension de l'export/effacement (parent §15.4) aux engagements et aux attributs personnes.
+Acceptation : l'effacement du domaine « personnes » supprime entités concernées, engagements et miroirs associés, avec trace d'audit ; DoD du §12 pour le reste.
+
+## 6. API livrée par la phase
+
+| Route | Rôle | Ticket |
+|---|---|---|
+| `GET /api/people` · `GET /api/people/{id}` | Personnes (coordonnées masquées par défaut) | P4-T01 |
+| `GET/POST /api/commitments` · `POST /api/commitments/{id}/close` | Engagements et clôture | P4-T02 |
+| `POST /api/voice/transcribe` | Transcription d'un audio déposé (run) | P4-T05 |
+| `POST /api/meetings/prepare` · `POST /api/meetings/minutes` | Préparation et compte rendu | P4-T07/T08 |
+| `GET /api/insights` · `POST /api/insights/{id}/act|dismiss` | Insights et leurs actions | P4-T10 |
+
+Outils `@tool` correspondants : `people.*`, `commitment.*` (parent §9.7/§13.2), exposés au MCP comme les autres — avec la règle que `people_get` via MCP ne renvoie **jamais** les coordonnées (masquage renforcé hors conversation directe).
+
+## 7. Comportements détaillés
+
+### 7.1 Sans la phase 3, la phase vit quand même
+
+Pas de courriel candidat (la détection reste conversation + consolidation), préparation de réunion depuis les notes du vault, anniversaires et engagements pleinement fonctionnels. L'UI signale les capacités absentes comme des réglages à activer, pas comme des erreurs.
+
+### 7.2 Un engagement, deux directions, un seul objet
+
+`je_dois` et `on_me_doit` partagent le même cycle de vie ; la revue du soir présente les deux listes séparément (ce que je dois faire demain / ce que j'attends), et une relance n'existe que pour `on_me_doit` — pour `je_dois`, l'action proposée est une tâche.
+
+### 7.3 La proactivité a un éditeur : Bruno
+
+Le taux d'acceptation par détecteur est la métrique directrice de la phase (suivie par #212) : elle est affichée, et les ajustements automatiques de seuil sont des événements journalisés et réversibles. Un détecteur suspendu peut être réactivé ; un détecteur supprimé d'`Insights.md` objet par objet apprend ce qui ne sert pas.
+
+## 8. Tests et golden tasks
+
+- Unitaires : détection d'engagements (corpus de formulations, aucune date inventée), masquage des coordonnées (miroir, export, MCP), dédup des insights, auto-ajustement des seuils.
+- Intégration : courriel candidat → engagement → échéance → brouillon de relance ; note vocale → tâche ; réunion complète prép → CR → tâches.
+- Golden tasks de la phase : **G12** — « engagement pris par courriel (réglage candidats activé) suivi jusqu'au brouillon de relance, jamais envoyé seul » ; **G13** — « compte rendu : 3 actions extraites sans invention (cf. P4-T08) » ; **G14** — « une semaine d'insights : zéro notification d'insight, taux d'acceptation mesuré ». (Suite de G1–G11.)
+
+## 9. Critères d'acceptation de la phase
+
+1. Un engagement créé en conversation ou validé depuis un courriel est suivi jusqu'à sa clôture ou sa relance rédigée — sans création silencieuse à aucun maillon.
+2. Aucune coordonnée de personne ne fuit : ni miroir, ni export par défaut, ni MCP, ni outil externe (tests dédiés verts).
+3. Une note vocale et un compte rendu produisent des tâches exactes (responsables et dates uniquement quand ils sont énoncés).
+4. Les insights sont utiles ou se taisent : publication sans notification directe, compteurs d'acceptation actifs, auto-ajustement prouvé sur fixture.
+5. La phase fonctionne, dégradée mais complète, sans aucun connecteur.
+
+## 10. Risques spécifiques et vigilance
+
+| Risque | Vigilance |
+|---|---|
+| Sentiment de surveillance des tiers (réunions, courriels) | Consentement affiché à la capture, candidats toujours validés, aucune donnée tierce conservée hors du fait validé ; les personnes peuvent être « gelées » (entité exclue de toute détection) par un réglage par personne |
+| Détection d'engagements trop zélée (faux positifs en chaîne) | Cartes regroupées, mémoire de rejet par formulation, métrique d'acceptation du détecteur d'engagements suivie comme les autres |
+| Coût de transcription sur de longues réunions | Plafonds de durée affichés avant traitement, coût journalisé par run, fournisseur choisi et révocable |
+| Insights « bienveillants » mais inutiles qui érodent la confiance | La boucle d'acceptation (P4-T11) est un critère de phase, pas une amélioration future |
+
+## 11. Ordre d'exécution
+
+```
+P4-T01 → T02 → T03 → T04        (#211)
+P4-T05 → T06 ; T07 → T08        (#209 — T07 peut démarrer après T01/T02)
+P4-T09 → T10 → T11              (#201 — après T02 pour le détecteur d'engagements)
+P4-T12                          (clôture)
+```
+
+## 12. Définition de « terminé »
+
+DoD du document de phase 0 §12, inchangée, plus : les golden tasks G12–G14 vertes en CI ; les tests de non-fuite des coordonnées (§9, critère 2) font partie de la suite permanente, pas d'un audit ponctuel.

docs/Assistant-V2/assistant-v21-phase-5-extension.md

@@ -0,0 +1,159 @@
+# Assistant V2.1 ObsiGate — Phase 5 : L'extension (packs de domaines et évaluation continue)
+
+| Champ | Valeur |
+|---|---|
+| Phase | **5 sur 5** — optionnelle et étalée : le cœur (phases 0–4) est complet sans elle |
+| Document parent | `ASSISTANT-V2.1.md` — en particulier §13.4 (packs de domaines), §16 (évaluation & observabilité), §20 (risque « périmètre qui grandit sans fin ») |
+| Version | 1.0 — 9 octobre 2026 |
+| Auteur | Spark, pour Bruno |
+| Statut | Cadre prêt ; chaque chantier s'active séparément, à la demande de Bruno |
+| Tranches | **#210** (packs de domaines, chantiers A–G), **#212** (évaluation & observabilité — volet continu, chantier H) |
+| Effort estimé | 3–5 jours **par chantier de pack**, étalés ; chantier H : 2–3 jours puis continu |
+| Prérequis | Phases 0–4 terminées pour les chantiers qui consomment connecteurs, personnes et automatisations ; les chantiers A et F sont possibles dès la phase 2 |
+| Dépendances | #210 ← #208 (+ phase 3 pour B, C partiellement, E ; + phase 4 pour C et les relances) ; #212 ← amorce de la phase 0, puis toutes les phases |
+| Débloque | Rien : c'est la phase d'extension. Chaque chantier terminé enrichit l'assistant sans rien débloquer d'obligatoire |
+
+> **Résultat visible à la fin de chaque chantier.** Un domaine de vie de plus est couvert de bout en bout par l'assistant — pas par un nouveau moteur, mais par l'assemblage curé de ce qui existe : des **recettes** (automatisations et plans), des **procédures** (la façon de Bruno de faire les choses, en mémoire), des **skills** et ses **golden tasks** propres. Un pack ne s'active qu'à la demande, se désactive sans laisser de trace dans le quotidien, et prouve son utilité par ses scénarios avant d'être livré. Le chantier H (#212) court en parallèle de toute la phase : le corpus de golden tasks grandit, les métriques du centre de contrôle deviennent des revues périodiques, et le routage de modèles s'affine sur données réelles.
+
+---
+
+## Table des matières
+
+1. [Objectif et principe directeur](#1-objectif-et-principe-directeur)
+2. [Ce qu'est un pack — anatomie et gouvernance](#2-ce-quest-un-pack--anatomie-et-gouvernance)
+3. [État d'entrée](#3-état-dentrée)
+4. [Chantiers de packs — #210](#4-chantiers-de-packs--210)
+5. [Chantier H — Évaluation & observabilité continues — #212](#5-chantier-h--évaluation--observabilité-continues--212)
+6. [Critères d'acceptation de la phase](#6-critères-dacceptation-de-la-phase)
+7. [Risques spécifiques et vigilance](#7-risques-spécifiques-et-vigilance)
+8. [Ordre d'exécution suggéré](#8-ordre-dexécution-suggéré)
+9. [Définition de « terminé »](#9-définition-de--terminé-)
+
+---
+
+## 1. Objectif et principe directeur
+
+Le principe : **« maximum de tâches » s'atteint par assemblage, pas par accumulation de moteurs.** Le cœur des phases 0–4 (mémoire, tâches, plan, exécution fiable, connecteurs, automatisations, personnes) est générique à dessein ; la valeur d'un domaine — voyages, argent, apprentissage — tient à ses recettes, ses procédures et ses critères de qualité, pas à du code nouveau. La phase 5 est donc organisée en **chantiers indépendants et optionnels**, sur le modèle de la phase d'extension des documents Agents & Skills : aucun chantier n'est un prérequis d'un autre (hors dépendances notées), chacun a ses critères de sortie, et la phase n'a pas de « fin » obligée.
+
+Deux garde-fous contre la dispersion (risque nommé au parent §20) :
+
+- **Un pack = un chantier, un chantier = une livraison.** Pas de pack « à moitié activé » : recettes, procédures, skills et golden tasks arrivent ensemble, ou le chantier n'est pas terminé.
+- **La désactivation est un non-événement.** Retirer un pack retire ses recettes actives et ses skills des menus ; les notes, tâches et faits créés restent (ce sont des données de Bruno, pas du pack).
+
+## 2. Ce qu'est un pack — anatomie et gouvernance
+
+| Composant | Forme | Exemple |
+|---|---|---|
+| Recettes | Automatisations et plans pré-remplis (phase 2), activables une à une | « Veille de prix hebdomadaire » |
+| Procédures | Faits `kind='procedure'` livrés avec le pack, **modifiables** (mémoire phase 0) | « Un dossier de voyage contient : itinéraire, documents, contacts, budget » |
+| Skills | Skills `/` existants ou nouveaux, dans le format actuel (`data/skills.json` et skills intégrés) | `/voyage-prep` |
+| Modèles de notes | Notes modèles dans le vault (listes, checklists, tableaux) | Checklist d'entretien maison par saison |
+| Golden tasks | Scénarios du domaine, ajoutés au corpus (chantier H) | 2–4 par pack, bloquants pour la livraison du chantier |
+| Réglages | Niveau d'autonomie par défaut proposé (jamais imposé), budgets propres éventuels | Pack Voyages : niveau 1 par défaut (lecture) |
+
+Gouvernance : un registre simple des packs (installé/activé/désactivé) dans les Configurations, section Assistant ; l'activation affiche **tout** ce que le pack ajoutera (recettes avec leurs déclencheurs, procédures avec leur texte, skills) avant confirmation — même exigence de transparence que pour une automatisation importée (parent §15.1). Aucun pack ne peut élever un niveau d'autonomie ni créer une délégation : il *propose*, les mécanismes des phases 0–1 disposent.
+
+## 3. État d'entrée
+
+Tout ce que les phases 0–4 ont livré, et en particulier : le catalogue d'outils existants bien plus riche que le seul périmètre assistant (documents docx/xlsx/csv/pdf et outils tableurs complets — lecture, recherche, analyse de plages, édition — décrits dans les guides `ASSISTANT_IA_FORGE` et `RECHERCHE_PDF_EXCALIDRAW`), les skills d'apprentissage déjà intégrés (`/quiz`, `/reading-note`, `/qa-generator`…), la recherche et le Deep Research, `fetch_url`/`crawl_site`, les connecteurs Gitea/GitHub migrés au cadre (phase 3), les automatisations et le bus (phase 2), les personnes et engagements (phase 4). Plusieurs chantiers ci-dessous ne demandent **aucun nouvel outil** — c'est un critère de conception, pas un hasard.
+
+## 4. Chantiers de packs — #210
+
+*Convention : chaque chantier est décrit par son contenu (recettes/procédures/skills), ses dépendances propres, 1 exemple de golden task et ses critères de sortie spécifiques. L'effort type est de 3–5 jours, presque entièrement en contenu et en tests, pas en moteur.*
+
+### Chantier A — Connaissance & veilles avancées
+
+Contenu : recettes de veille multi-sources (page web + recherche périodique sur un sujet → note de diff dans le vault, insight seulement si changement matériel) ; synthèse de dossier à la demande (« tout ce que j'ai sur X, et ce qui a changé depuis <date> ») en skill assemblant recherche vault, Notion synchronisée (phase 3) et mémoire ; revue de lecture hebdomadaire depuis l'inbox (items `url` non triés > 7 j proposés en lot : lire/résumer/archiver).
+Dépendances : phases 0–2 (3 pour la source Notion).
+Golden task (exemple) : une page fixture modifiée entre deux veilles produit exactement une note de diff citant l'ancien et le nouveau contenu ; inchangée, elle ne produit rien.
+Sortie : les trois recettes fonctionnent sur fixtures ; aucun nouvel outil créé.
+
+### Chantier B — Documents & données du quotidien
+
+Contenu : procédures et recettes sur les outils **existants** (documents et tableurs) : classeur de budget personnel (modèle xlsx + recette mensuelle « importer un relevé csv déposé dans le vault → catégoriser selon la procédure de Bruno → mettre à jour le classeur → rapport d'écarts en note ») ; génération de documents récurrents (attestations, courriers types) depuis des modèles de notes et des faits mémoire ; extraction de tableaux de PDF du vault vers des notes.
+Dépendances : phases 0–2 ; relevés = fichiers déposés par Bruno (aucune connexion bancaire, voir chantier D).
+Golden task : un relevé fixture de 30 lignes est catégorisé selon la procédure, avec les lignes ambiguës en carte — jamais devinées.
+Sortie : le rapport mensuel complet est produisible par une recette dry-runée puis activée.
+
+### Chantier C — Maison & administration personnelle
+
+Contenu : modèle d'entretien récurrent (tâches RRULE par équipement, notes d'interventions liées) ; démarches suivies (renouvellements, garanties, assurances) comme engagements envers soi avec échéances et documents rassemblés ; listes vivantes (courses, cadeaux — alimentées par l'inbox et les personnes de la phase 4 : anniversaires → propositions) ; rappels saisonniers en recettes.
+Dépendances : phases 1, 2, 4 (anniversaires et cadeaux) ; phase 3 optionnelle (échéances lues dans les courriels candidats).
+Golden task : la garantie d'un équipement arrivant à échéance dans 30 j produit une tâche datée avec le document lié, sans notification directe (revue).
+Sortie : le dossier « Maison » du vault de test est entièrement tenu par les recettes du pack pendant un mois simulé.
+
+### Chantier D — Argent en lecture seule
+
+Contenu : **strictement** la lecture et l'analyse de données que Bruno dépose (relevés csv/xlsx, exports) : catégorisation (procédure du chantier B réutilisée), budgets par enveloppe en notes, alertes d'échéances de factures détectées dans les notes et les courriels candidats, synthèse mensuelle. Aucun accès bancaire direct, aucun paiement, aucune initiation de virement — ces exclusions sont **structurelles** (aucun outil du pack n'a de capability d'écriture externe) et rappelées dans la fiche du pack.
+Dépendances : chantier B ; phase 3 pour les candidats courriels.
+Golden task : une facture fixture échue non payée (selon les notes) apparaît en revue avec sa source ; une facture payée n'y apparaît pas.
+Sortie : la synthèse mensuelle d'un mois fixture est exacte au centime sur les lignes non ambiguës, et les ambiguës sont listées à part.
+
+### Chantier E — Voyages
+
+Contenu : procédure « dossier de voyage » (itinéraire, documents, contacts sur place, budget, contraintes) ; recettes : préparation (checklist générée depuis la procédure et les dates, documents rassemblés depuis le vault et Drive), rappels décalés par fuseau (le moteur RRULE/heure murale des phases 1–2, appliqué au fuseau de destination pour les rappels « sur place »), briefing de départ (agenda, documents, engagements en suspens pendant l'absence), retour (dépenses déposées → chantier D, photos/notes → dossier).
+Dépendances : phases 1–4 (agenda réel et Drive en phase 3 fortement recommandés).
+Golden task : un voyage fixture sur 2 fuseaux produit des rappels aux heures murales correctes dans chaque fuseau, affichés avec leur heure d'origine (règle de la phase 3 §7.2).
+Sortie : le dossier complet d'un voyage de test est produit par les recettes, sans intervention de code.
+
+### Chantier F — Apprentissage
+
+Contenu : assemblage des skills **existants** (`/quiz`, `/reading-note`, `/qa-generator`, `/summary-progressive`) avec les habitudes (phase 2) et la mémoire : parcours de lecture d'un dossier (ordre proposé, fiches générées dans le vault, quiz espacés en tâches récurrentes liées à l'objectif), revue d'apprentissage mensuelle (ce qui est su, mesuré par les quiz, pas déclaré).
+Dépendances : phases 0–2 seulement — chantier livrable tôt.
+Golden task : un chapitre fixture produit des fiches et un quiz ; les réponses du quiz mettent à jour le suivi sans toucher aux notes sources.
+Sortie : un parcours complet sur un dossier de test, de la première fiche à la revue mensuelle.
+
+### Chantier G — Synchronisation de tâches externe (option conditionnelle)
+
+Contenu : **seulement si** Bruno tranche la décision ouverte n° 4 du parent en faveur d'un gestionnaire externe (Todoist ou équivalent) : connecteur du cadre (phase 3) en synchronisation bidirectionnelle avec le vault **source de vérité** (règles du parent §11.5 : tâches synchronisées marquées `source='connector'` + id externe ; conflit = modification la plus récente gagne, journalisée et visible) ; la vue Aujourd'hui et le plan continuent de lire l'index local.
+Dépendances : phases 1, 3 ; décision de Bruno.
+Golden task : la même tâche modifiée des deux côtés pendant une coupure se résout selon la règle, avec le conflit visible dans le journal — jamais de perte silencieuse.
+Sortie : une semaine d'usage simulé sans divergence d'index ; la désactivation du connecteur laisse le vault complet et autonome.
+
+## 5. Chantier H — Évaluation & observabilité continues — #212
+
+Ce chantier n'est pas un pack : c'est le volet continu de #212, amorcé en phase 0 (harnais + G3/G6/G7) et enrichi par chaque phase (G1/G2/G4/G5/G8 en phase 2, G9–G11 en phase 3, G12–G14 en phase 4, puis les golden tasks des packs).
+
+**P5-H1 — Corpus vivant.** Le corpus `tests/golden/` devient une suite de référence versionnée : tout scénario qui a un jour révélé un défaut réel y entre comme test de non-régression (règle : un bug d'assistant corrigé sans golden task ajouté n'est pas « terminé »). Revue du corpus à chaque livraison de chantier : scénarios obsolètes retirés explicitement, jamais en silence.
+
+**P5-H2 — Métriques en revues.** Les compteurs du centre de contrôle (parent §16.2 : plans tenus, runs par statut, validations de faits, acceptation des détecteurs, coût par type de run, temps de décision quotidien, interruptions vs budget) sont assemblés en **revue mensuelle automatique** (note dans `99_Assistant/Revues/`) relue avec Bruno : c'est là que se décident les ajustements de seuils, de budgets et de niveaux d'autonomie — sur données, pas sur impressions.
+
+**P5-H3 — Routage de modèles affiné.** La table de routage par type de job (parent §16.3) est ajustée depuis les métriques : un job dont le taux de rejet/correction dépasse un seuil passe au modèle supérieur (proposition en revue mensuelle, jamais de changement silencieux de coût) ; un job à très haut volume et haute acceptation peut descendre au modèle inférieur, golden tasks du job vertes à l'appui.
+
+**P5-H4 — Échantillon réel en lecture seule.** Avant chaque livraison de chantier, l'échantillon de scénarios sûrs (lecture seule) tourne contre l'instance réelle de Bruno ; les écarts avec la CI (données réelles vs fixtures) sont consignés dans la fiche du chantier. Aucune écriture réelle n'est jamais produite par ce mécanisme.
+
+Critères de sortie (le chantier est « en régime » quand) : la revue mensuelle est produite et a été relue au moins deux fois ; le corpus compte les scénarios de toutes les phases livrées ; au moins un ajustement (seuil, budget ou routage) a été décidé sur la base d'une revue.
+
+## 6. Critères d'acceptation de la phase
+
+La phase 5 n'a pas de critère global — chaque chantier a les siens. Critères transverses, vérifiés à chaque livraison de chantier :
+
+1. Le chantier n'a créé **aucun nouveau moteur** ; tout outil nouveau éventuel est justifié dans la fiche du chantier (par défaut : zéro).
+2. Ses golden tasks sont vertes et entrées au corpus (chantier H).
+3. Son activation a été précédée de l'affichage complet de ce qu'il ajoute ; sa désactivation ne supprime aucune donnée de Bruno.
+4. Sa fiche `docs/features/` et son guide sont livrés (DoD commune).
+
+## 7. Risques spécifiques et vigilance
+
+| Risque | Vigilance |
+|---|---|
+| La phase devient un fourre-tout qui ne finit jamais | C'est assumé : la phase est **optionnelle et étalée** ; le produit est complet sans elle. Le risque serait l'inverse — bloquer le cœur pour un pack |
+| Des packs médiocres érodent la confiance dans le cœur | La barre de livraison d'un chantier est celle des phases précédentes (golden tasks, DoD) ; un pack qui ne la passe pas ne s'active pas |
+| Le chantier D (argent) glisse vers du conseil financier | Périmètre lecture/analyse uniquement ; les synthèses citent les données déposées et n'émettent ni recommandation d'achat/vente ni jugement de solvabilité — écrit dans la procédure du pack et dans sa fiche |
+| La revue mensuelle (#212) devient un rituel ignoré | Elle est courte par construction (une page, chiffres et écarts seulement) et lue dans la revue de semaine existante, pas dans un nouveau rendez-vous |
+
+## 8. Ordre d'exécution suggéré
+
+Aucun ordre imposé. Suggestion fondée sur les dépendances et le rapport valeur/effort :
+
+```
+Dès la phase 2 :  F (apprentissage — aucun connecteur requis)
+Après la phase 3 : A (veilles) → B (documents & données) → D (argent, après B)
+Après la phase 4 : C (maison & admin) → E (voyages)
+Si décision prise : G (sync tâches externe)
+En continu, dès la phase 0 : H (#212) — ses livrables propres sont en §5
+```
+
+## 9. Définition de « terminé »
+
+Par chantier : DoD du document de phase 0 §12 + critères transverses du §6 ci-dessus. La phase 5 elle-même n'est jamais « terminée » par construction : elle se clos quand Bruno décide qu'aucun chantier restant ne vaut son effort — ce qui est un succès du découpage, pas un échec du plan.

docs/GUIDES/API_REST.md

@@ -100,13 +100,37 @@ Gestion :
 
 | Endpoint | Rôle |
 |---|---|
-| `GET /api/auth/tokens` | Lister vos clés (`last_used_at`, statut) |
-| `POST /api/auth/tokens` | Créer (`{name, expiry}`) |
+| `GET /api/auth/tokens` | Lister vos clés (`last_used_at`, statut, **portée**) |
+| `POST /api/auth/tokens` | Créer (`{name, expiry, vaults?, scope?}`) |
 | `DELETE /api/auth/tokens/{jti}` | Révoquer immédiatement (API **et** MCP) |
 
 > Le JWT brut n'est **jamais persisté** : copiez-le à la création. Plafond :
 > 50 clés actives par utilisateur.
 
+### 2.3 Clés à portée limitée (synchronisation externe, ex. TikTak)
+
+Une clé peut être confinée **à un ou plusieurs vaults** et **aux fichiers seuls** —
+si elle fuit, le reste reste hors de portée :
+
+```bash
+curl -s -X POST http://localhost:2020/api/auth/tokens \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"name":"TikTak sync","expiry":"never","vaults":["TikTak"],"scope":"files"}'
+```
+
+- `vaults` : sous-ensemble de vos vaults (`400` si inconnu, `403` si hors de vos
+  accès ; omis = tous vos vaults, comme avant).
+- `scope: "files"` : surface fichiers uniquement (CRUD, listes, recherche,
+  backups lecture/restauration, `GET /api/vaults`, `/mcp`). Tout le reste —
+  admin, config, IA, webhooks, partages, **gestion des clés elle-même** — répond
+  **403**. Les outils MCP hors fichiers sont refusés (`token_scope_denied`) et
+  masqués du `list_tools`.
+- La portée est affichée dans l'interface (Configurations → **🔑 Clés API & MCP**)
+  et renvoyée par `GET /api/auth/tokens` (`scope`, `vaults`).
+- Les clés créées avant cette fonction n'ont aucune portée = accès complet,
+  comportement inchangé (non-régression testée).
+
 ---
 
 ## 3. Référence des endpoints
@@ -166,7 +190,7 @@ Gestion :
 | `/api/suggest?q=` | Autocomplétion de titres | GET | Oui |
 | `/api/tags/suggest?q=` | Autocomplétion de tags | GET | Oui |
 | `/api/tree-search` | Recherche de fichiers/dossiers | GET | Oui |
-| `/api/vault/{vault}/paths` | Liste de chemins | GET | Oui |
+| `/api/vault/{vault}/paths` | Liste de chemins **avec `size`/`mtime`/`mtime_iso`** (réconciliation externe en un appel) | GET | Oui |
 | `/api/graph/{vault}` | Graphe de liens | GET | Oui |
 
 ### 3.5 Sauvegardes
@@ -231,10 +255,13 @@ Gestion :
 |---|---|---|
 | `/api/share/{vault}` | Créer un lien de partage public | POST |
 | `/api/shares` | Lister / supprimer les partages | GET/DELETE |
-| `/api/webhooks` | CRUD webhooks (HMAC-SHA256) | GET/POST/PATCH/DELETE |
+| `/api/webhooks` | CRUD webhooks (HMAC-SHA256, **filtres `vault` / `path_prefix`**) | GET/POST/PATCH/DELETE |
 | `/api/conflicts` · `/api/conflicts/resolve` | Conflits Syncthing | GET/POST |
 | `/api/plugins` | Installer / activer / désactiver | GET/POST/DELETE |
 | `/api/push/*` | Abonnement Web Push (VAPID) | GET/POST/DELETE |
+| `/api/duplicates` · `/api/duplicates/merge` | Doublons : paires candidates, fusion (`confirm: true`) | GET/POST |
+| `/api/notify/channels` · `/api/notify/test` | Notifications Discord/Telegram/SMTP/webhook (CRUD admin + test) | GET/POST/PATCH/DELETE |
+| `/api/scheduler/tasks` · `/api/scheduler/tasks/{id}/run` | Tâches planifiées (CRUD + exécution manuelle) | GET/POST/PATCH/DELETE |
 
 ---
 
@@ -282,9 +309,33 @@ curl -s $BASE/api/index/reload -H "Authorization: Bearer $TOKEN"
 
 ---
 
-## 5. Temps réel
+## 5. Synchronisation externe (TikTak)
 
-### 5.1 SSE — `/api/events`
+Recette complète côté ObsiGate : fiche
+[`../features/tiktak-integration-197-200.md`](../features/tiktak-integration-197-200.md)
+(#200 : provisionnement du vault « TikTak », #199 : clé limitée, #198 : webhook
+filtré). Boucle de réconciliation type avec **un seul appel de liste** :
+
+```bash
+KEY=<clé scope=files, vaults=[TikTak]>
+# 1. Inventaire : chemin + mtime + taille, sans lire les contenus
+curl -s "$BASE/api/vault/TikTak/paths?limit=20000" -H "Authorization: Bearer $KEY" \
+  | jq -r '.results[] | select(.type=="file") | "\(.mtime) \(.size) \(.path)"' > avant.txt
+# 2. … modifications …
+# 3. Détecter les changés par comparaison avec l'inventaire précédent
+curl -s "$BASE/api/vault/TikTak/paths?limit=20000" -H "Authorization: Bearer $KEY" \
+  | jq -r '.results[] | select(.type=="file") | "\(.mtime) \(.size) \(.path)"' > apres.txt
+```
+
+> `PUT /api/file/{vault}/save` rafraîchit l'index de façon synchrone : la re-liste
+> qui suit voit le nouveau `mtime`/`size` sans attendre le watcher. Les sauvegardes
+> texte émettent `file_modified` (webhook) pour tirer les retours.
+
+---
+
+## 6. Temps réel
+
+### 6.1 SSE — `/api/events`
 
 Flux d'événements de changement d'index (fichiers créés/supprimés/modifiés), avec
 reconnexion automatique côté client.
@@ -293,7 +344,7 @@ reconnexion automatique côté client.
 curl -N "$BASE/api/events"
 ```
 
-### 5.2 WebSocket — collaboration
+### 6.2 WebSocket — collaboration
 
 `ws(s)://<hôte>/ws/collab/{vault}/{path}` transporte les mises à jour
 Yjs/CRDT et la présence (curseurs distants). Authentification par cookie
@@ -302,7 +353,7 @@ Voir [Édition & collaboration](./COLLABORATION.md).
 
 ---
 
-## 6. Limites et bonnes pratiques
+## 7. Limites et bonnes pratiques
 
 - **Rate limiting** : les endpoints de login et les outils IA sont limités ;
   respectez `retry_after` en cas de `429`.
@@ -317,12 +368,12 @@ Voir [Édition & collaboration](./COLLABORATION.md).
 
 ---
 
-## 7. Dépannage
+## 8. Dépannage
 
 | Code | Cause probable |
 |---|---|
 | `401` | Jeton absent, expiré ou révoqué |
-| `403` | Compte sans accès à cette vault / réservé admin |
+| `403` | Compte sans accès à cette vault / réservé admin / clé à portée limitée hors périmètre |
 | `404` | Vault, fichier ou chemin inexistant |
 | `409` | Conflit (fichier déjà existant, etc.) |
 | `422` | Corps de requête invalide (schéma Pydantic) |

docs/GUIDES/ASSISTANT_IA_FORGE.md

@@ -182,10 +182,23 @@ partagée par l'assistant in-app et le serveur MCP.
 | Écriture (propose/apply) | `create_file`, `create_directory`, `edit_file`, `append_to_file`, `restore_backup` |
 | Destructif (propose/apply) | `rename_file`, `rename_directory`, `move_path`, `replace_in_files`, `delete_file`, `delete_directory` |
 | Web / sources connectées | `web_search`, `fetch_url`, sources Gitea/GitHub… |
+| Doublons (#166) | `find_duplicates` (lecture), `merge_duplicate_notes` (destructif) |
+| Notifications (#168) | `notify_external` (Discord, Telegram, SMTP, webhook) |
+| Tâches planifiées (#170) | `create/list/delete/run_scheduled_task*` |
 
 Les mutations suivent un flux **two-step** : `propose_<tool>` renvoie un aperçu
 et un **jeton signé à usage unique**, puis `apply_<tool>` exécute.
 
+Exemples de demandes à l'assistant (mode agent) :
+
+- « Trouve les notes en double dans ce vault » → `find_duplicates`, puis
+  « fusionne `brouillon.md` dans `rapport.md` » → `merge_duplicate_notes`
+  (backup automatique, approbation requise).
+- « Préviens-moi sur Discord quand la tâche échoue » → `notify_external`
+  (canaux configurés via `POST /api/notify/channels`, déclencheurs au choix).
+- « Crée une note de veille chaque matin à 8h » → `create_scheduled_task`
+  (`daily_time 08:00`, action `create_file` ou `append_to_file`).
+
 ---
 
 ## 7. Sécurité

docs/GUIDES/AUTHENTIFICATION_SECURITE.md

@@ -174,7 +174,7 @@ et [`features/api-mcp-tokens-107.md`](../features/api-mcp-tokens-107.md).
 | **Rate limiting MFA** | Appliqué aux endpoints TOTP/WebAuthn/recovery |
 | **Audit log** | Écritures, suppressions, config dans `data/audit.log` (JSON lines, rotation 10 Mo) |
 | **Backup automatique** | Avant chaque modification/suppression dans `.obsigate-backup/` |
-| **Redaction** | Masquage des JWT, clés API, tokens dans les aperçus et retours d'outils |
+| **Redaction** | Masquage des JWT, mots de passe, clés API (OpenAI, GitHub, Google, AWS, Slack, Stripe…), tokens et connection strings dans les aperçus markdown et les retours d'outils — clic sur un masque = copie de la valeur |
 | **CSP** | `object-src`, `base-uri`, `form-action`, `frame-ancestors` restreints |
 | **Cookie HttpOnly** | Jeton retiré de `sessionStorage`, porté par cookie HTTP-only |
 | **Utilisateur non-root** | Conteneur sous `obsigate` (UID 1000) |
@@ -187,6 +187,30 @@ et [`features/api-mcp-tokens-107.md`](../features/api-mcp-tokens-107.md).
 Une politique minimale est validée à la création d'un compte. Choisissez des mots
 de passe longs et uniques ; activez le MFA pour les comptes admin.
 
+### Secrets masqués dans les aperçus
+
+Quand une note contient un secret, l'aperçu markdown le remplace par un masque
+— `[CLÉ API MASQUÉE]`, `[MOT DE PASSE MASQUÉ]`, `[JWT MASQUÉ]`,
+`[CONNECTION_STRING MASQUÉE]` — au lieu de la valeur :
+
+- **Détectés automatiquement** : mots de passe (`password=`, `"passwd": "…"`,
+  `db_password=…`, toute longueur), affectations `api_key=` / `token=` /
+  `secret=`, JWT, clés privées, connection strings, hex en contexte secret,
+  et les formats de clés les plus répandus — OpenAI/Anthropic/OpenRouter
+  (`sk-`), GitHub (`ghp_`, `github_pat_`), Google (`AIza…`, `ya29.`), AWS
+  (`AKIA…`/`ASIA…`), Slack (`xoxb-`), Stripe (`sk_live_`, `whsec_`), GitLab
+  (`glpat-`), Hugging Face (`hf_`), npm, Docker, SendGrid, Resend, Square,
+  Atlassian, Discord, Telegram, jetons `Bearer …`.
+- **Clic = copie** : dans l'application (aperçu authentifié), cliquer sur un
+  masque copie la valeur réelle dans le presse-papiers (infobulle « Cliquer
+  pour copier la valeur »). La valeur n'apparaît jamais en clair à l'écran.
+- **Jamais exposé à l'extérieur** : partages publics (`/s/{token}`), exports
+  PDF et contexte envoyé à l'IA / au serveur MCP ne reçoivent que le libellé,
+  jamais la valeur derrière le masque.
+- **Hors périmètre** : la vue « source » (fichier brut) et les aperçus de
+  fichiers non-markdown ne sont pas masqués — c'est le fichier lui-même qui
+  est affiché.
+
 ---
 
 ## 7. Variables d'environnement

docs/GUIDES/DESKTOP.md

@@ -23,6 +23,32 @@ commande**.
 | Icône de barre des tâches (tray) | ❌ | ✅ |
 | Auto-update | ❌ | ✅ (vérifie les releases Gitea) |
 | Mode hors-ligne | Limité | Complet (backend local) |
+| Gestion vaults & dossiers | Fichiers de config serveur | ✅ UI dédiée + menu contextuel |
+
+### Gestion des vaults et dossiers (#159)
+
+Deux surfaces, réservées à l'application desktop :
+
+- **Menu contextuel** : clic droit sur un vault ou un dossier racine dans la
+  sidebar → « Retirer de l'application » (confirmation, déregistration de la
+  configuration locale — **aucun fichier n'est supprimé**), puis
+  redémarrage automatique du backend.
+- **Configuration** : section « 🖥️ Vaults & dossiers (Desktop) » listant les
+  vaults et dossiers chargés, avec boutons « Ajouter un vault » (sélecteur de
+  dossier natif) et « Ajouter un dossier ».
+
+### Premier lancement (#160)
+
+Au tout premier démarrage (aucun vault configuré), l'application :
+
+1. crée et monte **`%USERPROFILE%\ObsiGate`** comme vault de démarrage
+   (« ObsiGate ») et ouvre l'interface dessus ;
+2. y écrit le document **`Prise en main.md`** — présentation, premières
+   étapes, raccourcis (`Ctrl+Espace`, `Ctrl+Alt+Espace`, `Ctrl+F`,
+   `Ctrl+W`/`Ctrl+Tab`) et accès au guide complet (bouton d'aide de l'en-tête).
+   Le fichier n'est jamais réécrit : modifiez-le ou supprimez-le librement ;
+3. ajoute votre dossier personnel comme seconde racine (nommée d'après son
+   chemin).
 
 ---
 

docs/GUIDES/MCP.md

@@ -19,6 +19,10 @@ Cline, tout client compatible MCP) via un serveur **Streamable HTTP** monté sur
    (`Authorization: Bearer <token>`). Une seule clé fonctionne pour l'API REST
    **et** le MCP. Créez-la depuis l'interface (Configurations → 🔑 Clés API & MCP)
    ou via `POST /api/auth/tokens` — voir [API REST §2.2](./API_REST.md#22-clés-api-longue-durée-recommandé-pour-scripts--mcp).
+   Pour une intégration limitée aux fichiers (ex. TikTak), créez une clé
+   `{"vaults":["TikTak"],"scope":"files"}` ([API REST §2.3](./API_REST.md#23-clés-à-portée-limitée-synchronisation-externe-ex-tiktak)) :
+   les outils hors fichiers sont refusés (`token_scope_denied`) et masqués du
+   `list_tools`, et les autres vaults répondent en erreur d'accès.
 3. Si l'authentification est désactivée (`OBSIGATE_AUTH_ENABLED=false`), le
    serveur MCP accepte un utilisateur anonyme disposant de tous les vaults.
 

docs/GUIDES/PRISE_EN_MAIN.md

@@ -178,6 +178,31 @@ des **onglets** (avec possibilité de vue multi-panneaux / split view).
 > Selon le mode, la lecture et l'édition se remplacent : `Editer` et `Forge`
 > prennent la place de la vue lecture ; revenez avec `✓` / `×` ou `Échap`.
 
+### Discuter d'un fichier
+
+- **Bouton « Chat »** (💬, barre d'actions du document) : ouvre un panneau
+  latéral avec l'historique de la discussion et la saisie d'un message.
+- Les nouveaux messages s'affichent en direct ; si le panneau est fermé, une
+  notification annonce l'envoi. L'historique est conservé par fichier.
+- Le panneau **suit le document** : changer de fichier re-cible la discussion.
+
+### Chat général
+
+- Onglet **💬 Chat** (dernier de la sidebar, sous les onglets) : conversation
+  centrale, valable pour toute l'application, avec **pastille rouge** quand
+  de nouveaux messages arrivent.
+- **📎** attache une image ou une vidéo (25 MB max) ; les URL sont cliquables.
+- La **barre de filtre** sert à chercher dans le chat (texte ou auteur) quand
+  cet onglet est actif.
+- **🗑** (survol d'un message) : supprime votre message — un administrateur
+  peut supprimer celui de n'importe qui. Confirmation demandée, le retrait
+  est immédiat pour tout le monde.
+- **Messages privés** : la rangée de pastilles au-dessus du fil propose
+  **Général** puis chaque utilisateur ; choisissez un destinataire pour une
+  conversation à deux, avec son propre compteur de non-lus.
+- **Link preview** : coller une URL suffit — titre, description, image et
+  site s'affichent en carte cliquable sous le message (si le site répond).
+
 ---
 
 ## 7. Rechercher

docs/GUIDES/RECHERCHE_PDF_EXCALIDRAW.md

@@ -134,24 +134,87 @@ curl "http://localhost:2020/api/file/Recettes/pdf/info?path=menu.pdf"
 
 ## 6. Tableurs Excel (XLSX)
 
+### Créer un classeur
+
+Pour démarrer un tableur, clic droit sur un vault ou un dossier →
+**Nouveau fichier** (ou **Nouveau fichier ici**), choisissez le type **Excel
+(.xlsx)** et saisissez un nom : le classeur est créé avec une feuille
+**Feuille1** et s'ouvre directement dans l'éditeur, prêt à être saisi. La même
+liste de types est accessible depuis la palette de commandes (`Ctrl+Alt+Space`).
+
 ### Affichage et édition
 
 Un fichier `.xlsx` s'ouvre dans une visionneuse dédiée : un tableau par
 feuille, des onglets pour naviguer entre elles (toujours visibles, même à
 une seule feuille), les en-têtes A1/B1 et les numéros de ligne. La barre de
-commandes regroupe les actions en sections (Formules · Insertion · Vue ·
-Fichier) autour d'un bouton **Enregistrer** principal. Chaque cellule est
-modifiable directement (clic), `Entrée` valide, `Échap` annule la saisie.
-**Enregistrer** envoie les cellules modifiées à
+commandes reprend l'ordre de Google Sheets (recherche, annuler/rétablir,
+impression, peinture, zoom, formats de nombre, police, couleurs, bordures,
+fusion, alignements, retour ligne, rotation, options) et le bouton **⋮**
+regroupe figeage, tri, filtre, dimensions, lien, commentaire ; les menus
+**Mise en forme** / **Structure** restent disponibles. Elle est **épinglée en
+haut** de la page et l'éditeur occupe toute la largeur du contenu, pour que
+les commandes restent atteignables pendant le défilement d'un grand tableau.
+
+**Mise en page mobile** — sur un écran étroit (≤ 768 px), la barre de menus et
+le ruban de formatage sont **repliés par défaut** afin que la grille occupe
+toute la hauteur disponible : seuls les onglets de feuilles, **Enregistrer** et
+la **barre de formule (fx)** restent affichés. Le bouton **☰** (à gauche des
+onglets) déplie/replie l'ensemble ; les commandes tactiles font au moins
+44 px, les onglets défilent horizontalement et les champs de saisie restent en
+16 px pour éviter le zoom automatique d'iOS.
+
+Les largeurs de colonnes et hauteurs de lignes s'ajustent en **glissant le
+bord des en-têtes** (souris et tactile) : en plaçant le pointeur sur le bord
+d'un en-tête de colonne (`A`, `B`, `C`…) ou de ligne (`1`, `2`, `3`…), le
+curseur change pour indiquer l'ajustement.
+
+### Sélectionner et saisir
+
+Comme dans Google Sheets et Excel, une cellule est **sélectionnée** ou **en cours
+de saisie** — jamais les deux à la fois.
+
+- **Sélectionner** — un clic ou les flèches : la cellule s'entoure, sans curseur
+  clignotant.
+- **Saisir** — un **double-clic** (le curseur se place sous le pointeur, la saisie
+  se fait en place), la **première frappe** (qui *remplace* le contenu au lieu
+  de s'y ajouter), ou `F2`.
+- **Valider et descendre** — `Entrée` pendant la saisie enregistre et place le
+  focus **sur la cellule du dessous**. `Entrée` sur une cellule simplement
+  sélectionnée la bascule en saisie. `Tab` fait de même vers la droite. Les
+  **flèches** valident aussi et déplacent la sélection.
+- **Quitter la saisie** — `Échap` restaure la valeur d'origine ; un clic ailleurs
+  conserve ce qui a été tapé.
+- `Alt`+flèche insère un saut de ligne **dans** la cellule.
+
+**Sélection multiple** — `Maj`+clic ou `Maj`+flèches étendent la plage depuis la
+cellule d'origine ; glisser à la souris fait de même. Un **clic simple** réduit
+toujours la sélection à la cellule cliquée. La plage est **contourée** comme dans
+Excel, et les en-têtes couverts (lettres et numéros de ligne) sont mis en
+évidence. Depuis les **marges**, un clic sur un numéro de ligne ou une lettre de
+colonne sélectionne la **ligne ou la colonne entière**, et glisser — ou
+`Maj`+clic — étend à **plusieurs lignes ou colonnes** (`A1:Z5`). Une sélection
+de plusieurs cellules affiche une mini-barre (lien, commentaire,
+réinitialiser le filtre, somme). **Enregistrer**, placé à droite des onglets
+de feuilles, envoie les cellules modifiées à
 `PUT /api/file/{vault}/xlsx/save` : une sauvegarde par feuille, avec
 **backup automatique** du fichier avant écriture, et une écriture
 **atomique** (le classeur n'est jamais laissé à moitié écrit).
 
-Le bouton **« + »** à côté des onglets ajoute une nouvelle feuille. Deux
-pastilles d'état rappellent les limites de la vue : **« Lecture seule »**
-pour les formats `.xls`/`.ods`, et **« Formules non recalculées »** — ObsiGate
-affiche la formule telle qu'elle est enregistrée, Excel la recalcule à
-l'ouverture et les cellules dépendantes ne se rafraîchissent pas à l'écran.
+Le bouton **« + »** à côté des onglets ajoute une nouvelle feuille. Une
+pastille **« Lecture seule »** rappelle la seule limite de la vue : les
+formats `.xls`/`.ods`. ObsiGate calcule par ailleurs les formules courantes
+à l'écran (arithmétique, `SOMME`, `MOYENNE`, `SI`…) ; les fonctions non
+prises en charge affichent la formule telle qu'enregistrée, Excel la
+recalcule à l'ouverture.
+
+Le tableau suit le **thème de l'application** : fond, en-têtes, bordures et
+lignes alternées sont dérivés du thème actif (tous les thèmes, y compris
+contrasté élevé et sépia).
+
+La grille montre toujours les colonnes **A à Z** et **1000 lignes**, comme un
+tableur : les lignes et colonnes inutilisées restent affichées et leurs
+cellules vides sont **éditables** comme les autres. Seule la feuille affichée
+est étendue, à son ouverture.
 
 ### Avertissement avant enregistrement
 
@@ -253,7 +316,8 @@ ou `Maj+clic` sélectionne une plage (affichée dans la zone Nom, ex. `A1:B3`),
 et cliquer un **en-tête** sélectionne toute la ligne ou colonne. Un **clic
 droit** (ou un **appui long** sur mobile) ouvre un menu : copier, couper,
 coller, insérer/supprimer une ligne ou une colonne, trier A→Z / Z→A, effacer le
-contenu.
+contenu. Chaque entrée porte une **icône** ; le menu se referme dès qu'il perd
+le focus (clic ailleurs, `Échap`) et se parcourt au clavier (`↑`/`↓`).
 
 **Tri, filtre, recherche, export** — le tri (ascendant / descendant) s'applique
 depuis le menu contextuel et n'affecte que l'affichage ; les lignes se filtrent et
@@ -261,18 +325,24 @@ la recherche (`Ctrl+F` du panneau) parcourt **toutes les feuilles** : le compteu
 indique le nombre de feuilles concernées et passer sur une correspondance
 **active l'onglet** qui la contient.
 
-La sortie propose quatre formats, toujours sur le **contenu affiché** (et jamais
-sur les valeurs calculées en cache) :
+La sortie est rassemblée dans un seul menu **Fichier**, placé à droite des
+onglets de feuilles, juste avant le bouton **Enregistrer**. Il propose cinq
+actions, toujours sur le **contenu affiché** (et jamais sur les valeurs
+calculées en cache) :
 
-- **CSV** (bouton `CSV`) — exporte la **sélection** quand une plage de plusieurs
-  cellules est active (le nom du fichier reprend la plage, ex.
-  `Fruits-A1B2.csv`), sinon la feuille entière ;
-- **Markdown** et **HTML** (menu **Exporter**) — tableau markdown ou document
-  HTML autonome, mêmes règles de sélection ;
-- **Imprimer** (menu **Exporter**) — imprime la feuille ou la sélection seule,
-  sans le ruban ni les panneaux de l'application.
+- **Télécharger le fichier** — le classeur d'origine, tel qu'il est sur le
+  disque ;
+- **CSV** — exporte la **sélection** quand une plage de plusieurs cellules est
+  active (le nom du fichier reprend la plage, ex. `Fruits-A1B2.csv`), sinon la
+  feuille entière ;
+- **Markdown** et **HTML** — tableau markdown ou document HTML autonome,
+  mêmes règles de sélection ;
+- **Imprimer** — imprime la feuille ou la sélection seule, sans le ruban ni
+  les panneaux de l'application.
 
-Rien de tout cela ne modifie le classeur.
+Le menu se ferme au clic extérieur, à la perte de focus, avec `Échap` ou au
+défilement, et se parcourt aux flèches. Rien de tout cela ne modifie le
+classeur.
 
 **Structure** — le menu **Structure** de la barre d'outils ajoute,
 renomme, duplique ou supprime une feuille, et insère/supprime des lignes ou
@@ -280,12 +350,23 @@ colonnes autour de la cellule active (`PUT …/xlsx/structure`, backup
 automatique et confirmation, comme pour l'édition des cellules).
 
 **Mise en forme** — le bouton **Mise en forme** ouvre un menu qui agit sur la
-**sélection courante** (une cellule ou une plage) :
+**sélection courante** (une cellule ou une plage), repris aussi dans la barre
+d'outils (gras, italique, barré, souligné, taille, couleurs, bordures,
+alignements, retour ligne, rotation) :
 
-- **caractère** — gras, italique, souligné, effacer la mise en forme ;
-- **alignement** — gauche, centré, droite ;
-- **couleurs** — couleur de police et couleur de fond (sélecteur natif, aucune
-  palette imposée) ;
+- **caractère** — gras, italique, souligné, barré, taille de police,
+  effacer la mise en forme ;
+- **alignement** — gauche, centré, droite, justifié (+ vertical, retour à la
+  ligne, rotation) ;
+- **bordures** — toutes, extérieures, aucune ;
+- **couleurs** — couleur de police et couleur de fond, via un **panneau façon
+  Google Sheets** : *Réinitialiser*, une palette de 80 pastilles (une ligne de
+  gris du noir au blanc, puis huit teintes du clair au foncé), une section
+  **Standard** de huit couleurs prédéfinies et une section **Personnalisé**.
+  Un clic sur une pastille referme le panneau et applique la couleur à la
+  cellule ou à la plage sélectionnée. Le bouton **+** ouvre le sélecteur du
+  système pour une teinte libre. « Mise en forme conditionnelle » et
+  « Couleurs en alternance » sont annoncées mais pas encore disponibles ;
 - **format de nombre** — général, nombre, pourcentage, devise, date, texte ;
 - **structure** — fusionner / défusionner les cellules, figer / libérer les
   volets, largeur de colonne, hauteur de ligne (fusionner exige une vraie
@@ -299,8 +380,10 @@ message « Réessayer »). Un `.csv` ne portant pas de mise en forme, le bouton
 n'y est pas proposé (il est également absent d'une grille en lecture seule).
 La lecture restitue par ailleurs les couleurs, polices, cellules fusionnées et
 volets figés du fichier ; l'ancrage de la zone figée est conservé au défilement.
-Les **commentaires**, liens hypertexte, validation de données, mise en forme
-conditionnelle et bordures restent hors périmètre.
+Les **commentaires** se lisent (pastille) et s'éditent (mini-barre ou menu ⋮) ;
+les liens s'insèrent comme formules `=LIEN(url;libellé)` (ouvr. `Ctrl+clic`).
+Restent hors périmètre : validation de données, mise en forme conditionnelle,
+graphiques et tableaux croisés dynamiques.
 
 **Formats de fichiers** — `.xlsm` s'édite comme un `.xlsx` et ses
 **macros sont préservées** à l'enregistrement (y compris le chargement des
@@ -353,11 +436,13 @@ une feuille, insérer/supprimer des lignes ou des colonnes).
   qu'enregistrées (aucune valeur calculée n'est recalculée). Un classeur reste
   la source de vérité : utilisez **Charger la suite** pour exporter au-delà du
   plafond.
-- **Aucun moteur de formule** : ObsiGate lit et écrit les formules telles
-  qu'Excel les a enregistrées, sans jamais les recalculer. Une saisie
-  commençant par `=` ou `@` est stockée comme **texte** (garde anti-DDE)
-  tant que le bouton `f(x)` n'est pas activé ; l'enregistrement vous le
-  signale par un message. Excel reste la référence pour les valeurs calculées.
+- **Moteur de formule local** : ObsiGate calcule à l'écran l'arithmétique, les
+  références, les plages et une trentaine de fonctions en français et en
+  anglais (`SOMME`, `MOYENNE`, `SI`, `LIEN`…). Une saisie commençant par `=`
+  ou `@` reste stockée comme **texte** (garde anti-DDE) tant que le bouton
+  `f(x)` n'est pas activé ; l'enregistrement vous le signale par un message.
+  Les fonctions non prises en charge affichent la valeur mise en cache par
+  Excel quand elle existe. Excel reste la référence pour les valeurs calculées.
 - L'**annulation** couvre l'édition, l'effacement, le tri/filtre et les
   actions de structure ; en revanche une **suppression** (feuille, ligne,
   colonne) n'est pas annulable, faute d'inverse.

docs/ISSUES_TODOLIST.md

@@ -211,6 +211,15 @@ Avant de corriger quoi que ce soit, un agent IA doit :
 | *BUG-101* | Raccourcis d'onglets déclarés deux fois : un seul `Ctrl+W` fermait deux onglets (le second fermait celui ré-activé par la fermeture précédente) et `Ctrl+Tab` sautait un onglet | 🟢 corrigé | P1 | 📱 frontend | IA | `frontend/js/ui.js` (bloc « Keyboard shortcuts for tabs » dupliqué en fin de fichier) | Ouvrir deux onglets puis `Ctrl+W` une fois | Suppression du second bloc `document.addEventListener("keydown", …)` dupliqué (fin de `ui.js`) — un seul listener reste | Exposé par #158 : le second onglet n'était plus jamais vide auparavant (la 2ᵉ fermeture tombait sur `_activeTabId === null` et devenait sans effet). Vérifié : repro Playwright (`closes: ["fichier", "nav"]` avant → `["fichier"]` après) + suite E2E |
 | *BUG-102* | Menu contextuel qui se referme ~10 ms après son ouverture : la reflow des icônes (remplacement `<i>` → `<svg>` par lucide) déclenche un événement `scroll` capturé par `ContextMenuManager` qui referme le menu | 🟢 corrigé | P2 | 📱 frontend | IA | `frontend/js/ui.js` (`ContextMenuManager.init/show`) | Clic droit sur un fichier de la page de navigation (ou de l'arbre) juste après un rendu d'icônes | `show()` mémorise `_shownAt` ; le listener `scroll` (capture) ignore un déclenchement dans les 250 ms suivant l'ouverture | Exposé par #158 A5 (test E2E `nav-tab.spec.js` : menu résolu « hidden » alors que 6 items étaient construits). Vérifié : instrumentation Playwright (display block conservé après le scroll) + suite E2E |
 | *BUG-103* | Mobile : le bas du sidebar de navigation est masqué par la barre d'outils du bas (`z-index` 200 < 900) | 🟢 corrigé | P2 | 📱 frontend | IA | `frontend/style.css` (règle `.sidebar` du bloc `@media (max-width: 768px)`) | Vue mobile (≤768 px), sidebar ouvert depuis « Explorateur » | Passé à `z-index: 950` (au-dessus de `.mobile-toolbar`, 900) | Exposé après #158 (retour utilisateur). Vérifié : `elementFromPoint` Playwright (393×851) + test source `mobile sidebar over toolbar` (`unit.test.mjs`) |
+| *BUG-104* | Desktop : toutes les commandes Tauri invoquées depuis la page backend (`http://127.0.0.1`) rejetées « not allowed by ACL » — le bouton « Choisir mon dossier » du wizard ne fait rien | 🟢 corrigé | P1 | 🖥️ desktop | IA | `desktop/permissions/commands.toml` (nouveau), `desktop/capabilities/default.json`, `desktop/build.rs` | Installeur 2.49.2 : clic sur « Choisir mon dossier » → aucune fenêtre ; console `[desktop] invoke(pick_vault_folder) failed: Command … not allowed by ACL` (capturée via CDP, WebView2 `--remote-debugging-port`) | Manifeste de permissions applicatives créé (`allow-app-commands`, 19 commandes) et référencé par la capability : Tauri v2 ACL gate toute commande invoquée depuis une origine *remote*, y compris celles de l'`invoke_handler` | `cargo test` 25 passed (nouveau garde-fou `test_frontend_invokes_are_acl_allowed`) + vérif live CDP : `get_version`→2.49.2, clic → fenêtre native « Select Folder », parcours complet ajout de vault terminé |
+| *BUG-105* | Desktop : crash 2-15 s après l'ouverture de la fenêtre (`APPCRASH c0000374`, heap corruption détectée dans ntdll) — absent de v2.0.0, apparu en 2.49.2 | 🟢 corrigé | P1 | 🖥️ desktop | IA | `desktop/src/jumplist.rs` (`set_link_title`) | Installeur 2.49.2 : fenêtre visible quelques secondes puis fermeture (3/3), Event Log Windows `APPCRASH obsigate-desktop.exe … c0000374`, rien dans stderr | `set_link_title` (#77) construisait un `PROPVARIANT VT_LPWSTR` pointant un buffer heap Rust et le confiait au property store du shell, qui le libère avec l'allocateur Windows → corruption du tas ; fonction supprimée (`SetDescription` fournit déjà le libellé) | Bisect 3 états (jumplist off = stable, titre off = stable, d'origine = crash) ; run 9 min sans crash + sortie propre `EXIT=0`, zéro événement WER (avant : 3 crashes ≤20 s) |
+| *BUG-106* | Page blanche sur `/docs` (Swagger UI) : la CSP `script-src` sans `unsafe-inline` (#87 T5c) refuse le script inline d'init de FastAPI, jamais noncé | 🟢 corrigé | P1 | ⚙️ backend | IA | `backend/main.py` (`SecurityHeadersMiddleware`) | Ouvrir `https://og.dracodev.net/docs` : HTML servi (200) mais aucune UI, console `Refused to execute inline script … Content Security Policy` | Injection du nonce dans le HTML de `/docs` et `/redoc` depuis le middleware, via le helper existant `inject_csp_nonce` ; corps décompressé/recompressé (GZipMiddleware est plus proche de la route) | `pytest tests/test_csp_nonce.py` (3 tests ajoutés : nonce sur `/docs`, `/redoc` sans injection, regex sur bundle externe) + 45 passed sur les 3 suites sécurité ; ruff/mypy 0 |
+| *BUG-107* | Drag & drop de fichiers depuis l'Explorateur inutilisable sur desktop : Tauri/wry pose son propre `IDropTarget` par-dessus de celui du WebView2 et aucun événement natif n'est écouté — #89 ne fonctionnait que sur le web | 🟢 corrigé | P1 | 🖥️ desktop | IA | `desktop/tauri.conf.json` (`create: false`), `desktop/src/main.rs` (`WebviewWindowBuilder::…disable_drag_drop_handler`) | App desktop : glisser un fichier de l'Explorateur sur la fenêtre → aucun survol, aucun dépôt — les gestionnaires HTML5 de `dragdrop.js` ne sont jamais déclenchés | Création manuelle de la fenêtre avec `disable_drag_drop_handler()` (doc Tauri : « required to use HTML5 drag and drop APIs on the frontend on Windows ») ; `create: false` évite la double création par la boucle Tauri | `cargo test` 26 passed (nouveau garde-fou `test_window_created_without_tauri_drag_drop_handler` : les deux marqueurs obligatoires) + lancement OK (fenêtre unique, boot normal) ; dépôt réel à valider par l'utilisateur |
+| *BUG-108* | Tableur : le « Coller » du menu contextuel ne fait rien (copier-coller par menu muet) | 🟢 corrigé | P1 | 📱 frontend | IA | `frontend/js/xlsx/context-menu.js` (`closeContextMenu`) | Ouvrir un `.xlsx`, clic droit « Copier » sur une plage, clic droit cible puis « Coller » → rien n'est collé (le menu se ferme sans action) | `closeContextMenu()` retirait le nœud du DOM **avant** de remettre `_menu` à `null` : retirer le menu qui tient le focus émet `focusout` en synchrone, qui rappelle `closeContextMenu()` → second `remove()` sur un nœud déjà démonté → `NotFoundError` qui avorte le handler de l'action « Coller » du viewer. Introduit par #179 (fermeture au focus). Correctif : `_menu = null` avant `menu.remove()` | Reproduit en local sur HEAD (e2e « coller une plage » : attendu `Date`, obtenu la valeur datée) puis vert après fix : E2E `-g "coller une plage"` 1/1, `xlsx-menus` 11/11, `ai-quick-actions` 13/13 |
+| *BUG-109* | Chat : dans la tuile d'une URL (link preview) l'image ne s'affiche jamais | 🟢 corrigé | P2 | ⚙️ backend | IA | `backend/file_chat.py` (`build_preview`, `_proxy_image`) | Poster une URL avec `og:image` dans le chat général → la carte s'affiche mais sans vignette (console : `Refused to load the image … Content Security Policy`) | La CSP de réponse (`img-src 'self' data: blob:`) interdit toute image externe, et les `og:image` **relatives** étaient résolues contre l'origine d'ObsiGate (404). La vignette est désormais **téléversée à l'envoi** dans `chat_uploads` et servie same-origin (`/api/chat/attachment/<uuid>`) : résolution `urljoin` contre la page, garde SSRF réutilisée, plafond 2 Mo, allow-list d'extensions ; échec du téléchargement → carte conservée sans vignette (jamais de message perdu) | Tests `test_preview_image_is_proxied_same_origin` + `test_preview_image_failure_keeps_the_card` (contre-preuve : proxy neutralisé → `image == ""`). Cartes antérieures inchangées : leur URL distante était déjà bloquée |
+| *BUG-111* | Admin : modale « Administration — Utilisateurs » sans icône de fermeture (lucide absent de admin.html) et tableau de bord admin affichant toutes les sections au lieu de la seule section sélectionnée | 2026-10-10 | Utilisateur | `frontend/admin.html` (ajout du script lucide UMD) + `frontend/js/admin.js` (`_wireSectionNav` : show/hide au lieu du scrollspy) ; suites frontend + backend vertes, vérifié sur instance locale 2020 | lucide n'était chargé que dans index.html ; le scrollspy laissait les 4 sections visibles |
+| *BUG-110* | Chat : refonte visuelle des posts — boutons discrets sous l'image, image ouverte dans un onglet de l'app, point de non-lus sur l'icône chat, notification OS hors focus, annulation **réelle** d'une suppression | 🟢 corrigé | P2 | 📱 frontend | IA | `frontend/js/filechat.js`, `frontend/js/ui.js`, `frontend/js/viewer.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/frontend/filechat.test.mjs` | Clic sur une image du chat → ouverture dans un onglet du navigateur au lieu du visualiseur de l'app ; boutons de pièce jointe bavards (icône + libellé) ; aucun repère visuel persistant sur l'icône chat ; aucune alerte OS quand l'app est en arrière-plan ; le bouton « Annuler » d'une suppression ne restaurait rien (copie DOM d'un message déjà supprimé côté serveur) | `TabManager.openChatImage()` (+ branche `chatImage` de `activate()`, `renderImageViewer()` accepte une `url` directe) ouvre la pièce jointe dans un **onglet** avec le visualiseur des images de vault (zoom/pan/plein écran) ; boutons **icônes seules** (24 px, `aria-label`) sous l'image, alignés à droite ; **point rouge pulsant** (`.chat-has-unread`) tant qu'il reste des non-lus, en plus du badge chiffré ; `_notifyNewMessage()` — notification OS si `document.hidden`/hors focus, permission demandée à l'ouverture du chat ; suppression **différée de 10 s** (ligne « Ce message a été supprimé » + « Annuler », DELETE envoyé à l'échéance seulement, échec réseau → le message revient) | Vérifié : `filechat.test.mjs` 25/25 (dont 6 tests #110), `validate-imports` 42 modules / 372 exports 0 erreur, `unit.test.mjs` 13/13 |
+| *BUG-112* | E2E local : `pwsh -File scripts/e2e-server.ps1 2>&1 \| head -n 20` ne se termine **jamais** — la commande semble bloquée des dizaines de minutes alors que le serveur est prêt en ~7 s | 🟢 corrigé | P1 | 🧪 E2E local / Windows | IA | `scripts/e2e-server.ps1` (`start`) | `pwsh -NoProfile -File scripts/e2e-server.ps1 start 2>&1 \| head -n 20` → pipeline ouvert ~500 s+ ; se termine en <2 s dès qu'uvicorn est tué (problème d'EOF du pipe, pas de lenteur du démarrage) | `Start-Process` laissait uvicorn hériter des handles stdout/stderr du pwsh parent → le pipe `\| head` reste ouvert tant que le serveur vit → `head` attend un EOF qui n'arrive jamais. Remplacé par `Win32_Process.Create` (WMI) : processus détaché sans handle hérité ; le processus WMI n'héritant pas de l'environnement, les `OBSIGATE_*` sont passés via `set "NOM=valeur"` dans `cmd /c` (les `""` doublés faisaient échouer le quote-stripping de cmd : forme sans guillemets extérieurs) | Vérifié : commande exacte de l'utilisateur → `real 0m6,883s`, `[OK] READY v2.67.2`, serveur toujours up (2 vaults, 137 fichiers indexés), `stop`/`status` OK, syntaxe PS validée, aucun orphelin |
 |  | | | | | | | | | |
 ### TODOs techniques (améliorations / nouvelles tâches)
 
@@ -288,7 +297,7 @@ Avant de corriger quoi que ce soit, un agent IA doit :
 | 2026-09-17 | BUG-065, #78 (complément) | Correction + feature | `frontend/js/excalidraw-viewer.js`, `frontend/js/utils.js`, `frontend/excalidraw-editor.html`, `tests/frontend/excalidraw-viewer.test.mjs`, `docs/features/excalidraw.md`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md` | **BUG-065** : l'auto-save Excalidraw (débounce 2 s) déclenchait `PUT save` → SSE `index_updated` → `reloadExternalWrite` → `openFile` → recréation de l'iframe = refresh visible pendant le dessin. Auto-save retirée (`excalidraw-viewer.js` : plus de `requestSave`/`saveTimer`), sauvegarde explicite (bouton 💾 / Ctrl+S) ; `reloadExternalWrite` (utils.js) court-circuite le re-rendu si un iframe Excalidraw est ouvert sur ce fichier (attributs `data-excalidraw-vault`/`data-excalidraw-path`) ; le badge « Modified » suit désormais une signature des éléments (`id:versionNonce`) au lieu de tout `onChange` — resize/zoom/plein écran ne marquent plus le fichier modifié. **#78 (complément)** : bouton **plein écran** `#btn-fullscreen` dans la barre d'outils de l'éditeur (`requestFullscreen` sur le document de l'iframe) + iframe créée avec `allow="fullscreen" allowfullscreen`. Vérifié Playwright : bascule plein écran OK (`document.fullscreenElement` true→false), badge non modifié après bascule ; tests statiques `excalidraw-viewer.test.mjs` 12/12, validate-imports 38 modules, unit 9/9. | 🟢 corrigé (en attente vérif utilisateur) |
 | 2026-09-17 | #78 (complément) | UI | `frontend/excalidraw-editor.html`, `docs/features/excalidraw.md`, `CHANGELOG.md` | **#78 (complément)** : la barre d'outils de l'éditeur Excalidraw passe en **colonne d'icônes** (34×34 px, SVG seuls), **collée au bord droit** (`right: 0` ; `top: 45%` ; empilement vertical), avec `title`/`aria-label`. L'icône du bouton Save est remplacée par une coche pendant 1,2 s après une sauvegarde réussie. Badge « Modifié » réduit à une pastille. Vérifié Playwright : bord droit au bord de l'iframe, haut 45 %, 4 boutons empilés ; bascule plein écran OK, cycle d'icône Save + `PUT save` observés. | 🟢 livré (en attente vérif utilisateur) |
 | 2026-09-18 | BUG-066 | Correction | `frontend/locales/fr.json`, `frontend/locales/en.json`, `tests/frontend/unit.test.mjs`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md` | **BUG-066** : la table des matières de la page de configuration n'affichait aucune icône pour « Fichiers cachés » et « Partages publics ». Les libellés du sommaire proviennent de clés i18n (`config.section_hidden`, `config.section_shares`) distinctes des titres de section qui, eux, portaient déjà l'icône. Alignement : 🗂️ / 📤 en FR **et** EN. Test de non-régression : `unit.test.mjs` vérifie que **toutes** les entrées `.help-nav-link` du sommaire portent une icône dans les deux langues (17/17). Vérifié : `unit.test.mjs` 10/10, `validate-imports` 38 modules. | 🟢 corrigé (en attente vérif utilisateur) |
-| 2026-09-18 | #105, BUG-067 | Documentation + correction | `frontend/index.html`, `frontend/js/config.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `backend/guide_export.py`, `backend/main.py`, `tests/test_guide.py`, `docs/features/guide-coverage-105.md`, `CHANGELOG.md`, `docs/ROADMAP.md`, `docs/ISSUES_TODOLIST.md` | **#105** : audit complet de couverture du Guide d'utilisation — 8 nouvelles sections (Architecture + diagramme Mermaid, API & intégrations, Diagrammes Mermaid & Excalidraw, Hors-ligne & synchronisation, Collaboration temps réel, Application desktop, Bibliothèque & signets, Multilingue) et compléments (recherche sémantique, MFA/WebAuthn, notifications push, exports HTML/ePub/ZIP, PDF, vue multi-panneaux, admin). Téléchargement du guide en Markdown et PDF (`GET /api/guide/download?format=md|pdf`, FR/EN, rendu par le moteur d'export existant). Guide plus large en desktop. **BUG-067** : ancre morte `#help-mobile-editor` → section dédiée créée. | 🟢 corrigé (en attente vérif utilisateur)
+| 2026-09-18 | #105, BUG-067 | Documentation + correction | `frontend/index.html`, `frontend/js/config.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `backend/guide_export.py`, `backend/main.py`, `tests/test_guide.py`, `docs/features/guide-coverage-105.md`, `CHANGELOG.md`, `docs/ROADMAP.md`, `docs/ISSUES_TODOLIST.md` | **#105** : audit complet de couverture du Guide d'utilisation — 8 nouvelles sections (Architecture + diagramme Mermaid, API & intégrations, Diagrammes Mermaid & Excalidraw, Hors-ligne & synchronisation, Collaboration temps réel, Application desktop, Bibliothèque & signets, Multilingue) et compléments (recherche sémantique, MFA/WebAuthn, notifications push, exports HTML/ePub/ZIP, PDF, vue multi-panneaux, admin). Téléchargement du guide en Markdown et PDF (`GET /api/guide/download?format=md|pdf`, FR/EN, rendu par le moteur d'export existant). Guide plus large en desktop. **BUG-067** : ancre morte `#help-mobile-editor` → section dédiée créée. | 🟢 corrigé (en attente vérif utilisateur) |
 | 2026-09-18 | #105 (ajustements) | Amélioration | `frontend/index.html`, `frontend/js/config.js`, `frontend/sw.js`, `frontend/locales/{fr,en}.json`, `backend/guide_export.py`, `backend/pdf_export.py`, `Dockerfile`, `scripts/build_guide_diagrams.py`, `scripts/render_guide_diagram.mjs`, `scripts/guide_content.py`, `backend/assets/guide_diagrams/df7366a40db6a5a2.png`, `tests/test_guide.py`, `docs/features/guide-coverage-105.md`, `CHANGELOG.md` | **#105 (retour utilisateur)** : 1) boutons de téléchargement du guide passés en icônes seules (tooltips i18n conservés) ; 2) le diagramme Mermaid de la section Architecture est désormais rendu en **vraie image** dans le PDF (pipeline de pré-rendu PNG Chromium+mermaid v11, PNG commité sous `backend/assets/guide_diagrams/<sha1>.png`, résolu par `diagram_png_for()` ; le Markdown garde le fenced mermaid) ; 3) emoji du PDF rendus **en couleur** au lieu de rectangles : `fonts-noto-color-emoji` ajouté au Dockerfile + `"Noto Color Emoji"` en fin de pile de polices PDF. Vérifié : pytest 1218 (test_guide ×13), ruff/mypy 0, validate-imports 38, unit 10/10 ; PDF live conteneur 2020 : 24 pages, 0 glyphes tofu, diagramme 3568x1174 embarqué. | 🟢 livré
 | 2026-09-22 | BUG-068 | Correction | `backend/auth/router.py`, `backend/requirements.txt`, `frontend/js/auth.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/test_mfa.py`, `tests/frontend/mfa-settings.test.mjs` (nouveau), `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md` | **BUG-068** : section « 🔒 Sécurité du compte » finalisée. (1) Boutons hors thème : `config-btn-primary`/`config-btn-danger` n'existaient pas en CSS → définis depuis les variables du thème (+ états disabled). (2) QR invisible : l'image tierce était bloquée par la CSP (`img-src 'self' data: blob:`) et exposait le secret TOTP → QR SVG `data:` généré en local par le backend (`qr_data_url`, segno) avec repli saisie manuelle. (3) Codes de récupération perdus à la 1re activation WebAuthn → `_showRecoveryCodes(codes, targetId)` avec repli `webauthn-flow-area`. (4) Carte « Mot de passe » ajoutée (endpoint `change-password` existant, jusque-là sans UI) + échappement des libellés de clés WebAuthn. Vérifié : pytest 1241 passed / 6 skipped, ruff 0, mypy 0 (78 fichiers), `mfa-settings.test.mjs` 9/9, unit 10/10, validate-imports 39 modules. | 🟢 corrigé (en attente vérif utilisateur) |
 | 2026-09-23 | BUG-069 | Correction | `frontend/js/auth.js`, `frontend/locales/{fr,en}.json`, `tests/frontend/mfa-settings.test.mjs`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md` | **BUG-069** : login 2FA bloqué sans erreur — après user+pwd corrects, `showMfaChallenge` cherchait `.login-box` (inexistant dans `index.html`, marquage réel `#login-screen > .login-card`) et faisait un `return` silencieux : page de login figée, aucune erreur. Correctif : montage dans `.login-card` (repli `#login-screen`) + erreur visible `mfa.challenge_unavailable` (FR/EN) si le point de montage manque. **Reproduit au navigateur** (Playwright, instance Docker `obsigate-test`, compte jetable avec TOTP) : avant → challenge jamais affiché ; après → challenge affiché, code erroné → erreur, code valide (verify 200) → app. Tests : `mfa-settings.test.mjs` 11/11 (+2 ancrage DOM), unit 10/10, validate-imports 39 modules. | 🟢 corrigé (en attente vérif utilisateur) |
@@ -318,6 +327,27 @@ Avant de corriger quoi que ce soit, un agent IA doit :
 | 2026-10-02 | BUG-101 | Correction | `frontend/js/ui.js` | **BUG-101 — le bloc « Keyboard shortcuts for tabs » existait en double dans `ui.js`** (fin de fichier) : un seul `Ctrl+W` déclenchait **deux** `close()`, le second refermant l'onglet ré-activé par le premier — observé avec #158 quand un onglet navigation survit à la fermeture du fichier ; `Ctrl+Tab` sautait également un onglet. Bloc dupliqué supprimé (un seul listener). Vérifié : repro Playwright (`close()` appelé 2× puis 1×) et suite E2E. | 🟢 corrigé (en attente vérif utilisateur) |
 | 2026-10-02 | BUG-102 | Correction | `frontend/js/ui.js` | **BUG-102 — menu contextuel refermé par sa propre ouverture** : la reflow des icônes lucide à l'affichage déclenche un `scroll` capturé qui refermait le menu ~10 ms après son apparition (constaté sur les fichiers de la page de navigation, #158 A5). `show()` mémorise `_shownAt` et le listener `scroll` ignore un déclenchement dans les 250 ms. Vérifié : instrumentation Playwright + suite E2E (`nav-tab.spec.js`). | 🟢 corrigé (en attente vérif utilisateur) |
 | 2026-10-02 | BUG-103 | Correction | `frontend/style.css` | **BUG-103 — sidebar mobile sous la barre d'outils du bas** : en mobile le `.sidebar` (`z-index: 200`) passait sous `.mobile-toolbar` (`z-index: 900`, 64 px de haut), masquant les dernières entrées de l'arbre ; passé à `950`. Vérifié : `elementFromPoint` Playwright (393×851) + test source `mobile sidebar over toolbar` (`unit.test.mjs`). | 🟢 corrigé |
+| 2026-10-02 | BUG-104 | Correction | `desktop/permissions/commands.toml` (nouveau), `desktop/capabilities/default.json`, `desktop/build.rs` | **BUG-104 — commandes Tauri rejetées par l'ACL depuis la page backend** : la fenêtre redirige vers `http://127.0.0.1:<port>`, origine *remote* pour Tauri v2, et aucune commande applicative n'était déclarée → `Command … not allowed by ACL` sur `pick_vault_folder`, `get_wizard_state`, etc. ; les erreurs sont avalées par `desktop.js:invoke()` → bouton du wizard silencieusement inopérant depuis #77. Correctif : manifeste `desktop/permissions/commands.toml` (`allow-app-commands`, 19 commandes) référencé par la capability + `rerun-if-changed=permissions` dans `build.rs`. Vérifié : `cargo test` 25 passed (nouveau garde-fou ACL), CDP live : `get_version` OK, clic → fenêtre native « Select Folder », ajout de vault complété de bout en bout. | 🟢 corrigé |
+| 2026-10-02 | BUG-105 | Correction | `desktop/src/jumplist.rs` | **BUG-105 — crash heap (c0000374) à l'ouverture du desktop** : `set_link_title` (#77) passait un `PROPVARIANT VT_LPWSTR` pointant un buffer heap Rust au property store du shell, qui le libère avec l'allocateur Windows → `STATUS_HEAP_CORRUPTION` détectée dans ntdll ≤20 s après le lancement (3/3, Event Log WER, même empreinte de pile). Fonction supprimée : le libellé des entrées vient de `SetDescription`. Vérifié : bisect sur 3 états de build, run 9 min `EXIT=0`, zéro événement WER. | 🟢 corrigé |
+| 2026-10-02 | BUG-106 | Correction | `backend/main.py`, `tests/test_csp_nonce.py` | **BUG-106 — page blanche sur /docs** : la CSP `#87 T5c` (`script-src` sans `unsafe-inline`, nonce frais par réponse) s'applique aussi aux pages générées par FastAPI (`/docs`, `/redoc`) dont le balisage n'est jamais passé par `inject_csp_nonce` → le navigateur refusait le script inline `SwaggerUIBundle(…)`, la div restait vide. `SecurityHeadersMiddleware` injecte désormais le nonce dans ce HTML avec le helper existant ; le corps est décompressé/recompressé car `SSESafeGZipMiddleware` est plus proche de la route (les réponses arrivent gunzippées). `/redoc` n'a aucun script inline (bundle jsdelivr seul, couvert par `script-src`) — vérifié tel quel. Vérifié : `test_docs_inline_script_nonced`, `test_redoc_served_with_csp`, `test_docs_external_bundle_not_nonced` + 45 passed sur les 3 suites sécurité, ruff/mypy 0. | 🟢 corrigé |
+| 2026-10-02 | BUG-107 | Correction | `desktop/tauri.conf.json`, `desktop/src/main.rs` | **BUG-107 — drag & drop de fichiers inutilisable sur desktop** : Tauri/wry installe son propre `IDropTarget` par-dessus de celui du WebView2 (source wry : « Enumerate child windows to find the WebView2 window and override! ») et aucun événement natif n'était écouté → les glisser-déposer depuis l'Explorateur n'atteignaient jamais les gestionnaires HTML5 de `dragdrop.js` (#89 marchait donc uniquement sur le web). Correctif : la doc Tauri est explicite — `disable_drag_drop_handler()` « is required to use HTML5 drag and drop APIs on the frontend on Windows » ; la fenêtre est créée en code (`create: false` dans `tauri.conf.json`, boucle Tauri qui saute les fenêtres non auto-créées) via `WebviewWindowBuilder::from_config(...).disable_drag_drop_handler()`. Vérifié : `cargo test` 26 passed (nouveau garde-fou `test_window_created_without_tauri_drag_drop_handler` : les deux marqueurs obligatoires), lancement de l'app OK (fenêtre unique, boot log normal) ; glisser-déposer réel à valider par l'utilisateur. | 🟢 corrigé |
+| 2026-10-07 | BUG-108 | Correction | `frontend/js/xlsx/context-menu.js` | **BUG-108 — « Coller » du menu contextuel du tableur muet** : `closeContextMenu()` faisait `menu.remove()` **avant** `_menu = null` ; retirer le menu portant le focus émet `focusout` synchrone qui rappelle `closeContextMenu()`, le second `remove()` sur un nœud démonté lève `NotFoundError` et avorte le handler de l'action avant son exécution (introduit par la fermeture au focus #179). Reproduit par l'E2E `xlsx-viewer.spec.js` « coller une plage » (CI #850→#854). Correctif : déférencer avant de retirer. | 🟢 corrigé |
+| 2026-10-08 | #189 | Fonctionnalité | `frontend/js/viewer.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/frontend/xlsx-viewer.test.mjs`, `tests/e2e/xlsx-viewer.spec.js`, `docs/ROADMAP.md`, `docs/features/xlsx-mobile-layout-189.md`, `docs/GUIDES/RECHERCHE_PDF_EXCALIDRAW.md`, `README.md`, `README.fr.md`, `CHANGELOG.md` | **#189 — mise en page mobile du tableur** : sur ≤ 768 px les barres menus/ruban/Recherche sont repliées par défaut (la barre des feuilles + barre formule fx restent visibles, la grille récupère la hauteur perdue), bascule unique `#xlsx-tools-toggle` (☰, `aria-expanded`), cibles tactiles ≥ 44 px, groupes du ruban qui s'enroulent, onglets de feuilles défilants, inputs 16 px (anti-zoom iOS). E2E mobile ajouté + helper `openXlsx()` (déplie le ruban). 10 échecs E2E mobile **préexistants** prouvés par `git stash` (hors périmètre, CI ne lance que desktop). Vérifié : xlsx-viewer.test.mjs 165/165, E2E desktop 19 passed/1 skipped, suite 1628 passed, ruff/mypy 0, CI run #1937 success | ✅ livré (en attente vérif utilisateur) |
+| 2026-10-08 | #191 | Fonctionnalité | `backend/file_chat.py`, `backend/routers/file_chat.py`, `backend/schemas.py`, `frontend/js/filechat.js`, `frontend/js/sync.js`, `frontend/index.html`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/test_file_chat.py`, `tests/frontend/filechat.test.mjs`, `docs/ROADMAP.md`, `docs/features/file-chat-169.md`, `CHANGELOG.md` | **#191 — chat : suppression de post, messages privés, boîte compacte, link preview** : (A) `DELETE /api/chat/{id}` + `/api/chat/dm/{peer}/{id}` (auteur ou admin, 403 sinon) avec diffusion SSE `chat_deleted` et bouton 🗑 au survol côté client (`confirm()` natif) ; (B) DM 2 utilisateurs : vault `__dm__` + `dm_path(a,b)` trié, `GET /api/chat/users` (destinataires sans soi-même, aucun hash exposé), routes `GET/POST /api/chat/dm/{user}` (404 inconnu, 400 DM à soi), rangée de canaux `.chat-channels` dans la sidebar, non-lus par canal (compteurs localStorage, anciens timestamps/compteurs mélangés unifiés) ; (C) bouton d'envoi réduit à une icône dans les deux formulaires ; (D) `build_preview(text)` : 1ʳᵉ URL → garde SSRF `_assert_public_http_url` → `httpx.get` 5 s/512 Ko → OG (titre/desc/image/site) en carte cliquable, best-effort (échec → message sans carte), cache 200 entrées. Bug trouvé en cours de route : `max_redirects` n'existe pas sur `httpx.get` → TypeError avalé par le `try` = previews jamais générées en prod, invisible des tests (ils mockaient `build_preview`) ; arg retiré + `test_build_preview_happy_path_parses_og` (httpx mocké) ajouté. Tests : pytest 45 file_chat (44→45, +13 sur #191), JSDOM filechat 16 (+5) | 
+| 2026-10-08 | #190 | Fonctionnalité | `backend/file_chat.py`, `backend/routers/file_chat.py`, `backend/schemas.py`, `frontend/js/filechat.js` (réécrit), `frontend/js/viewer.js`, `frontend/js/config.js`, `frontend/js/sidebar.js`, `frontend/js/app.js`, `frontend/index.html`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/test_file_chat.py`, `tests/frontend/filechat.test.mjs`, `docs/ROADMAP.md`, `CHANGELOG.md` | **#190 — chat : suivi du document, chat général en onglet sidebar, onglets au-dessus du filtre** : (A) l'en-tête du panneau affiche le document ciblé (titre + chemin) et `followFileChat()` appelé par `renderFile()` re-cible le panneau ouvert à chaque changement de document ; (B) onglet **Chat** (dernier) → conversation générale stockée dans le même store #169 via les sentinelles `__global__/general` (`GET/POST /api/chat`), **pastille de messages non lus** (`localStorage` + badge sur l'onglet), **pièces jointes image/vidéo** (`POST /api/chat/upload` : allow-list d'extensions, 25 MB, nom UUID — jamais le nom client ; `GET /api/chat/attachment/{name}` résolu contre l'allow-list), **URL cliquables** dans le rendu (linkification `http(s)://`), date/heure d'envoi ; (C) barre de filtre **déplacée sous les onglets** et routée vers `filterChatMessages()` (texte + auteur) quand l'onglet Chat est actif. Transport : broadcast SSE `chat_message` réutilisé (vault `__global__` route vers le panneau sidebar, sinon panneau fichier) — pas de second WebSocket. Contre-preuves : `__global__` non routé → test « routes __global__ » échoue ; panneau sans classe `active` → le message part en toast au lieu du rendu (révélé par le stub JSDOM). Vérifié : pytest **1655 passed / 2 skipped** (27 tests chat dont 12 nouveaux), ruff 0, mypy 0 (113 fichiers), validate-imports 42 modules/368 exports, unit 13/13, filechat.test.mjs **11/11** (5 nouveaux), toolbar-order, sidebar-filters 8/8 | ✅ livré (en attente vérif utilisateur) |
+| 2026-10-08 | #169 | Fonctionnalité | `backend/file_chat.py` (nouveau), `backend/routers/file_chat.py` (nouveau), `backend/schemas.py`, `backend/main.py`, `frontend/js/filechat.js` (nouveau), `frontend/js/viewer.js`, `frontend/js/sync.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/test_file_chat.py` (nouveau), `tests/frontend/filechat.test.mjs` (nouveau), `tests/frontend/toolbar-order.test.mjs`, `.gitea/workflows/ci.yml`, `docs/ROADMAP.md`, `docs/features/file-chat-169.md` (nouveau), `docs/GUIDES/PRISE_EN_MAIN.md`, `CHANGELOG.md` | **#169 — chat intégré par fichier** : store JSON par (vault, path) sous `data/chats/` (nom SHA-256 → traversal impossible, plafond 500 msgs, texte 4000 car., écriture atomique, fichier corrompu → vide) ; `GET/POST /api/file/{vault}/chat` (auth + `check_vault_access` + `resolve_safe_path`, 400/404/403, `response_model`) + broadcast SSE `chat_message` sur le transport #62 (**pas de 2ᵉ WebSocket**) ; panneau latéral `filechat.js` (bouton 💬 toolbar, rendu chronologique `textContent`, envoi optimiste + dédup par id, toast si panneau fermé/autre fichier, plein écran ≤ 768 px) ; relais SSE en import dynamique dans `sync.js` ; i18n FR/EN 10 clés `chat.*`. En route : tag OpenAPI maison `file-chat` non déclaré → `test_used_tags_are_declared` rouge (retiré, dérivé « Files »), regex navBtns de `toolbar-order.test.mjs` (échappements → `includes`), ruff UP012/TRY004/I001. Vérifié : `test_file_chat.py` 15 passed, `filechat.test.mjs` 6/6, suite 1643 passed, ruff/mypy 0, validate-imports 42 modules, CI run #1938 5/5 success (v2.57.0) | ✅ livré (en attente vérif utilisateur) |
+| 2026-10-08 | #192 + BUG-109 | Fonctionnalité + correction | `backend/file_chat.py`, `backend/routers/file_chat.py`, `backend/schemas.py`, `frontend/js/filechat.js`, `frontend/js/sync.js`, `frontend/index.html`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/test_file_chat.py`, `tests/frontend/filechat.test.mjs`, `docs/ROADMAP.md`, `docs/features/file-chat-169.md`, `CHANGELOG.md` | **#192 — chat : saisie auto-agrandissante + accusé de réception.** La boîte d'envoi (panneau document **et** sidebar) devient un `textarea` dont la hauteur suit le contenu (plafond 160 px puis défilement, repasse à 1 ligne après l'envoi), `Entrée` envoie / `Maj+Entrée` saute une ligne ; placeholder sidebar désormais traduit à l'init. **Accusé de réception** : chaque document de conversation porte `read = {utilisateur: ts}` (verrou global sur le read-modify-write — une lecture ne peut plus faire disparaître un message), `GET` d'historique renvoie la carte, nouveau `POST /api/chat/read` (400 sans vault/path, 403 DM hors pair, ACL vault pour un chat de fichier) marque la lecture et diffuse `chat_read` en SSE ; côté client `✓` envoyé / `✓✓` lu sur **mes** messages (exclut ma propre carte de lecture), bascule en direct via `onChatRead()` + toast « {user} a lu votre message », accusé émis à l'ouverture d'une conversation et à la réception d'un message déjà affiché. **BUG-109** : la vignette des tuiles de lien ne s'affichait jamais (CSP `img-src 'self'` + `og:image` relative résolue contre ObsiGate) → `_proxy_image()` téléverse l'image dans `chat_uploads` (same-origin, `urljoin` contre la page, garde SSRF, 2 Mo max, allow-list) et la carte reste affichée si le téléchargement échoue. Tests : pytest `test_file_chat.py` 45→**54** (`TestReadReceipts` 7, proxy image 2, 2 assertions de réponse adaptées), JSDOM `filechat.test.mjs` 16→**19** ; ruff 0, mypy 0 (113 fichiers), validate-imports 42/371, unit 13/13 | ✅ livré (en attente vérif utilisateur) |
+| 2026-10-10 | BUG-111 | Correction UI admin | `frontend/admin.html`, `frontend/js/admin.js`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md` | **BUG-111** : (1) la modale « Administration — Utilisateurs » ouverte depuis `/admin` n'affichait pas l'icône du bouton fermer — `safeCreateIcons()` retourne immédiatement car le global `lucide` n'existe pas sur `admin.html` (script UMD absent — seul index.html le chargeait) ; ajout du même `<script defer>` lucide@0.344.0. (2) Le tableau de bord admin affichait les 4 sections d'un coup (scrollspy) — `_wireSectionNav` masque désormais toutes les sections sauf celle cliquée (état initial : hash de l'URL ou section Stats). Vérifié : 1705 passed, suites frontend vertes, instance docker locale 2020. | 🟢 corrigé (en attente vérif utilisateur) |
+| 2026-10-09 | BUG-110 | Correction + refonte UI chat | `frontend/js/filechat.js`, `frontend/js/ui.js`, `frontend/js/viewer.js`, `frontend/style.css`, `frontend/locales/{fr,en}.json`, `tests/frontend/filechat.test.mjs`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md` | **BUG-110 — refonte visuelle du chat** : (1) les boutons de pièce jointe deviennent des **icônes seules** (24 px, `aria-label`) rangées **sous l'image, alignées à droite** — plus de gros boutons à libellé ; (2) le clic sur une image ouvre le **même visualiseur que pour une image de vault** (zoom/pan/plein écran) mais dans un **onglet de l'app** (`TabManager.openChatImage()`, branche `chatImage` de `activate()`, `renderImageViewer()` accepte désormais une `url` directe : une pièce jointe n'est pas dans un vault) au lieu d'un onglet du navigateur ; (3) **point rouge pulsant sur l'icône chat** de la sidebar tant qu'il reste des non-lus (classe `chat-has-unread`, en plus du badge chiffré) ; (4) **notification OS** (`Notification`) quand l'app n'est pas au premier plan (`document.hidden`/hors focus), permission demandée au premier clic d'ouverture du chat ; (5) la suppression n'est plus mensongère : le `DELETE` est **différé de 10 s**, la ligne passe à « Ce message a été supprimé » avec « Annuler » — annuler réarme le message (l'ancien code restaurait une copie DOM d'un message déjà détruit côté serveur en affichant « Message restauré ») ; échec réseau → le message revient. Vérifié : `filechat.test.mjs` 25/25 (dont 6 tests #110 : icônes seules, clic image → `openChatImage`, aucun `DELETE` pendant la fenêtre d'annulation, notification OS), `validate-imports` 42 modules / 372 exports 0 erreur, `unit.test.mjs` 13/13 | 🟢 corrigé (en attente vérif utilisateur) |
+
+| 2026-10-09 | #193 | Fonctionnalité | `backend/file_chat.py`, `backend/schemas.py`, `frontend/js/filechat.js`, `frontend/style.css`, `tests/test_file_chat.py`, `tests/frontend/filechat.test.mjs`, `docs/features/file-chat-169.md`, `CHANGELOG.md` | **#193 — un post du chat s'affiche comme un document markdown** : le serveur rend le texte de chaque message avec le **pipeline des documents** (`backend/render.py::_render_markdown` : mistune — tableaux, listes de tâches, notes —, wikilinks, masquage des secrets #188, **sanitizer BUG-021**) et le renvoie dans un champ `html` (ajouté à `ChatMessageItem`, sinon `response_model` le filtrait). Le rendu est calculé **à la lecture** (`get_messages`) et à l'ajout (`_append`) — il n'est donc **jamais persisté** dans `data/chats/*.json` — et l'écho SSE part avec : les autres clients voient le rendu sans refresh. Côté front, `_fillBody()` injecte le HTML dans un `<div class="md-content">` puis appelle `safeHighlight()` sur chaque `pre code` (highlight.js + alias de langages, exactement comme le viewer ; mermaid non déclenché). Repli intact si `html` manque (écho optimiste → texte brut + URL cliquable) et un échec de rendu n'emporte jamais le message. CSS : `.file-chat-md` annule le `pre-wrap` hérité de la bulle (les retours à la ligne du HTML source produisaient des lignes vides) et compacte `.md-content` (`pre`/`table` en `overflow-x: auto`). Vérifié : `test_file_chat.py` 54→**61** (`TestMarkdownRendering` ×7 : html à l'ajout et à la lecture, **absent du JSON**, classe `language-xxx`, listes, `<script>` neutralisé, routes POST/GET, broadcast SSE), `filechat.test.mjs` 25→**27**, suite 1689 passed, ruff 0, mypy 0 (113 fichiers), validate-imports 42 modules / 372 exports | ✅ livré (en attente vérif utilisateur) |
+
+| 2026-10-09 | #194 | Fonctionnalité | `backend/user_home.py` (nouveau), `backend/indexer.py`, `backend/auth/router.py`, `backend/routers/vaults.py`, `backend/main.py`, `docker-compose.yml`, `tests/test_user_home.py` (nouveau), `tests/test_auth_api.py`, `docs/features/user-home-194.md` (nouveau), `docs/ROADMAP.md`, `CHANGELOG.md`, `README.md`, `README.fr.md` | **#194 — dossier personnel par utilisateur** : chaque compte reçoit `<OBSIGATE_HOME_ROOT>/<user>` monté comme vault propre `home-<user>` (option A validée) — l'isolation s'appuie sur l'ACL par vault **existante** (`check_vault_access`), aucune ACL par chemin inventée. `backend/user_home.py` : `ensure_user_home()` idempotent (mkdir → `add_vault_to_index` → `persist_vault` → watcher → SSE → octroi dans `user.vaults`) appelé à `POST /api/auth/admin/users` **et** au démarrage (`ensure_all_user_homes()` : migration des users existants, réparation des dossiers/registres manquants, sweep des vaults `home-*` orphelins dont l'utilisateur a disparu hors route — garde `Path.parent == racine` pour ne jamais toucher à un vault admin homonyme) ; `release_user_home()` à la suppression (index/watcher/registre refermés, **dossier conservé**). **Blocage levé** : registre persistant `data/vaults.json` fusionné par `load_vault_config()` — avant, tout vault ajouté à la volée (`/api/vaults/add`) disparaissait au premier reindex complet et au redémarrage. Correctif au passage : `reload_single_vault()` remet `vault_config[name]` après `remove_vault_from_index()`. Réponse du POST = vaults réactualisés (l'instantané de `create_user` était antérieur à l'octroi). Déploiement : montage unique `/NFS/OBSIDIAN_DOC/Home:/vaults/Home` + `OBSIGATE_HOME_ROOT` (absente = feature inactive, dev/tests/desktop inchangés). Vérifié : `test_user_home.py` 12/12 (création, idempotence, username invalide, persistance après `load_vault_config`, retrait, isolation `check_vault_access`, orphelins), `test_auth_api.py::TestUserHome` 2/2, suite **1703 passed / 2 skipped**, ruff backend 0, mypy 114 fichiers 0, `validate-imports` 42 modules / 372 exports, `unit.test.mjs` 13/13 | ✅ livré (en attente vérif utilisateur) |
+
+| 2026-10-09 | #194 | Fonctionnalité (UI) | `frontend/js/sidebar.js`, `frontend/js/viewer.js`, `docker-compose.test-win.yml`, `.gitignore`, `tests/frontend/sidebar-filters.test.mjs`, `docs/ROADMAP.md`, `docs/features/user-home-194.md`, `CHANGELOG.md` | **#194 (incrément UI)** : les vaults `home-<user>` s'affichent **en premier** dans l'arborescence de la sidebar — tri stable appliqué à la source (`_homeFirst` dans `loadVaults()` et dans le soft-refresh, donc `state.allVaults`, l'arborescence et les sélecteurs restent cohérents) — et portent l'icône **maison** lucide (`data-lucide="home"` via `getVaultIcon`, même `safeCreateIcons`/`stroke: currentColor` que les autres icônes, thème-aware). Compose de test : `test_home:/vaults/Home` + `OBSIGATE_HOME_ROOT=/vaults/Home` (dossier `test_home/` ignoré par git). Vérifié : `sidebar-filters.test.mjs` 8→**10/10**, `validate-imports` 42 modules / 372 exports, `unit.test.mjs` 13/13, suites voisines (ai-sidebar, toolbar-order, search-facets, pane-manager, editor-inline) vertes, **live Playwright sur l'instance 2020** : ordre `home-admin, home-bruno, TestDir, TestVault` + `svg.lucide-home` rendu (placeholder `<i>` remplacé) | ✅ livré (en attente vérif utilisateur) |
+
+| 2026-10-14 | BUG-112 | Correction | `scripts/e2e-server.ps1`, `docs/ISSUES_TODOLIST.md`, `CHANGELOG.md` | **BUG-112 — `pwsh -File scripts/e2e-server.ps1 2>&1 \| head -n 20` ne se termine jamais.** Constat : le démarrage n'est pas lent (~7 s, READY, health 200, 137 fichiers indexés) — c'est le pipe qui ne reçoit jamais d'EOF. Preuve : le pipeline survit 494 s+ puis se termine en <2 s dès qu'uvicorn est tué. Cause : `Start-Process` laisse l'enfant hériter des handles stdout/stderr du pwsh parent ; le serveur (immortel par design) maintient le pipe ouvert → `head` attend un EOF qui n'arrivera jamais. Correctif : `Win32_Process.Create` (WMI) lance uvicorn détaché sans handle hérité ; le processus WMI n'héritant pas de l'environnement, les `OBSIGATE_*` sont passés via `set "NOM=valeur"` dans `cmd /c` (les `""` doublés faisaient échouer le quote-stripping de cmd : forme sans guillemets extérieurs). Vérifié : commande exacte de l'utilisateur → `real 0m6,883s`, `[OK] READY v2.67.2`, serveur toujours up (2 vaults, 137 fichiers), `stop`/`status` OK, syntaxe PS validée, aucun orphelin | 🟢 corrigé (en attente vérif utilisateur) |
+| 2026-10-09 | #194 | Correction (isolation) | `backend/auth/middleware.py`, `backend/services/recent.py`, `backend/services/search.py`, `backend/routers/search.py`, `backend/routers/config.py`, `backend/routers/conflicts.py`, `backend/routers/files_read.py`, `backend/routers/history.py`, `backend/push.py`, `backend/user_home.py`, `tests/test_user_home.py`, `tests/test_auth_api.py`, `docs/features/user-home-194.md`, `CHANGELOG.md` | **#194 — l'admin voyait le home de chaque utilisateur** (retour utilisateur) : `vaults: ["*"]` ouvrait **tous** les vaults, donc `home-<user>` compris. Correctif à la racine : `check_vault_access` exige un octroi **explicite** pour tout vault `home-*` (nouveau `is_home_vault()`), et les filtres « * » écrits en dur dans les routes ont été remplacés par cet appel unique — dashboard (`routers/config.py`), conflits, liens retour, favoris, abonnements push (`/api/search/replace` utilisait déjà `is_vault_allowed`). `/api/search` filtre désormais les bruts **avant** pagination via `search_vaults(is_allowed=…)` (sinon notes personnelles d'un autre compte dans les résultats). `_grant` n'écarte plus les comptes « * » → l'admin reçoit son propre `home-admin` (auto-réparé au démarrage). Vérifié : `test_user_home.py` 12→**14/14** (dont « * » sans homes + filtrage recherche), `test_auth_api.py` 2/2 (admin ne voit **plus** `home-alice`, alice voit le sien), suite **1705 passed / 2 skipped**, ruff backend 0, mypy 114 fichiers 0, **live Playwright instance 2020** : arborescence admin = `home-admin, TestDir, TestVault` (plus de `home-bruno`), `svg.lucide-home` rendu. Reste ouvert (fuite pré-existante, hors périmètre) : `/api/search/advanced`, `/api/tags`, `/api/tags/suggest`, `/api/tree-search`, `/api/suggest` ne filtrent pas par vault accessible | ✅ livré (en attente vérif utilisateur) |
 
 ---
 

docs/ROADMAP.md

@@ -1,6 +1,6 @@
 # ObsiGate — Roadmap
 
-> **Version :** 2.49.2 | **Dernière mise à jour :** 2026-10-02
+> **Version :** 2.68.1 | **Dernière mise à jour :** 2026-10-14
 > **Ce fichier ne contient que le travail à venir** (🔵 En cours + ⚪ Backlog) et un index compact
 > vers les fonctionnalités livrées.
 > - **Méthode de livraison à appliquer pour toute tâche : [DELIVERY_WORKFLOW.md](./DELIVERY_WORKFLOW.md)**
@@ -30,6 +30,133 @@
 
 ## 🔵 En cours
 
+### 196. Partage dirigé entre utilisateurs (document → utilisateur)
+
+- **Effort :** 0,5-1 jour | **Impact :** 🟡 | **Ouvert :** 2026-10-10 | **Statut :** ✅ livré le 2026-10-10
+- **Fiche :** [features/directed-shares-196.md](./features/directed-shares-196.md)
+- **Description :** un utilisateur peut partager un document à un ou plusieurs
+  autres comptes (pas un lien public) : les pages `/s/{token}` exigent alors
+  une session et n'acceptent que créateur + admin + destinataires (404 sinon,
+  pas de fuite d'existence). Vue « partagé avec moi » dans le dashboard,
+  destinataires listés dans le dialogue de partage, révocabilité réservée au
+  créateur/admin, `GET /api/shares` scopé (un non-admin ne voit que ses
+  partages créés/reçus — corrige une fuite préexistante). Rétrocompatible :
+  les partages publics existants restent anonymes.
+- **Sous-tâches :**
+  - [x] Store `shared_with` + validation des destinataires à la création
+  - [x] Gate auth+appartenance sur `/s/{token}` (+`/pdf`, `/raw`) — 404 opaque
+  - [x] Scope de `GET /api/shares` ; révocation créateur/admin uniquement
+  - [x] UI : dialogue dirigé/public + destinataires, dashboard « partagé par X »
+  - [x] i18n FR/EN, tests `test_directed_shares.py` (9), fiche feature
+  - [x] **Itération 2 (2026-10-11)** : icône « partagé » (share-2 bleu) sur les
+        fichiers porteurs d'un partage actif dans l'arborescence ; dossier
+        virtuel **Partage** à la racine du home du destinataire (fichiers reçus,
+        ouverture lecture seule `/s/{token}`) ; les documents reçus sont
+        **cherchables** (merge dans `search_vaults`, résultats
+        `home-<user>/Partage/…` avec `share_token`, clic → page de partage —
+        jamais l'éditeur du vault d'autrui) ; cache front invalidé à la
+        création/révocation. +2 tests (recherche trouvée par le destinataire,
+        aucune fuite vers un non-destinataire).
+  - [x] **Itération 3 (2026-10-11)** : le dossier Partage ne déclenche plus la
+        navigation (dossier virtuel — corrige « Directory not found: Partage ») ;
+        un fichier reçu s'ouvre **dans l'application en onglet** (arbre,
+        recherche, dashboard) via la résolution serveur
+        `home-<user>/Partage/<fichier>` → fichier source dans `/api/file`
+        (+ raw, download) ; validation `path` non-nulle à la création d'un
+        partage. +2 tests.
+  - [x] **Itération 4 (2026-10-11)** : le partage dirigé EST l'autorisation —
+        la résolution `Partage/…` court-circuite l'ACL du vault source (fix
+        « Accès refusé à la vault … » : le destinataire n'a par définition
+        pas accès au vault de l'émetteur) ; chemin virtuel canonique
+        `Partage/<token>/<nom>` (lève l'ambiguïté de fichiers homonymes,
+        fallback par nom conservé) ; « reçu » = adressé à moi (un admin ne
+        voit plus les partages d'autres comptes comme reçus — fix 404
+        « File not found: Partage/… »). +3 tests.
+
+### 194. Dossier personnel par utilisateur (`<racine>/Home/<user>`)
+
+- **Effort :** 1-2 jours | **Impact :** 🟡 | **Ouvert :** 2026-10-09 | **Statut :** 🔵 en cours
+- **Cadrage :** chaque utilisateur créé reçoit un dossier personnel monté en vault propre
+  (`home-<user>`), isolé par l'ACL par vault existante — pas d'ACL par chemin à inventer.
+- **Décisions validées :** option A (un vault par utilisateur), nom `home-<user>`,
+  dossier **conservé** à la suppression du compte, racine `/NFS/OBSIDIAN_DOC/Home`
+  (montée `/vaults/Home`, exposée par `OBSIGATE_HOME_ROOT`).
+- **Sous-tâches :**
+  - [x] ID stable créé (avant codage, AGENTS.md)
+  - [x] Registre persistant des vaults dynamiques `data/vaults.json` (les vaults ajoutés à la
+        volée sont aujourd'hui perdus au redémarrage / reindex — `load_vault_config` ne lit
+        que les env `VAULT_N_*`)
+  - [x] Service `ensure_user_home()` idempotent : mkdir + vault + octroi, appelé à la création
+        d'un user et au démarrage (réparation/migration)
+  - [x] Retrait au suppression de compte (index/watcher/registre) sans supprimer le dossier
+  - [x] Montage Docker + `OBSIGATE_HOME_ROOT` (prod **et** compose de test
+        `docker-compose.test-win.yml` → `test_home:/vaults/Home`)
+  - [x] UI : vaults `home-*` en **premier** dans l'arborescence + icône maison
+        lucide (`getVaultIcon`), vérifié live sur l'instance 2020
+  - [x] Isolation : « * » (admin) ne couvre **plus** les dossiers persos —
+        `check_vault_access` + filtres des routes + `/api/search` (avant
+        pagination) ; octroi du home aussi aux comptes « * »
+  - [x] Tests (création, persistance après rebuild, isolation 403 entre users) + docs
+
+---
+
+### 197. Listes de fichiers : `mtime` + `size` pour réconciliation externe (TikTak, Gitea #4)
+
+- **Effort :** 0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-10-14 | **Statut :** ✅ livré le 2026-10-14
+- **Fiche :** [features/tiktak-integration-197-200.md](./features/tiktak-integration-197-200.md)
+- **Description :** un client de synchro doit détecter les fichiers modifiés en **un
+  seul appel de liste**, sans relire chaque fichier. `GET /api/vault/{vault}/paths`
+  n'exposait que `vault/path/name/type`.
+- **Sous-tâches :**
+  - [x] `/paths` : `size`/`mtime`/`mtime_iso` par fichier (index, même contrat que
+        `list_all_files`) ; `None` sur les répertoires
+  - [x] `/browse` : `modified`/`modified_iso` ; outil MCP `list_directory` : `size`/`mtime`
+  - [x] Cohérence read-after-write : `PUT …/save` rafraîchit l'index en synchrone
+  - [x] Bug latent corrigé : `update_single_file`/`remove_single_file` exigeaient un
+        absolu mais recevaient un relatif (no-op silencieux) — acceptent les deux
+  - [x] Tests `tests/test_sync_lists.py` (7 : métadonnées + scénario de réconciliation)
+
+### 198. Webhooks : `vault` dans la charge + filtre `vault` / `path_prefix` (TikTak, Gitea #3)
+
+- **Effort :** 0,5-1 jour | **Impact :** 🟡 | **Ouvert :** 2026-10-14 | **Statut :** ✅ livré le 2026-10-14
+- **Fiche :** [features/tiktak-integration-197-200.md](./features/tiktak-integration-197-200.md)
+- **Description :** un consommateur externe (retours de synchro TikTak, phase 3) recevait
+  tout, de tous les vaults, sans pouvoir filtrer.
+- **Sous-tâches :**
+  - [x] Filtres optionnels `vault` (exact) + `path_prefix` (sous-arbre, `old/new_path`
+        inclus) ; sans filtre = tout, comme avant ; `webhook_matches()` pur et testé
+  - [x] `POST`/`PATCH`/`GET /api/webhooks` : filtres acceptés, modifiables (`""` = reset), exposés
+  - [x] `PUT …/save` émet enfin `file_modified` (souscrit mais jamais dispatché)
+  - [x] UI : champs filtre + badge, aide intégrée FR/EN mise à jour
+  - [x] Tests `tests/test_webhook_filters.py` (10 : matching, persistance, dispatch simulé)
+
+### 199. Clés API à portée limitée — vault unique + fichiers seuls (TikTak, Gitea #2)
+
+- **Effort :** 1-2 jours | **Impact :** 🟡 | **Ouvert :** 2026-10-14 | **Statut :** ✅ livré le 2026-10-14
+- **Fiche :** [features/tiktak-integration-197-200.md](./features/tiktak-integration-197-200.md)
+- **Description :** la clé que TikTak conservera ne doit toucher que le vault « TikTak »
+  et que les fichiers — en cas de fuite, le reste de la mémoire reste hors de portée.
+- **Sous-tâches :**
+  - [x] `POST /api/auth/tokens` : `vaults?` (sous-ensemble du créateur, 400/403 sinon) +
+        `scope` (`full` défaut | `files`) ; JWT + record portent la portée
+  - [x] Vault : `check_vault_access`/`require_vault_access` existants → 403 hors vault (REST + MCP)
+  - [x] Périmètre `files` : `TokenScopeMiddleware` (403 REST, stateless) + `call_tool`/
+        `propose_*`/`list_tools`/`vault://` (`token_scope_denied`, `FILES_SCOPE_TOOLS`)
+  - [x] UI : sélecteur de portée + champ vaults, badge et vaults listés (i18n FR/EN)
+  - [x] Compatibilité : clés existantes = `full`, inchangées
+  - [x] Tests `tests/test_scoped_tokens.py` (13) + guides API_REST (§2.3, §5) / MCP
+
+### 200. Provisionnement du vault dédié « TikTak » (exploitation, Gitea #1)
+
+- **Effort :** 0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-10-14 | **Statut :** ✅ livré le 2026-10-14 (runbook)
+- **Fiche :** [features/tiktak-integration-197-200.md](./features/tiktak-integration-197-200.md) (§#200)
+- **Description :** opération unique côté hébergement, aucun code requis : dossier hôte +
+  montage conteneur + `POST /api/vaults/add` (persisté, sans redémarrage) + ACL du
+  compte de synchro + clé limitée (#199) + webhook filtré (#198) + recette `curl`
+  d'acceptation. **Reste à exécuter sur l'hôte** (suivre le runbook, puis fermer Gitea #1).
+
+---
+
 ### 77. Application Desktop native — Tauri (Windows / Linux / macOS)
 
 - **Effort :** 8-12 jours | **Impact :** 🟡 | **Framework :** Tauri v2 (Rust + Webview)
@@ -42,7 +169,7 @@
 
 ---
 
-## 🔵 En cours — Visionneuse & édition Excel (P0/P1/P2)
+## ✅ Terminé — Visionneuse & édition Excel (P0/P1/P2)
 
 ### 153. Visionneuse & édition XLSX — complétude (fidélité, recherche, IA, UX, formats)
 
@@ -92,7 +219,7 @@
 
 ---
 
-## 🔵 En cours — Refonte UI/UX tableur (P2)
+## ✅ Terminé — Refonte UI/UX tableur (P2)
 
 ### 154. Refonte UI/UX de la visionneuse & éditeur XLSX (ruban, grille, inspecteur)
 
@@ -119,7 +246,7 @@
 
 ---
 
-## 🔵 En cours — Ergonomie tableur
+## ✅ Terminé — Ergonomie tableur
 
 ### 155. Ergonomie tableur — menu contextuel & sélection type Excel
 
@@ -137,6 +264,260 @@
 
 ---
 
+## ✅ Terminé — Polish menus tableur
+
+### 179. Éditeur tableur — icônes des menus & boutons, fermeture au focus, polish mobile
+
+- **Effort :** 1-2 jours | **Impact :** 🟡
+- **Statut :** ✅ **livré le 2026-10-04** (v2.53.0) — ouvert le 2026-10-04
+- **Fiche :** [features/xlsx-menus-179.md](./features/xlsx-menus-179.md)
+- **Description :** la grille (#155), les menus Structure/Mise en forme/Export
+  (#156-A8/A11/A14) et les boutons du ruban (#154) sont textuels et restent
+  ouverts quand le focus quitte le menu. Ajouter des icônes Lucide
+  représentatives, fermer tout menu à la perte de focus (clic extérieur,
+  `focusout`, `Échap`, défilement), naviguer au clavier dans le menu grille, et
+  garantir des cibles tactiles ≥ 44 px + menus dans le viewport en mobile.
+- **Sous-tâches :**
+  - [x] **A1** Icônes des entrées du menu contextuel de la grille (+ `item.icon`)
+  - [x] **A2** Icônes des menus Structure / Mise en forme / Export + boutons
+        Enregistrer / « + » onglet
+  - [x] **A3** Fermeture à la perte de focus (helper partageable : extérieur,
+        `focusout`, `Échap`, scroll/resize) + navigation clavier du menu grille
+  - [x] **A4** Polish mobile (44 px tactile, menus bornés au viewport) + tests
+        JSDOM + E2E `xlsx-viewer.spec.js`
+
+---
+
+## ✅ Terminé — Ergonomie & grille du tableur
+
+### 186. Création d'un fichier Excel depuis « Créer un fichier »
+
+- **Effort :** 0,5 jour | **Impact :** 🟢
+- **Statut :** ✅ **livré le 2026-10-05** - ouvert le 2026-10-05
+- **Fiche :** [features/create-file-xlsx-186.md](./features/create-file-xlsx-186.md)
+- **Description :** l'éditeur Excel étant disponible, la modale « Créer un fichier » ne
+  proposait que des formats texte (`.md`, `.txt`, `.py`, `.js`, `.json`, `.yaml`, `.sh`,
+  `.ps1`) + Excalidraw : impossible de démarrer un classeur depuis l'UI. Il fallait
+  passer par l'assistant IA (`create_xlsx`) ou déposer un fichier existant.
+- **Sous-tâches :**
+  - [x] **A1** Option **Excel (.xlsx)** dans la liste des types, et les 10 libellés du
+        `<select>` passés en i18n FR/EN (`modal.ext_*`) — ils étaient codés en dur
+  - [x] **A2** `create_file()` backend : un `.xlsx` est une archive OPC, pas du texte —
+        le classeur est **construit avec openpyxl** (une feuille `Feuille1`) au lieu
+        d'écrire la charge utile vide, sinon le fichier est illisible par la visionneuse
+  - [x] **A3** Tests : non-régression pytest (`test_api_main.py` — classeur relu par
+        openpyxl et servi en `is_xlsx`), E2E `xlsx-viewer.spec.js` (option présente,
+        création depuis le menu contextuel, ouverture dans la grille)
+
+---
+
+## ✅ Terminé — Assistant IA
+
+### 187. Assistant IA — mode agent toujours actif, retrait du bouton toggle
+
+- **Effort :** 0,5 jour | **Impact :** 🟢
+- **Statut :** ✅ **livré le 2026-10-07** (v2.53.2) — ouvert le 2026-10-06
+- **Description :** le bouton « mode agent » du panneau (toggle persisté en
+  localStorage, défaut OFF) n'était plus protecteur : Deep Research et les
+  quick actions `agent: true` basculaient déjà le mode en silence. Un
+  utilisateur pouvait donc voir l'assistant agir sans jamais avoir activé le
+  bouton. Retiré au profit d'un agent toujours actif : toute requête texte
+  part sur `/api/ai/bookslm/agent` (outils lire/lister/chercher/modifier ; les
+  mutations gardent la confirmation two-step) ; les images seules restent sur
+  `/api/ai/bookslm/chat` (endpoint multimodal, la boucle agent étant
+  textuelle).
+- **Sous-tâches :**
+  - [x] **A1** Frontend : bouton header, `_agentMode`, toggle/persistance et les
+        auto-bascules (Deep Research, quick actions) supprimés ; `_postChat`
+        route texte→`/agent`, images→`/chat` ; aide et i18n FR/EN mises à jour
+  - [x] **A2** Optimisations requêtes AI : `/agent` résout désormais le
+        provider comme `/chat` (avant : `req.provider` brut transmis au
+        provider adapter → moteur réel ≠ étiquette SSE) ; schémas d'outils
+        mis en cache (~27 ms de pydantic économisés par requête agent/MCP)
+  - [x] **A3** Tests : `ai.test.mjs` adapté (100/100) ; non-régression pytest
+        (`test_bookslm.py` provider résolu, `test_tools.py` cache sûr) ;
+        ruff/mypy 0 erreur ; build + instance Docker locale à jour
+
+---
+
+## ✅ Terminé — Barre de menus & grille du tableur
+
+### 185. Tableur — barre de menus Google Sheets (10 menus), ruban Sheets, grille unie
+
+- **Effort :** 1-2 jours | **Impact :** 🟡
+- **Statut :** ✅ **livré le 2026-10-08** (v2.54.0) — ouvert le 2026-10-05
+- **Fiche :** [features/xlsx-menus-185.md](./features/xlsx-menus-185.md)
+- **Description :** l'éditeur n'avait **aucune barre de menus** (ni Fichier, ni
+  Modifier, ni Affichage, ni Insertion, ni Format, ni Données, ni Outils, ni
+  Gemini, ni Extensions, ni Aide) : beaucoup de fonctions n'étaient atteignables
+  que par clic droit. Le ruban gardait un chromer bordersé qui ne ressemblait à
+  rien et la grille n'était bordée qu'en bas avec une couleur quasi identique au
+  fond des cellules — le quadrillage se lisait comme une tache.
+- **Sous-tâches :**
+  - [x] **A1** `frontend/js/xlsx/menus.js` : les **dix menus de Google Sheets**,
+        dans l'ordre et avec les libellés exacts (161 entrées) ; sections en
+        accordéon ; le menu **Fichier** quitte la barre d'onglets pour la barre de
+        menus en **conservant ses identifiants**, seul *Enregistrer* reste
+        épinglé
+  - [x] **A2** **Majorité des fonctions câblées** : Partager, Renommer,
+        Corbeille, Historique, Détails ; Annuler/Rétablir/Couper/Copier/Coller,
+        **Collage spécial (valeurs)**, Supprimer, Tout sélectionner,
+        Rechercher-et-remplacer ; Figer, Afficher (barre de formule / grille /
+        en-têtes / tableau de bord), Zoom, Plein écran ; Lignes / Colonnes /
+        Cellules, Lien, Commentaire, Fonction ; Nombre, Thème, B/I/U/S, Taille,
+        Alignement, Retour ligne, Rotation, **Couleurs alternées**, Effacer ;
+        Trier, **Filtre**, Plages nommées, **Nettoyage (doublons / espaces)**,
+        **Diviser le texte en colonnes** ; Autocomplétion, Accessibilité ;
+        Gemini ; Aide, Mises à jour, Raccourcis, Signalement. Les 36 options
+        absentes d'ObsiGate **sont listées et le disent** au clic
+  - [x] **A3** **Ruban façon Sheets** : boutons plats 30 × 30 sans chromer,
+        survol discret, groupes par filets ; nouveau bouton grille piloté par le
+        menu Affichage
+  - [x] **A4** **Grille unie et visible** : 1 px **sur les quatre côtés** de
+        chaque cellule (en-têtes compris) et un seul `--grid-border` dérivé du
+        thème (`color-mix` texte → surface) au lieu de `--border` invisible
+  - [x] Tests JSDOM (`xlsx-menus` + `xlsx-viewer`), E2E `xlsx-viewer.spec.js`,
+        i18n FR/EN (134 clés `xlsx.m*` / `xlsx.mi_*`)
+
+---
+
+### 184. Tableur — peinture de format, multi-lignes/colonnes, grille A→Z × 1000
+
+- **Effort :** 1 jour | **Impact :** 🟡
+- **Statut :** ✅ **livré le 2026-10-08** (v2.54.0) — ouvert le 2026-10-05
+- **Fiche :** [features/xlsx-sheet-input-181.md](./features/xlsx-sheet-input-181.md) (§8)
+- **Description :** « Peindre le format » échouait quand la source n'avait pas de
+  format propre ; il manquait la sélection de plusieurs lignes/colonnes depuis
+  les marges ; la grille s'arrêtait aux dimensions réelles du fichier au lieu
+  d'aller jusqu'à A → Z et 1000 lignes.
+- **Sous-tâches :**
+  - [x] **A1** Peinture de format **complète** (toutes propriétés) + source sans
+        format ⇒ **réinitialisation** de la cible ; fuite du handler annulé
+  - [x] **A2** Sélection multi-lignes / multi-colonnes par glissement sur les
+        marges et `Maj`+clic ; le geste de redimensionnement garde la priorité
+  - [x] **A3** Grille étendue à **A → Z × 1000 lignes**, cellules vides
+        éditables, padding à l'activation de l'onglet, pas de doublons
+  - [x] **A4** Performance : index de cellules `findTd`, court-circuits
+        formule/styles, marqueur `data-wired`
+
+---
+
+## ✅ Terminé — Panneau de couleurs du tableur
+
+### 183. Panneau de sélection de couleurs façon Google Sheets (texte et fond)
+
+- **Effort :** 0,5-1 jour | **Impact :** 🟡
+- **Statut :** ✅ **livré le 2026-10-08** (v2.54.0) — ouvert le 2026-10-05
+- **Fiche :** [features/xlsx-sheet-input-181.md](./features/xlsx-sheet-input-181.md) (§7)
+- **Description :** le sélecteur natif `<input type="color">` du ruban et du menu
+  Mise en forme est remplacé par un panneau conforme aux maquettes : *Réinitialiser*,
+  palette 8 × 10, STANDARD, PERSONNALISÉ, pied de page. Un clic sur une pastille
+  referme le panneau et applique la couleur.
+- **Sous-tâches :**
+  - [x] **A1** Module `frontend/js/xlsx/color-picker.js` : palette 8 × 10
+        (8 gris puis 8 teintes × 9 nuances), **sortie en `#rrggbb`**
+  - [x] **A2** Coche de sélection blanche/noire selon la luminance
+  - [x] **A3** Câblage ruban + menu Mise en forme, fermeture au clic, application
+        sur cellule **ou plage**, réinitialisation, « + » / crayons vers le
+        sélecteur natif
+  - [x] **A4** Chrome du panneau thémé (variables CSS), i18n FR/EN (21 clés),
+        pied de page honnête (message explicite pour les fonctions absentes)
+
+---
+
+## ✅ Terminé — Correctifs éditeur tableur
+
+### 182. Tableur — désélection fiable & couleurs sur une plage
+
+- **Effort :** 0,5 jour | **Impact :** 🟡
+- **Statut :** ✅ **livré le 2026-10-08** (v2.54.0) — ouvert le 2026-10-05
+- **Fiche :** [features/xlsx-sheet-input-181.md](./features/xlsx-sheet-input-181.md) (§6)
+- **Description :** suite de #181 — la sélection multiple se dessinait mais ne
+  s'effaçait plus, et l'application d'une couleur de texte / de fond sur une
+  plage paraissait inerte.
+- **Sous-tâches :**
+  - [x] **A1** Le clic simple efface toujours la plage, sans dépendre de
+        l'événement `focus` (cause : `Maj`+clic + `preventDefault()` figeait le
+        focus, donc aucun `focus` ne partait au clic suivant)
+  - [x] **A2** Après `Maj`+clic, le focus suit la cellule cliquée ; la zone Nom
+        affiche la plage après un glissement
+  - [x] **A3** Couleurs de texte et de fond vérifiées sur les 3 chemins
+        (menu Mise en forme, nuanciers du ruban, `Maj`+flèches et glissement)
+  - [x] **A4** Pastille de couleur sur les nuanciers du ruban (retour visuel)
+  - [x] **A5** **Contours de plage qui s'empilaient** : le sélecteur de
+        nettoyage oubliait le `.` des classes (`querySelectorAll("xlsx-sel-top")`
+        cherche une balise) — rien n'était effacé, les encadrés restaient et
+        s'ajoutaient à chaque changement de cellule. Même famille de faute sur
+        les en-têtes reflétés
+  - [x] **A6** Pendant la saisie, les flèches **valident et déplacent** la
+        sélection (au lieu de déplacer le curseur), comme Google Sheets ;
+        `Alt`+flèche garde le saut de ligne
+  - [x] Tests JSDOM `xlsx-viewer` **152/152** (+6), suites frontend vertes
+
+---
+
+## ✅ Terminé — Polish éditeur tableur (mise en page & thèmes)
+
+### 181. Éditeur tableur — modèle de saisie Google Sheets (sélection ≠ édition) & écarts fonctionnels
+
+- **Effort :** 1 jour (A1-A3) + inventaire des écarts (A4) | **Impact :** 🟡
+- **Statut :** ✅ **livré le 2026-10-08** (v2.54.0) — ouvert le 2026-10-05
+- **Fiche :** [features/xlsx-sheet-input-181.md](./features/xlsx-sheet-input-181.md)
+- **Description :** l'éditeur ne distingue pas **sélectionner** une cellule et
+  **l'éditer** : le curseur de texte est visible en permanence, `Entrée` valide
+  puis perd le focus, et l'indicateur de plage est discret. Aligner le modèle de
+  saisie sur Google Sheets / Excel (A1-A3) et **inventorier** précisément ce qui
+  manque encore face à un tableur de référence (A4) — le rapprochement exhaustif
+  n'est pas réalisable en une tranche.
+- **Sous-tâches :**
+  - [x] **A1** Deux états distincts : *sélection* (clic / flèches, pas de
+        curseur via `caret-color: transparent`, contour visible) et *édition*
+        (double-clic en place, première frappe qui **remplace**, `F2`,
+        `Alt`+flèche pour un saut de ligne, `Échap` qui restaure)
+  - [x] **A2** Sélection multiple : glisser, `Maj`+clic, `Maj`+flèches, avec
+        contour de plage (`.xlsx-sel-*` sur les 4 bords réels) + en-têtes
+        `A`/`B`… et `1`/`2`… reflétés
+  - [x] **A3** `Entrée` contextuelle : en édition → valide et passe **à la
+        cellule du dessous** ; en sélection → bascule en **mode édition**
+  - [x] **A4** Inventaire des écarts vs Google Sheets / Excel et priorisation
+        (P1 poignée de recopie / remplacer / validation de données / filtre
+        auto / tri multi-critères ; P2 mise en forme conditionnelle / création
+        de graphiques / TCD éditables / protection ; P3 analyse de données,
+        historique, macros) — voir [fiche](./features/xlsx-sheet-input-181.md)
+  - [x] Tests JSDOM (`xlsx-viewer` **146/146**, +10 cas #181), suites frontend
+        vertes, build + déploiement de l'instance Docker locale
+
+---
+
+### 180. Éditeur tableur — redimensionnement au curseur, grille thémée, menu Fichier & barre épinglée
+
+- **Effort :** 1-2 jours | **Impact :** 🟡
+- **Statut :** ✅ **livré le 2026-10-08** (v2.54.0) — ouvert le 2026-10-05
+- **Fiche :** [features/xlsx-sheetbar-180.md](./features/xlsx-sheetbar-180.md)
+- **Description :** retours utilisateur après #179 — (1) le redimensionnement des
+  colonnes/lignes par les marges (`A, B, C…` / `1, 2, 3…`) doit afficher un
+  curseur iconique (`col-resize` / `row-resize`) quand le pointeur est sur le
+  bord ; (2) la grille doit suivre le thème de l'utilisateur (15 thèmes ×
+  4 modes + importés : tokens dérivés, plus de fond figé) ; (3) regrouper
+  Télécharger / CSV / Exporter dans un **menu Fichier** en haut à droite, au
+  niveau des onglets de feuilles, avec **Enregistrer** juste à côté ;
+  (4) retirer l'indicateur « Formules calculées localement » ; (5) épingler la
+  barre de boutons en haut, au bord de la marge, et étendre l'éditeur à la
+  largeur de la page.
+- **Sous-tâches :**
+  - [x] **A1** Curseur de redimensionnement sur les marges d'en-têtes
+        (en-tête de bord miroité en ligne + classe de repaint `.xlsx-resize-col/row`)
+  - [x] **A2** Grille compatible tous thèmes (`--grid-*` dérivés dans
+        `themes.js`, replis CSS, modes contraste élevé / sépia, menu Export sur `--surface`)
+  - [x] **A3** Menu Fichier + Enregistrer au niveau des onglets (`.xlsx-sheetbar`,
+        identifiants des contrôles conservés)
+  - [x] **A4** Retrait de l'indicateur de formules + barre épinglée pleine largeur
+        (`position: sticky`, `:has(.xlsx-viewer)` en plein cadre)
+  - [x] Tests JSDOM (`xlsx-viewer` 136/136, `xlsx-menus` 12/12), E2E `xlsx-viewer.spec.js`,
+        i18n FR/EN, 8 tests réalignés sur l'application locale des écritures
+
+---
+
 ## ✅ Terminé — Navigation
 
 ### 158. Navigation — vue répertoire en onglet, filtres & tris, retour Home complet
@@ -220,12 +601,80 @@
 
 ---
 
+## ✅ Terminé — Secrets masqués
+
+### 188. Secrets masqués — couverture universelle des clés API & mots de passe + clic pour copier
+
+- **Effort :** 1 jour | **Impact :** 🟡
+- **Statut :** ✅ **livré le 2026-10-08** — ouvert le 2026-10-08
+- **Fiche :** [features/secret-mask-188.md](./features/secret-mask-188.md)
+- **Description :** le redacteur (`secret_redactor.py`) ne couvrait que les
+  JWT, clés `sk-`/`AKIA`/`ghp_`, connection strings et affectations
+  `key=value` de 20+ caractères — la plupart des clés API réelles et **tous
+  les mots de passe courts** passaient en clair dans l'aperçu markdown, et
+  un masque affiché n'était pas récupérable sans ouvrir la source. #188
+  couvre la majorité des formats de clés, masque les mots de passe quelle
+  que soit leur longueur et rend chaque masque **cliquable** dans l'aperçu
+  authentifié (copie dans le presse-papiers) sans jamais exposer la valeur
+  à l'extérieur (partages, PDF, IA/MCP).
+- **Sous-tâches :**
+  - [x] **A1** Détection universelle : table de formats fournisseur (OpenAI,
+        Stripe, GitLab, GitHub, Google, AWS, Slack, SendGrid, Hugging Face,
+        npm, Docker, Resend, Square, Atlassian, Discord, Telegram,
+        `Bearer …`) + plancher des affectations génériques 20 → 8 caractères
+  - [x] **A2** Mots de passe : `[MOT DE PASSE MASQUÉ]` toute longueur /
+        quote (`password=`, `"passwd":`, `db_password=`, `mot de passe=`) ;
+        `PWD=` shell épargné
+  - [x] **A3** Clic → copie : placeholders markdown-safe (blocs de code
+        compris) réécrits en `<span class="secret-mask" data-secret>`
+        côté aperçu authentifié (listener délégué, toast + infobulle
+        i18n FR/EN) ; libellé seul pour partages / PDF / IA / MCP ;
+        code masqué non re-coloré (highlight.js perdrait le badge)
+  - [x] **A4** Guide in-app FR/EN, `GUIDES/AUTHENTIFICATION_SECURITE.md`,
+        README FR/EN, tests `TestSecretRedactor` (+33)
+
+---
+
+## ✅ Terminé — Mise en page mobile du tableur
+
+### 189. Tableur — mise en page mobile (barres repliées, grille prioritaire)
+
+- **Effort :** 0,5-1 jour | **Impact :** 🟡 | **Framework :** CSS vanilla + `frontend/js/viewer.js`
+- **Statut :** ✅ **livré le 2026-10-08** — ouvert le 2026-10-08
+- **Fiche :** [features/xlsx-mobile-layout-189.md](./features/xlsx-mobile-layout-189.md)
+- **Description :** sur mobile, la barre de menus + le ruban + la barre de
+  formule s'empilaient et occupaient plus de 50 % de la hauteur d'écran.
+  Sous 768 px, `.xlsx-menubar`, `.xlsx-cmdbar` et le groupe Recherche sont
+  **repliés par défaut** (la barre de formule fx et les onglets restent
+  visibles) et un **bouton unique** `#xlsx-tools-toggle` dans la barre des
+  feuilles déplie/replie l'ensemble (`aria-expanded`, état actif) — desktop
+  inchangé (bouton masqué).
+- **Sous-tâches :**
+  - [x] **A1** Repli CSS par défaut ≤ 768 px + révélation via
+        `.xlsx-toolbar.xlsx-tools-open` (menubar, ruban, Recherche)
+  - [x] **A2** Bascule `#xlsx-tools-toggle` dans `.xlsx-sheetbar`
+        (`aria-expanded` + classe `active` + i18n `xlsx.tools_toggle` FR/EN)
+  - [x] **A3** Tactile : cibles ≥ 44 px, onglets en défilement horizontal,
+        champs de la barre de formule en 16 px (anti-zoom iOS), barre de
+        formule en 2 lignes quand les outils sont ouverts
+  - [x] **A4** Tests : JSDOM `xlsx-viewer.test.mjs` (+2, 165/165) et E2E
+        mobile (repli par défaut, dépliage, no-overflow ruban, 44 px) ;
+        `openXlsx()` déplie automatiquement ≤ 768 px pour les tests desktop
+
+---
+
 ## ⚪ Backlog — Priorité 4 (P4)
 
 ### 73. Synchronisation multi-appareils — Obsidian Sync compatible
 
 - **Effort :** 6-8 jours | **Impact :** 🟢
 - **Décision 2026-09-26 : reporté (P4)** — axe prioritaire = dette & sécurité (#85/#87) ; #73 hors chemin critique. Si réactivé : partir d'un MVP export/hash/LWW adossé à #59 (PWA offline) + #62 (collab Yjs/CRDT) plutôt qu'un protocole parallèle.
+- **Périmètre élargi le 2026-10-04 (liste v1.2 Ph.3) :** la **synchronisation des favoris**
+  (répertoires compris, cf. #161) et la **synchronisation des préférences utilisateur** (thèmes
+  #65/#174, langue, historique de recherche et de modifications, recherches sauvegardées #162) sont
+  **fusionnées dans cet item** plutôt que portées par des items séparés — même API de sync, même
+  résolution de conflits. Store local actuel : JSON par utilisateur dans `data/` (pas de table
+  `user_preferences` distincte ; un addendum de schéma suffirait si #73 est réactivé).
 - **Description :** Synchronisation des vaults entre plusieurs instances d'ObsiGate via un protocole de synchronisation décentralisé ou compatible Obsidian Sync. Alternative self-hosted à Obsidian Sync.
 - **Sous-tâches :**
   - [ ] Protocole : évaluation CRDT vs OT vs diff/patch pour fichiers markdown
@@ -236,6 +685,9 @@
   - [ ] Conflits : UI de résolution manuelle (diff côte à côte entre version locale et distante)
   - [ ] Chiffrement : optionnel, chiffrement AES-256-GCM avant transmission
   - [ ] Pairing : échange de clé publique + code QR pour appairage des appareils
+  - [ ] Périmètre v1.2 : sync des **favoris** (#161) et des **préférences** (thème, langue,
+        historique, recherches sauvegardées) avec résolution de conflits (priorité à la dernière
+        modification) + indicateur « préférences synchronisées »
 
 ---
 
@@ -259,6 +711,130 @@
 
 ---
 
+## ⚪ Backlog — Améliorations produit & évolutions agent IA (liste v1.2) — P1/P2
+
+> **Ouvert le 2026-10-04** à partir de la liste « Roadmap ObsiGate – Développement des
+> Fonctionnalités » v1.2 (phases 1-3 + suggestions agent IA numérotées 161-180 dans la liste
+> source). Évaluation croisée avec le code réel (2026-10-04) : **7 propositions sont déjà
+> livrées** et n'ouvrent donc **pas** d'ID ; seul le périmètre manquant reçoit un ID ObsiGate
+> stable `#161` → `#178`. Les numéros de la liste source ne sont **pas** repris tels quels
+> (règle du dépôt : un ID n'est jamais attribué à du déjà-fait ni réutilisé).
+> Chaque item doit passer par [DELIVERY_WORKFLOW.md](./DELIVERY_WORKFLOW.md) (DoD) à son ouverture.
+
+### Table de correspondance (liste v1.2 → ObsiGate)
+
+| Proposition v1.2 | Verdict 2026-10-04 (vérifié dans le code) | ID ObsiGate |
+|---|---|---|
+| Ph.1 — Sauvegarde des recherches fréquentes | Sauvegarde **déjà livrée** (`backend/saved_searches.py`, store `data/{user}_saved_searches.json`, bouton « Sauver » #158) ; fréquence & rappels manquants | ⚪ #162 |
+| Ph.1 — Liens de répertoires aux favoris | Marque-page existant sur **fichiers** uniquement (dashboard) ; répertoires absents | ⚪ #161 |
+| Ph.1 — Recherche dans la page | **Déjà livrée** en vue lecture (`FindInPageManager`, Ctrl+F + navigation + regex, tableur via #153-A13) ; reste l'intégration **Forge** | ⚪ #163 |
+| Ph.2 — Auto-complétion intelligente | **Déjà livrée** (`frontend/js/autocomplete.js` : Mermaid, code fence, frontmatter, wikilinks, table — partagé Forge/CodeMirror) | ✅ |
+| Ph.2 — Suggestions contextuelles (historique & préférences) | Non livré | ⚪ #164 |
+| Ph.3 — Synchronisation favoris + préférences multiplateforme | Fusionné dans le périmètre de **#73** (reporté P4, décision 2026-09-26) | ⚪ #73 |
+| 161 — Synchronisation Git automatique des vaults | Non livré (les outils `git_*` #92 ciblent Gitea/GitHub pour l'IA, pas la sync de vault) | ⚪ #165 |
+| 162 — Génération de résumés automatiques | **Déjà livrée** (`POST /api/ai/summarize`, actions instantanées #106, skills `backend/skills.py`) | ✅ |
+| 163 — Détection & fusion de doublons | Non livré (brique embeddings/TF-IDF #70 disponible) | ⚪ #166 |
+| 164 — Traduction automatique | **Déjà livrée** (toolbar IA « Traduire », #106) | ✅ |
+| 165 — Analyse de ton/style | **Déjà livrée** (toolbar IA « Ton », #106) | ✅ |
+| 166 — APIs tierces (Google Drive, Notion) | Partiel : sources connectées **Gitea/GitHub** livrées (#103, `backend/tools/connected.py`) ; Drive/Notion manquants | ⚪ #167 |
+| 167 — Notifications externes (Slack, Discord, Email) | Partiel : webhooks #9 + Push API #67 livrés ; canaux Slack/Discord/SMTP et choix des déclencheurs à câbler | ⚪ #168 |
+| 168 — Édition collaborative temps réel | **Déjà livrée** (#62 — Yjs/CRDT, WebSocket, awareness, v2.3.0) | ✅ |
+| 169 — Scripts personnalisés sandboxés | **Déjà livrée** (#61 — plugins en sandbox Web Worker, hooks, 9 endpoints, v2.2.0) | ✅ |
+| 170 — Planification de tâches automatiques (cron) | Non livré | ⚪ #170 |
+| 171 — Audit des accès | Partiel : `backend/audit.py` + `/api/admin/audit` + dashboard admin #71 existent ; historique **par fichier**, filtres avancés et export CSV manquants | ⚪ #171 |
+| 172 — Chiffrement/déchiffrement de fichiers | Non livré (AES-GCM interne réservé aux tokens) | ⚪ #172 |
+| 173 — Vues personnalisées (Kanban, Calendrier) | Non livré | ⚪ #173 |
+| 174 — Optimisation mobile | Base **largement livrée** (#69 éditeur mobile, #83 ruban mobile, #114 config responsive 44 px) ; reste un audit du solde | ⚪ #178 |
+| 175 — Chat intégré | **Livré le 2026-10-08** (SSE, panneau latéral, historique, toast) | ✅ #169 |
+| 176 — Thèmes dynamiques (règles heure/date) | Base livrée (#65 thèmes + import/export) ; règles automatiques manquantes | ⚪ #174 |
+| 177 — Export formats propriétaires (OneNote, Evernote) | Base livrée (#66 HTML/MD bundle/ePub + PDF #74) ; formats tiers manquants | ⚪ #175 |
+| 178 — Webhooks pour événements | **Déjà livrée** (#9 — `backend/webhooks.py`, événements + secrets + validation d'URL SSRF-safe) | ✅ |
+| 179 — Gestion fine des permissions | Non livré (ACLs par vault/dossier racine seulement) | ⚪ #176 |
+| 180 — Historique des révisions visuel | Partiel : gestion des backups **avec diff** livrée (#40-46, outil IA `diff_backup`) ; UI côte à côte manquante | ⚪ #177 |
+
+---
+
+### 161. Favoris — répertoires et liens de vault (menu contextuel)
+
+- **Effort :** 0,5-1 jour | **Impact :** 🟡 | **Ouvert :** 2026-10-04 | **Statut :** ⚪ non commencé
+- **Description :** le marque-page actuel ne couvre que les fichiers ; ajouter les **répertoires**
+  aux favoris (proposition « liens de répertoires », liste v1.2 Ph.1).
+- **Sous-tâches :**
+  - [ ] Étendre le modèle de favoris aux répertoires (vérification d'accès backend via
+        `_resolve_safe_path()`, permissions)
+  - [ ] Entrée « Ajouter aux favoris » dans le menu contextuel de l'arbre **et** de la page de
+        navigation (#158-A5)
+  - [ ] Section « Favoris » dans la sidebar (répertoires + fichiers)
+  - [ ] i18n FR/EN, tests (unit + E2E si UI), fiche `docs/features/`
+
+### 162. Recherches fréquentes — fréquence d'utilisation & rappels
+
+- **Effort :** 1-2 jours | **Impact :** 🟢 | **Ouvert :** 2026-10-04 | **Statut :** ⚪ non commencé
+- **Cadrage :** la **sauvegarde** des recherches existe déjà (`backend/saved_searches.py`, bouton
+  « Sauver » de #158). Cet item n'ouvre que l'incrément manquant de la liste v1.2 Ph.1.
+- **Sous-tâches :**
+  - [ ] Compteur d'utilisation par recherche sauvegardée (horodatage + fréquence)
+  - [ ] Section dédiée « Recherches fréquentes » (page de résultats + sidebar) et épinglage
+  - [ ] Rappel optionnel (« Vous avez souvent cherché X ») via notifications #67, interruptible
+        en Configuration
+  - [ ] i18n FR/EN + tests
+
+### 163. Recherche dans la page — éditeur Forge
+
+- **Effort :** 0,5-1 jour | **Impact :** 🟡 | **Ouvert :** 2026-10-04 | **Statut :** ⚪ non commencé
+- **Cadrage :** `FindInPageManager` (Ctrl+F, surbrillance, navigation ↑/↓, casse / mot entier /
+  regex) est livré pour la vue lecture ; le tableur a sa propre recherche (#153-A13). Reste à
+  raccorder la recherche à l'éditeur **Forge** et à l'exposer en commande `/`.
+- **Sous-tâches :**
+  - [ ] Raccorder `FindInPageManager` à Forge (textarea **et** CodeMirror) : surbrillance dans le
+        contenu édité, navigation avec boucle, conservation du curseur
+  - [ ] Commande `/recherche-dans-page` (mécanisme de commandes #81)
+  - [ ] Non-régression des raccourcis existants (Ctrl+F vs recherche globale, Échap) ; i18n ;
+        tests JSDOM + E2E
+
+### 164. Suggestions contextuelles dans l'éditeur (historique & préférences)
+
+- **Effort :** 3-5 jours | **Impact :** 🟢 | **Ouvert :** 2026-10-04 | **Statut :** ⚪ non commencé
+- **Cadrage :** l'auto-complétion contextuelle (Mermaid, code, Markdown, wikilinks, frontmatter)
+  est **déjà livrée** (`frontend/js/autocomplete.js`) — la proposition v1.2 Ph.2
+  « Auto-complétion intelligente » est couverte. Cet item n'ouvre que les suggestions apprises
+  du contexte utilisateur.
+- **Sous-tâches :**
+  - [ ] Mesure locale des snippets les plus utilisés par l'utilisateur (fréquence, sans cloud)
+  - [ ] Suggestions basées sur l'historique de modification (termes récurrents, patterns du type
+        « souvent inséré après … ») — option locale, IA légère si disponible
+  - [ ] Bascule on/off en Configuration ; intégration à la complétion existante
+  - [ ] i18n FR/EN + tests
+
+---
+
+### ⚪ Évolutions agent IA (liste v1.2 « Phase 4 », IDs ObsiGate #165 → #178)
+
+| ID | Fonctionnalité | Effort | Impact | Dépendances / socle à étendre |
+|---|---|---|---|---|
+| 165 | Synchronisation automatique des vaults avec Git (add/commit/push/pull, résolution de conflits, auth SSH/token, option planification X heures) | 4-6 j | 🟡 | subprocess/`gitpython` ; UI dans Configuration (#160) ; distinct des outils `git_*` #92 (IA, Gitea/GitHub) |
+| 166 | Détection & fusion de doublons (score de similarité, liste des paires potentielles, outil de fusion) — ✅ **livré le 2026-10-04** ([fiche](./features/agent-phase4-166-168-170.md)) | 3-4 j | 🟢 | embeddings/TF-IDF #70 ; **jamais de fusion sans confirmation explicite** (+ backup préalable) |
+| 167 | Connexions tierces — Google Drive & Notion (import/export, OAuth2, respect des quotas) | 5-7 j | 🟡 | page « sources connectées » #103 ; rate-limit existant |
+| 168 | Notifications externes — canaux Slack/Discord (webhooks) et Email (SMTP) + choix des déclencheurs — ✅ **livré le 2026-10-04** ([fiche](./features/agent-phase4-166-168-170.md) ; périmètre : Discord, Telegram, SMTP, webhook générique — Slack via webhook générique) | 3-4 j | 🟢 | `backend/webhooks.py` #9 ; Push API #67 |
+| 169 | Chat intégré par fichier (panneau latéral, historique, notifications de nouveaux messages) — ✅ **livré le 2026-10-08** ([fiche](./features/file-chat-169.md) ; transport SSE #62, pas de 2ᵉ WebSocket) | 3-4 j | 🟢 | transport SSE #62 |
+| 170 | Planification de tâches automatiques (type cron ; actions = outils existants `create_file`/`append_to_file` ; notifications d'échec) — ✅ **livré le 2026-10-04** ([fiche](./features/agent-phase4-166-168-170.md) ; tick asyncio 60 s, API + outils, sans UI dédiée) | 3-4 j | 🟢 | scheduler backend (APScheduler ou asyncio) ; UI de création de tâches |
+| 171 | Audit des accès — extension : historique lecture/édition par fichier, filtres (utilisateur/fichier/date), export CSV | 2-3 j | 🟡 | `backend/audit.py` + `/api/admin/audit` (#71) |
+| 172 | Chiffrement/déchiffrement de fichiers sensibles (AES-256-GCM, gestion de clés, confirmation) | 3-4 j | 🟡 | **backup automatique préalable** ; clés hors dépôt (jamais de secret committé) |
+| 173 | Vues personnalisées Kanban & Calendrier (glisser-déposer, colonnes/date par tags & métadonnées) | 5-6 j | 🟢 | facettes/tags #157-#158 ; store JSON par utilisateur (pattern `data/*.json`) |
+| 174 | Thèmes dynamiques (règles heure/date, ex. mode sombre 18h-8h, règles personnalisables) | 2-3 j | 🟢 | thèmes #65 ; préférence persistée (candidate à la sync #73) |
+| 175 | Export vers formats propriétaires (OneNote, Evernote) avec conservation des métadonnées (tags, liens, images) | 3-4 j | 🟢 | `export.py` #66 (HTML/MD bundle/ePub) + PDF #74 |
+| 176 | Permissions fines par fichier/dossier (utilisateur/groupe + actions, héritage, journal des changements) | 4-5 j | 🟡 | ACLs vaults/dossiers existantes ; passerelle obligatoire par `_resolve_safe_path()` |
+| 177 | Historique des révisions visuel (diff côte à côte, surlignage ajouts/suppressions, navigation Précédent/Suivant) | 3-4 j | 🟢 | backups + diff #40-46 (`diff_backup`) ; `difflib` backend |
+| 178 | Optimisation mobile — solde (audit cibles tactiles ≥ 44 px, lazy-loading images/médias, raccourcis clavier virtuel) | 4-5 j | 🟡 | base livrée #69/#83/#114 ; lazy-loading déjà partiel (#153-A9) |
+
+- **Critères d'acceptation transverses (liste v1.2 harmonisée avec la DoD du dépôt) :** test
+  desktop **et** mobile ; documentation utilisateur FR/EN dans `docs/GUIDES/` (l'appel
+  « Guide_MCP_ObsiGate.md » de la liste source est ramené à la cartographie documentaire du
+  dépôt) ; **backup automatique avant toute modification destructive** ; i18n FR/EN systématique ;
+  passage de l'ID à « en cours » avant codage (AGENTS.md, « Avant de commencer »).
+
+---
+
 ## ✅ Complété — index
 
 > Détail complet dans [docs/archive/COMPLETED_v1-v2.md](./archive/COMPLETED_v1-v2.md) et
@@ -271,6 +847,22 @@
 | 154 | Tableur — Refonte UI/UX (ruban groupé, onglets permanents, badges d'état, inspecteur droit, undo/redo) | 2.40.0→2.43.1 | [features/xlsx-ui-redesign.md](./features/xlsx-ui-redesign.md) |
 | 155 | Tableur — Menu contextuel (clic droit / appui long) & sélection type Excel | 2.44.0 | [features/xlsx-context-menu.md](./features/xlsx-context-menu.md) |
 | 156 | Tableur — Complétude éditeur : presse-papiers/clavier (A5-A7), mise en forme (A8), décision calcul (A9), undo unifié (A10), export + recherche multi-feuilles (A11), concurrence optimiste (A12), cache méta (A13), outils IA `.xlsm`/`.csv` (A14) + BUG-096 → BUG-099 | 2.45.0 | [features/xlsx-editor-completeness.md](./features/xlsx-editor-completeness.md) |
+| 179 | Tableur — icônes des menus & boutons, fermeture au focus, polish mobile | 2.53.0 | [features/xlsx-menus-179.md](./features/xlsx-menus-179.md) |
+| 180 | Tableur — redimensionnement au curseur, grille thémée, menu Fichier, barre épinglée | 2.54.0 | [features/xlsx-sheetbar-180.md](./features/xlsx-sheetbar-180.md) |
+| 181 | Tableur — modèle de saisie Google Sheets (sélection ≠ édition) & inventaire des écarts | 2.54.0 | [features/xlsx-sheet-input-181.md](./features/xlsx-sheet-input-181.md) |
+| 182 | Tableur — désélection fiable, contours non empilés, couleurs sur une plage | 2.54.0 | [features/xlsx-sheet-input-181.md](./features/xlsx-sheet-input-181.md) |
+| 183 | Tableur — panneau de couleurs façon Google Sheets (texte et fond) | 2.54.0 | [features/xlsx-sheet-input-181.md](./features/xlsx-sheet-input-181.md) |
+| 184 | Tableur — peinture de format complète, multi-lignes/colonnes, grille A → Z × 1000 (croissance par blocs) | 2.54.0 | [features/xlsx-sheet-input-181.md](./features/xlsx-sheet-input-181.md) |
+| 185 | Tableur — barre de menus Google Sheets (10 menus), ruban Sheets, grille unie | 2.54.0 | [features/xlsx-menus-185.md](./features/xlsx-menus-185.md) |
+| 186 | Création d'un fichier Excel (`.xlsx`) depuis la modale « Créer un fichier » | 2.54.0 | [features/create-file-xlsx-186.md](./features/create-file-xlsx-186.md) |
+| 188 | Secrets — détection universelle des clés API & mots de passe, masque cliquable (clic = copie) | Unreleased | [features/secret-mask-188.md](./features/secret-mask-188.md) |
+| 189 | Tableur — mise en page mobile : barres repliées par défaut, bascule unique, cibles tactiles 44 px | 2.56.0 | [features/xlsx-mobile-layout-189.md](./features/xlsx-mobile-layout-189.md) |
+| 169 | Chat intégré par fichier (panneau latéral, historique, temps réel SSE, toast de notification) | 2.57.0 | [features/file-chat-169.md](./features/file-chat-169.md) |
+| 190 | Chat — suivi du document, chat général en onglet sidebar (pièces jointes, non lus, recherche), onglets au-dessus du filtre | 2.58.0 | [features/file-chat-169.md](./features/file-chat-169.md) |
+| 191 | Chat — suppression de post, messages privés 2 utilisateurs (canaux), boîte d'édition compacte, link preview OG | 2.60.0 | [features/file-chat-169.md](./features/file-chat-169.md) |
+| 192 | Chat — boîte de saisie auto-agrandissante + accusé de réception ✓✓ (retour live SSE, notification de lecture) · BUG-109 (image de tuile de lien) | 2.61.0 | [features/file-chat-169.md](./features/file-chat-169.md) |
+| 159 | Desktop — gestion des vaults & dossiers : retrait par menu contextuel + section Configuration (ajout vault/dossier racine) | 2.50.0 | [features/desktop-tauri.md](./features/desktop-tauri.md) |
+| 160 | Desktop — premier lancement professionnel (répertoire `%USERPROFILE%\ObsiGate` + `Prise en main.md`) et section Configuration harmonisée | 2.51.0 | [features/desktop-tauri.md](./features/desktop-tauri.md) |
 | BUG-047 | Versionnage — source unique `VERSION` + bump SemVer automatique au commit (hooks + tag) | 2.3.0 | [DEVELOPMENT_AND_RELEASES.md](./DEVELOPMENT_AND_RELEASES.md) |
 | 90 | Barre d'actions du document — regroupement fonctionnel + spacers | 2.3.0 | [archive](./archive/COMPLETED_v1-v2.md) |
 | 89 | Drag & drop complet de fichiers/dossiers & intégration Assistant IA | 2.3.0 | [features/drag-and-drop-ai.md](./features/drag-and-drop-ai.md) |
@@ -340,6 +932,9 @@
 | 85 | Refonte architecturale — découpage du monolithe (14 routers, `main.py` 4 827 → ~750 lignes), stores JSON verrouillés, rate-limit SQLite optionnel | 2.27.2→2.27.13 | [features/archi-refonte-85.md](./features/archi-refonte-85.md) |
 | 157 | Recherche — facette « Extensions » dans les résultats (3ᵉ filtre avec Vaults et Tags) + panneau repliable | 2.46.0→2.47.0 | [archive](./archive/COMPLETED_v1-v2.md) |
 | 158 | Navigation — clic répertoire → **onglet de navigation** (sous-répertoires, facettes Vaults/Tags/Extensions, tri Pertinence/Date, Sauver), **onglet Accueil**, menus contextuels + retour Home complet (**BUG-100** → **BUG-102**) | 2.48.0→2.49.0 | [features/navigation-tab-158.md](./features/navigation-tab-158.md) |
+| 166 | Assistant IA — détection & fusion de doublons (score déterministe, paires candidates, fusion backup + confirmation) | Unreleased | [features/agent-phase4-166-168-170.md](./features/agent-phase4-166-168-170.md) |
+| 168 | Assistant IA — notifications externes Discord / Telegram / SMTP / webhook (déclencheurs, secrets hors config, SSRF-safe) | Unreleased | [features/agent-phase4-166-168-170.md](./features/agent-phase4-166-168-170.md) |
+| 170 | Assistant IA — tâches planifiées type cron (create/append/notify, interval/daily/once, tick 60 s, échec notifié) | Unreleased | [features/agent-phase4-166-168-170.md](./features/agent-phase4-166-168-170.md) |
 
 ---
 
@@ -349,7 +944,9 @@
 |---|---|---|
 | ✅ Complété | #1 → #59, #61–72, #74–76, #78–86, #88–93, #94–100, #102–115, #117, #92 | ~141 jours réalisés |
 | 🔵 Finitions | #77 Desktop : 6 tests E2E **manuels** ([protocole](./DESKTOP_E2E_CHECKLIST.md)) — signature Windows non retenue (décision 2026-09-26) | ~0,5-1 jour |
-| ⚪ P4 reporté | #73 Sync — **reporté (décision 2026-09-26)**, hors chemin critique | 6-8 jours si réactivé |
+| ⚪ P4 reporté | #73 Sync — **reporté (décision 2026-09-26)**, hors chemin critique ; périmètre élargi 2026-10-04 (favoris #161 + préférences) | 6-8 jours si réactivé |
+| ⚪ P1/P2 nouvelles (liste v1.2) | #161 favoris répertoires · #162 recherches fréquentes · #163 recherche Forge · #164 suggestions contextuelles | ~5-9 jours |
+| ⚪ Évolutions agent IA (#165 → #178) | Git sync, doublons, Drive/Notion, notifications, chat, cron, audit, chiffrement, Kanban, thèmes dynamiques, OneNote/Evernote, permissions, diff visuel, mobile | ~45-63 jours si tout activé (à prioriser par tranches) |
 | ⚪ P0/P1 prioritaire | #87 CI/CD (BUG-035 → BUG-040 corrigés, #86 livré) | ~3-5 jours |
 | ✅ Terminé | #153 Visionneuse & édition XLSX — complétude (A1-A17 **toutes livrées**, v2.27.0 → v2.39.0) | 0 jour restant |
 | ✅ Terminé | #154 Refonte UI/UX tableur (A1-A5 **toutes livrées**, v2.40.0 → v2.43.1) | 0 jour restant |
@@ -368,6 +965,14 @@
 - **Clôture 2026-09-30 :** #156 **livré (P0 → P3)** — **A8** mise en forme en écriture (bouton **Mise en forme** : gras/italique/souligné, alignements, couleurs, formats de nombre, fusions, volets figés, largeur/hauteur — via `PUT …/xlsx/style`), **A9** décision « pas de moteur de formule, annoncée dans l'UI », **A10** undo/redo unifié conservé au re-rendu, **A11** export de la sélection / Markdown / HTML / impression + recherche sur toutes les feuilles, **A12** concurrence optimiste (`If-Match`, **409** réparable), **A13** cache des métadonnées par `mtime`, **A14** outils IA `.xlsm`/`.csv` + `search_workbook`/`analyze_range`/`edit_xlsx_structure` — détail dans [features/xlsx-editor-completeness.md](./features/xlsx-editor-completeness.md).
 - **Ajout 2026-09-29 :** #156 **P1 livré** — **A5** presse-papiers de plage (copier/couper/coller un bloc, presse-papiers interne + système, entrées du menu contextuel, remplissage multi-cellules), **A6** clavier complet (`Ctrl+S`/`Ctrl+A`/`Suppr`/`F2`/`Ctrl+Home|End`/`PgUp|PgDn`/`Ctrl+flèches`/`Maj+Entrée`) et **A7** zone Nom éditable + aide à la saisie ; restent P2 (mise en forme, calcul, undo unifié) et P3 (sortie, concurrence optimiste, performances, outils IA).
 - **Ajout 2026-09-29 :** #156 ouvert — audit de complétude de l'éditeur Excel : **4 défauts recensés** (BUG-096 enregistrement `.csv`, BUG-097 lazy-load `.xlsm`, BUG-098 délimiteur CSV, BUG-099 sonde de perte), **corrigés le jour même (P0 ✅)** avec tests de non-régression ; restent P1-P3 (presse-papiers, clavier, mise en forme, calcul, export, concurrence optimiste) puis presse-papiers de plage, clavier complet, mise en forme en écriture, calcul, undo/redo unifié, export/impression, concurrence optimiste — détail dans [features/xlsx-editor-completeness.md](./features/xlsx-editor-completeness.md).
+- **Ajout 2026-10-04 :** intégration de la liste « Roadmap – Développement des Fonctionnalités »
+  v1.2 (phases 1-3 + suggestions agent IA). Évaluation croisée avec le code : **7 propositions déjà
+  livrées** (auto-complétion `autocomplete.js`, résumés/traduction/ton #106, édition collaborative
+  #62, scripts/plugins #61, webhooks #9, recherche dans la page en vue lecture) → pas d'ID ;
+  **périmètre manquant** ouvert en backlog **#161 → #178** avec **table de correspondance** en tête
+  de la nouvelle section ; sync favoris/préférences **fusionnée dans #73** (reporté P4). Les numéros
+  161-180 de la liste source ne sont pas repris tels quels (règle dépôt : ID jamais attribué au
+  déjà-fait) ; la correspondance figure item par item.
 - **Clôture #85 (v2.27.13) :** monolithe découpé (T1→T9), stores verrouillés + rate-limit SQLite (T10), fiche `docs/features/archi-refonte-85.md`.
 - Les items P3/P4 ne sont pas ordonnés par priorité interne — à raffiner selon les retours utilisateurs.
 - L'effort inclut le développement + tests unitaires + intégration CI, mais pas la documentation utilisateur.

docs/agent-flow.dot

@@ -0,0 +1,87 @@
+// ObsiGate AI Agent — flux de traitement d'une demande (b89af91)
+digraph ObsiGateAgent {
+  rankdir=TB;
+  splines=polyline;
+  nodesep=0.35; ranksep=0.45;
+  graph [fontname="DejaVu Sans", fontsize=13, bgcolor="white", pad=0.3];
+  node  [fontname="DejaVu Sans", fontsize=12, style=filled, shape=box, color="#333333", margin="0.16,0.09"];
+  edge  [fontname="DejaVu Sans", fontsize=11, color="#555555", arrowsize=0.8];
+
+  // ── Entrée ──
+  user [label="Demande utilisateur\n(frontend bookslm.js)", fillcolor="#dbeafe"];
+  deep [label="Chip « Deep Research »\n= agent mode + prompt injecté :\n« décomposer les étapes, chercher\ndans le vault, croiser,\nsynthétiser avec sources »",
+        shape=note, fillcolor="#fef3c7"];
+  api  [label="POST /api/bookslm/agent\n→ réponse SSE (thought · tool ·\nconfirmation · message · done)", fillcolor="#e0f2fe"];
+  prompt [label="Construction du system prompt\nmode directory / documents / general\ncontexte vault pré-chargé (BooksLM :\n≤200 fichiers, ≤200k chars, cache 5 min)\nprotocole agent = function calling natif", fillcolor="#f1f5f9"];
+
+  user -> api; deep -> user [style=dashed, label="active", fontsize=10];
+  api -> prompt;
+
+  // ── Boucle agent ──
+  subgraph cluster_loop {
+    label="BOUCLE AGENT — backend/agent/loop.py · run_agent()";
+    style=rounded; color="#e11d48"; penwidth=2; fontsize=13; fontcolor="#e11d48";
+
+    llm [label="Appel LLM — chat_completion()\nfournisseur OpenAI-compatible / Gemini\ntemp=0.3 · max_tokens 8192\nschemas des 50 outils exposés\n(si modèle sans tools → retombe chat simple)", fillcolor="#fee2e2"];
+    decide [label="Le LLM demande des\noutils (tool_calls) ?", shape=diamond, fillcolor="#fff7ed"];
+    thought [label="note de raisonnement\nintermédiaire → step visible « pensée »", fillcolor="#fef9c3"];
+    tools [label="Exécution de chaque tool call\nvia call_tool() (voir pipeline)", fillcolor="#dcfce7"];
+    back [label="résultat (JSON, tronqué ≤100k chars)\najouté à la conversation →\nitération suivante", shape=plaintext];
+
+    llm -> decide;
+    decide -> thought [label="oui", color="#e11d48"];
+    thought -> tools;
+    tools -> llm [label="itération ≤ 10\nquota tools ≤ 25\n(BOOKSLM_MAX_TOOL_CALLS)", color="#e11d48"];
+  }
+  prompt -> llm;
+
+  // ── Pipeline call_tool ──
+  subgraph cluster_pipe {
+    label="PIPELINE call_tool() — backend/tools/registry.py · chaque appel passe par là";
+    style=rounded; color="#7c3aed"; fontsize=13; fontcolor="#7c3aed";
+
+    p1 [label="1 · Schéma Pydantic\n+ validation arguments", fillcolor="#ede9fe"];
+    p2 [label="2 · Rate limit\npar identité + outil", fillcolor="#ede9fe"];
+    p3 [label="3 · Permission vault\n(+ déstructif si risque\nDANGEROUS)", fillcolor="#ede9fe"];
+    p4 [label="4 · Risque READ ?\n→ exécution directe", shape=diamond, fillcolor="#f5f3ff"];
+    p5 [label="PAUSE CONFIRMATION\noutil WRITE/DANGEROUS → event SSE\n« confirmation » avec le plan complet\nbatché (BUG-075) : une seule\napprobation applique toutes les mutations\n(resume via confirm / confirm_all)", fillcolor="#fde68a"];
+    p6 [label="5 · Handler exécuté\n6 · Audit JSON-lines\n7 · Redaction secrets (redact_payload)", fillcolor="#dcfce7"];
+    p1 -> p2 -> p3 -> p4;
+    p4 -> p6 [label="read"];
+    p4 -> p5 [label="mutation", color="#d97706"];
+    p5 -> p6 [label="approuvé", style=dashed];
+  }
+  tools -> p1;
+  p6 -> back [label="tool result", style=invis];
+  p6 -> tools [style=invis];
+  back -> p1 [style=invis];
+
+  // ── Sorties ──
+  done [label="Réponse finale\nréponse sans tool_calls\n→ SSE « message »\n(Markdown + sources citées)", fillcolor="#bbf7d0"];
+  final [label="Budget épuisé (10 itérations\nou 25 appels) → _finalize_answer :\ndernier appel SANS outils pour forcer\nune synthèse, sinon liste des sources\ndéterministe (jamais de réponse vide)", fillcolor="#fed7aa"];
+  decide -> done [label="non", color="#059669", penwidth=2];
+  decide -> final [label="budget atteint", color="#ea580c"];
+  answer [label="Affichage UI : bloc\n« N étapes » Notion-style\n(pensées + outils dépliables)", fillcolor="#dbeafe"];
+  done -> answer; final -> answer;
+
+  // ── Boîte à outils ──
+  subgraph cluster_tools {
+    label="50 OUTILS — backend/tools/*.py · risque READ / WRITE / DANGEROUS";
+    style=rounded; color="#0369a1"; fontsize=13; fontcolor="#0369a1";
+    node [fillcolor="#f0f9ff", fontsize=10];
+
+    fam_vault [label="VAULT · service.py (22)\nlecture : list_vaults, list_directory,\nlist_all_files, read_file, read_file_raw,\nsearch_fulltext, search_advanced,\nsearch_paths, get_graph, get_backlinks,\nlist_tags, suggest_tags, list_recent,\nlist_backups, diff_backup\nécriture : create_file, create_directory,\nappend_to_file, edit_file, restore_backup\nDANGEROUS : delete_file, delete_directory,\nmove_path, rename_file, rename_directory,\nreplace_in_files"];
+    fam_web [label="WEB · web.py + crawler.py\nweb_search · fetch_url\ncrawl_site (≤20 pages, même hôte)"];
+    fam_doc [label="DOCUMENTS · documents.py\ncreate_pdf · create_docx\ncreate_xlsx · create_csv"];
+    fam_xlsx [label="TABLEURS · spreadsheets.py\nlist_xlsx_sheets · xlsx_to_markdown\nsearch_workbook · analyze_range\nupdate_xlsx_cells · append_xlsx_rows\nedit_xlsx_structure"];
+    fam_dup [label="DOUBLONS · duplicates.py\nfind_duplicates\nmerge_duplicate_notes (DANG.)"];
+    fam_git [label="GIT CONNECTÉ · connected.py\ngit_list_repos · git_get_file\ngit_search_issues (Gitea/GitHub)"];
+    fam_sched [label="SCHEDULER · scheduled.py\nlist/create/delete/run_scheduled_task"];
+    fam_notify [label="NOTIFICATIONS · notify.py\nnotify_external (Discord,\nTelegram, SMTP, webhook)"];
+  }
+  p6 -> cluster_tools [style=invis];
+  fam_vault -> fam_web [style=invis]; fam_web -> fam_doc [style=invis];
+  fam_doc -> fam_xlsx [style=invis]; fam_xlsx -> fam_dup [style=invis];
+  fam_dup -> fam_git [style=invis]; fam_git -> fam_sched [style=invis];
+  fam_sched -> fam_notify [style=invis];
+}

docs/agent-flow.svg

@@ -0,0 +1,394 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 2.42.4 (0)
+ -->
+<!-- Title: ObsiGateAgent Pages: 1 -->
+<svg width="2130pt" height="1034pt"
+ viewBox="0.00 0.00 2130.20 1033.70" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(21.6 1012.1)">
+<title>ObsiGateAgent</title>
+<polygon fill="white" stroke="transparent" points="-21.6,21.6 -21.6,-1012.1 2108.6,-1012.1 2108.6,21.6 -21.6,21.6"/>
+<g id="clust1" class="cluster">
+<title>cluster_loop</title>
+<path fill="white" stroke="#e11d48" stroke-width="2" d="M493,-11.5C493,-11.5 1052,-11.5 1052,-11.5 1058,-11.5 1064,-17.5 1064,-23.5 1064,-23.5 1064,-471 1064,-471 1064,-477 1058,-483 1052,-483 1052,-483 493,-483 493,-483 487,-483 481,-477 481,-471 481,-471 481,-23.5 481,-23.5 481,-17.5 487,-11.5 493,-11.5"/>
+<text text-anchor="middle" x="772.5" y="-468.6" font-family="DejaVu Sans" font-size="13.00" fill="#e11d48">BOUCLE AGENT — backend/agent/loop.py · run_agent()</text>
+</g>
+<g id="clust2" class="cluster">
+<title>cluster_pipe</title>
+<path fill="white" stroke="#7c3aed" d="M1084,-102C1084,-102 1580,-102 1580,-102 1586,-102 1592,-108 1592,-114 1592,-114 1592,-761.5 1592,-761.5 1592,-767.5 1586,-773.5 1580,-773.5 1580,-773.5 1084,-773.5 1084,-773.5 1078,-773.5 1072,-767.5 1072,-761.5 1072,-761.5 1072,-114 1072,-114 1072,-108 1078,-102 1084,-102"/>
+<text text-anchor="middle" x="1332" y="-759.1" font-family="DejaVu Sans" font-size="13.00" fill="#7c3aed">PIPELINE call_tool() — backend/tools/registry.py · chaque appel passe par là</text>
+</g>
+<g id="clust3" class="cluster">
+<title>cluster_tools</title>
+<path fill="white" stroke="#0369a1" d="M1612,-8C1612,-8 2067,-8 2067,-8 2073,-8 2079,-14 2079,-20 2079,-20 2079,-970.5 2079,-970.5 2079,-976.5 2073,-982.5 2067,-982.5 2067,-982.5 1612,-982.5 1612,-982.5 1606,-982.5 1600,-976.5 1600,-970.5 1600,-970.5 1600,-20 1600,-20 1600,-14 1606,-8 1612,-8"/>
+<text text-anchor="middle" x="1839.5" y="-968.1" font-family="DejaVu Sans" font-size="13.00" fill="#0369a1">50 OUTILS — backend/tools/*.py · risque READ / WRITE / DANGEROUS</text>
+</g>
+<!-- user -->
+<g id="node1" class="node">
+<title>user</title>
+<polygon fill="#dbeafe" stroke="#333333" points="712.5,-743.5 561.5,-743.5 561.5,-705.5 712.5,-705.5 712.5,-743.5"/>
+<text text-anchor="middle" x="637" y="-727.9" font-family="DejaVu Sans" font-size="12.00">Demande utilisateur</text>
+<text text-anchor="middle" x="637" y="-714.9" font-family="DejaVu Sans" font-size="12.00">(frontend bookslm.js)</text>
+</g>
+<!-- api -->
+<g id="node3" class="node">
+<title>api</title>
+<polygon fill="#e0f2fe" stroke="#333333" points="742.5,-669 531.5,-669 531.5,-618 742.5,-618 742.5,-669"/>
+<text text-anchor="middle" x="637" y="-653.4" font-family="DejaVu Sans" font-size="12.00">POST /api/bookslm/agent</text>
+<text text-anchor="middle" x="637" y="-640.4" font-family="DejaVu Sans" font-size="12.00">→ réponse SSE (thought · tool ·</text>
+<text text-anchor="middle" x="637" y="-627.4" font-family="DejaVu Sans" font-size="12.00">confirmation · message · done)</text>
+</g>
+<!-- user&#45;&gt;api -->
+<g id="edge1" class="edge">
+<title>user&#45;&gt;api</title>
+<path fill="none" stroke="#555555" d="M637,-705.18C637,-696.86 637,-686.76 637,-677.2"/>
+<polygon fill="#555555" stroke="#555555" points="639.8,-677.01 637,-669.01 634.2,-677.01 639.8,-677.01"/>
+</g>
+<!-- deep -->
+<g id="node2" class="node">
+<title>deep</title>
+<polygon fill="#fef3c7" stroke="#333333" points="749,-919 519,-919 519,-842 755,-842 755,-913 749,-919"/>
+<polyline fill="none" stroke="#333333" points="749,-919 749,-913 "/>
+<polyline fill="none" stroke="#333333" points="755,-913 749,-913 "/>
+<text text-anchor="middle" x="637" y="-903.4" font-family="DejaVu Sans" font-size="12.00">Chip « Deep Research »</text>
+<text text-anchor="middle" x="637" y="-890.4" font-family="DejaVu Sans" font-size="12.00">= agent mode + prompt injecté :</text>
+<text text-anchor="middle" x="637" y="-877.4" font-family="DejaVu Sans" font-size="12.00">« décomposer les étapes, chercher</text>
+<text text-anchor="middle" x="637" y="-864.4" font-family="DejaVu Sans" font-size="12.00">dans le vault, croiser,</text>
+<text text-anchor="middle" x="637" y="-851.4" font-family="DejaVu Sans" font-size="12.00">synthétiser avec sources »</text>
+</g>
+<!-- deep&#45;&gt;user -->
+<g id="edge2" class="edge">
+<title>deep&#45;&gt;user</title>
+<path fill="none" stroke="#555555" stroke-dasharray="5,2" d="M637,-841.83C637,-813.95 637,-776.67 637,-751.91"/>
+<polygon fill="#555555" stroke="#555555" points="639.8,-751.71 637,-743.71 634.2,-751.71 639.8,-751.71"/>
+<text text-anchor="middle" x="652.5" y="-784.5" font-family="DejaVu Sans" font-size="10.00">active</text>
+</g>
+<!-- prompt -->
+<g id="node4" class="node">
+<title>prompt</title>
+<polygon fill="#f1f5f9" stroke="#333333" points="773.5,-585 500.5,-585 500.5,-508 773.5,-508 773.5,-585"/>
+<text text-anchor="middle" x="637" y="-569.4" font-family="DejaVu Sans" font-size="12.00">Construction du system prompt</text>
+<text text-anchor="middle" x="637" y="-556.4" font-family="DejaVu Sans" font-size="12.00">mode directory / documents / general</text>
+<text text-anchor="middle" x="637" y="-543.4" font-family="DejaVu Sans" font-size="12.00">contexte vault pré&#45;chargé (BooksLM :</text>
+<text text-anchor="middle" x="637" y="-530.4" font-family="DejaVu Sans" font-size="12.00">≤200 fichiers, ≤200k chars, cache 5 min)</text>
+<text text-anchor="middle" x="637" y="-517.4" font-family="DejaVu Sans" font-size="12.00">protocole agent = function calling natif</text>
+</g>
+<!-- api&#45;&gt;prompt -->
+<g id="edge3" class="edge">
+<title>api&#45;&gt;prompt</title>
+<path fill="none" stroke="#555555" d="M637,-617.54C637,-610.12 637,-601.74 637,-593.43"/>
+<polygon fill="#555555" stroke="#555555" points="639.8,-593.17 637,-585.17 634.2,-593.17 639.8,-593.17"/>
+</g>
+<!-- llm -->
+<g id="node5" class="node">
+<title>llm</title>
+<polygon fill="#fee2e2" stroke="#333333" points="784.5,-453 489.5,-453 489.5,-376 784.5,-376 784.5,-453"/>
+<text text-anchor="middle" x="637" y="-437.4" font-family="DejaVu Sans" font-size="12.00">Appel LLM — chat_completion()</text>
+<text text-anchor="middle" x="637" y="-424.4" font-family="DejaVu Sans" font-size="12.00">fournisseur OpenAI&#45;compatible / Gemini</text>
+<text text-anchor="middle" x="637" y="-411.4" font-family="DejaVu Sans" font-size="12.00">temp=0.3 · max_tokens 8192</text>
+<text text-anchor="middle" x="637" y="-398.4" font-family="DejaVu Sans" font-size="12.00">schemas des 50 outils exposés</text>
+<text text-anchor="middle" x="637" y="-385.4" font-family="DejaVu Sans" font-size="12.00">(si modèle sans tools → retombe chat simple)</text>
+</g>
+<!-- prompt&#45;&gt;llm -->
+<g id="edge8" class="edge">
+<title>prompt&#45;&gt;llm</title>
+<path fill="none" stroke="#555555" d="M637,-507.9C637,-493.35 637,-476.55 637,-461.3"/>
+<polygon fill="#555555" stroke="#555555" points="639.8,-461.02 637,-453.02 634.2,-461.02 639.8,-461.02"/>
+</g>
+<!-- decide -->
+<g id="node6" class="node">
+<title>decide</title>
+<polygon fill="#fff7ed" stroke="#333333" points="641,-325 489,-287 641,-249 793,-287 641,-325"/>
+<text text-anchor="middle" x="641" y="-290.4" font-family="DejaVu Sans" font-size="12.00">Le LLM demande des</text>
+<text text-anchor="middle" x="641" y="-277.4" font-family="DejaVu Sans" font-size="12.00">outils (tool_calls) ?</text>
+</g>
+<!-- llm&#45;&gt;decide -->
+<g id="edge4" class="edge">
+<title>llm&#45;&gt;decide</title>
+<path fill="none" stroke="#555555" d="M638.2,-375.85C638.63,-362.33 639.12,-346.95 639.57,-332.87"/>
+<polygon fill="#555555" stroke="#555555" points="642.37,-332.85 639.83,-324.76 636.77,-332.67 642.37,-332.85"/>
+</g>
+<!-- thought -->
+<g id="node7" class="node">
+<title>thought</title>
+<polygon fill="#fef9c3" stroke="#333333" points="786.5,-154.5 529.5,-154.5 529.5,-116.5 786.5,-116.5 786.5,-154.5"/>
+<text text-anchor="middle" x="658" y="-138.9" font-family="DejaVu Sans" font-size="12.00">note de raisonnement</text>
+<text text-anchor="middle" x="658" y="-125.9" font-family="DejaVu Sans" font-size="12.00">intermédiaire → step visible « pensée »</text>
+</g>
+<!-- decide&#45;&gt;thought -->
+<g id="edge5" class="edge">
+<title>decide&#45;&gt;thought</title>
+<path fill="none" stroke="#e11d48" d="M645.12,-249.81C648.17,-222.91 652.28,-186.83 655.02,-162.68"/>
+<polygon fill="#e11d48" stroke="#e11d48" points="657.81,-162.94 655.93,-154.67 652.25,-162.31 657.81,-162.94"/>
+<text text-anchor="middle" x="659.5" y="-205.2" font-family="DejaVu Sans" font-size="11.00">oui</text>
+</g>
+<!-- done -->
+<g id="node16" class="node">
+<title>done</title>
+<polygon fill="#bbf7d0" stroke="#333333" points="473,-167.5 275,-167.5 275,-103.5 473,-103.5 473,-167.5"/>
+<text text-anchor="middle" x="374" y="-151.9" font-family="DejaVu Sans" font-size="12.00">Réponse finale</text>
+<text text-anchor="middle" x="374" y="-138.9" font-family="DejaVu Sans" font-size="12.00">réponse sans tool_calls</text>
+<text text-anchor="middle" x="374" y="-125.9" font-family="DejaVu Sans" font-size="12.00">→ SSE « message »</text>
+<text text-anchor="middle" x="374" y="-112.9" font-family="DejaVu Sans" font-size="12.00">(Markdown + sources citées)</text>
+</g>
+<!-- decide&#45;&gt;done -->
+<g id="edge19" class="edge">
+<title>decide&#45;&gt;done</title>
+<path fill="none" stroke="#059669" stroke-width="2" d="M595.1,-260.3C551.33,-235.79 485.07,-198.69 436.49,-171.49"/>
+<polygon fill="#059669" stroke="#059669" stroke-width="2" points="437.81,-169.02 429.46,-167.55 435.07,-173.9 437.81,-169.02"/>
+<text text-anchor="middle" x="541.5" y="-205.2" font-family="DejaVu Sans" font-size="11.00">non</text>
+</g>
+<!-- final -->
+<g id="node17" class="node">
+<title>final</title>
+<polygon fill="#fed7aa" stroke="#333333" points="250,-174 0,-174 0,-97 250,-97 250,-174"/>
+<text text-anchor="middle" x="125" y="-158.4" font-family="DejaVu Sans" font-size="12.00">Budget épuisé (10 itérations</text>
+<text text-anchor="middle" x="125" y="-145.4" font-family="DejaVu Sans" font-size="12.00">ou 25 appels) → _finalize_answer :</text>
+<text text-anchor="middle" x="125" y="-132.4" font-family="DejaVu Sans" font-size="12.00">dernier appel SANS outils pour forcer</text>
+<text text-anchor="middle" x="125" y="-119.4" font-family="DejaVu Sans" font-size="12.00">une synthèse, sinon liste des sources</text>
+<text text-anchor="middle" x="125" y="-106.4" font-family="DejaVu Sans" font-size="12.00">déterministe (jamais de réponse vide)</text>
+</g>
+<!-- decide&#45;&gt;final -->
+<g id="edge20" class="edge">
+<title>decide&#45;&gt;final</title>
+<path fill="none" stroke="#ea580c" d="M565.01,-267.84C491.13,-250.18 390,-226 390,-226 390,-226 314.36,-200.46 243.91,-176.66"/>
+<polygon fill="#ea580c" stroke="#ea580c" points="244.71,-173.97 236.23,-174.07 242.92,-179.28 244.71,-173.97"/>
+<text text-anchor="middle" x="429.5" y="-205.2" font-family="DejaVu Sans" font-size="11.00">budget atteint</text>
+</g>
+<!-- tools -->
+<g id="node8" class="node">
+<title>tools</title>
+<polygon fill="#dcfce7" stroke="#333333" points="987,-57.5 787,-57.5 787,-19.5 987,-19.5 987,-57.5"/>
+<text text-anchor="middle" x="887" y="-41.9" font-family="DejaVu Sans" font-size="12.00">Exécution de chaque tool call</text>
+<text text-anchor="middle" x="887" y="-28.9" font-family="DejaVu Sans" font-size="12.00">via call_tool() (voir pipeline)</text>
+</g>
+<!-- thought&#45;&gt;tools -->
+<g id="edge6" class="edge">
+<title>thought&#45;&gt;tools</title>
+<path fill="none" stroke="#555555" d="M701.61,-116.41C739.89,-100.53 795.6,-77.42 835.95,-60.68"/>
+<polygon fill="#555555" stroke="#555555" points="837.23,-63.18 843.55,-57.53 835.09,-58 837.23,-63.18"/>
+</g>
+<!-- tools&#45;&gt;llm -->
+<g id="edge7" class="edge">
+<title>tools&#45;&gt;llm</title>
+<path fill="none" stroke="#e11d48" d="M881.93,-57.8C864.2,-121.83 806,-332 806,-332 806,-332 764.31,-352.1 722.35,-372.34"/>
+<polygon fill="#e11d48" stroke="#e11d48" points="721.06,-369.85 715.07,-375.85 723.49,-374.9 721.06,-369.85"/>
+<text text-anchor="middle" x="930" y="-217.2" font-family="DejaVu Sans" font-size="11.00">itération ≤ 10</text>
+<text text-anchor="middle" x="930" y="-205.2" font-family="DejaVu Sans" font-size="11.00">quota tools ≤ 25</text>
+<text text-anchor="middle" x="930" y="-193.2" font-family="DejaVu Sans" font-size="11.00">(BOOKSLM_MAX_TOOL_CALLS)</text>
+</g>
+<!-- p1 -->
+<g id="node10" class="node">
+<title>p1</title>
+<polygon fill="#ede9fe" stroke="#333333" points="1244,-743.5 1080,-743.5 1080,-705.5 1244,-705.5 1244,-743.5"/>
+<text text-anchor="middle" x="1162" y="-727.9" font-family="DejaVu Sans" font-size="12.00">1 · Schéma Pydantic</text>
+<text text-anchor="middle" x="1162" y="-714.9" font-family="DejaVu Sans" font-size="12.00">+ validation arguments</text>
+</g>
+<!-- tools&#45;&gt;p1 -->
+<g id="edge15" class="edge">
+<title>tools&#45;&gt;p1</title>
+<path fill="none" stroke="#555555" d="M927.18,-57.59C988.4,-85.16 1098,-134.5 1098,-134.5 1098,-644.5 1098,-644.5 1098,-644.5 1098,-644.5 1123.27,-675.7 1142.06,-698.88"/>
+<polygon fill="#555555" stroke="#555555" points="1139.94,-700.72 1147.16,-705.18 1144.3,-697.2 1139.94,-700.72"/>
+</g>
+<!-- back -->
+<g id="node9" class="node">
+<title>back</title>
+<polygon fill="#333333" stroke="transparent" points="1056,-440 810,-440 810,-389 1056,-389 1056,-440"/>
+<text text-anchor="middle" x="933" y="-424.4" font-family="DejaVu Sans" font-size="12.00">résultat (JSON, tronqué ≤100k chars)</text>
+<text text-anchor="middle" x="933" y="-411.4" font-family="DejaVu Sans" font-size="12.00">ajouté à la conversation →</text>
+<text text-anchor="middle" x="933" y="-398.4" font-family="DejaVu Sans" font-size="12.00">itération suivante</text>
+</g>
+<!-- back&#45;&gt;p1 -->
+<!-- p2 -->
+<g id="node11" class="node">
+<title>p2</title>
+<polygon fill="#ede9fe" stroke="#333333" points="1282,-662.5 1146,-662.5 1146,-624.5 1282,-624.5 1282,-662.5"/>
+<text text-anchor="middle" x="1214" y="-646.9" font-family="DejaVu Sans" font-size="12.00">2 · Rate limit</text>
+<text text-anchor="middle" x="1214" y="-633.9" font-family="DejaVu Sans" font-size="12.00">par identité + outil</text>
+</g>
+<!-- p1&#45;&gt;p2 -->
+<g id="edge9" class="edge">
+<title>p1&#45;&gt;p2</title>
+<path fill="none" stroke="#555555" d="M1174.06,-705.18C1181.02,-694.61 1189.86,-681.17 1197.46,-669.62"/>
+<polygon fill="#555555" stroke="#555555" points="1199.95,-670.95 1202,-662.72 1195.27,-667.87 1199.95,-670.95"/>
+</g>
+<!-- p3 -->
+<g id="node12" class="node">
+<title>p3</title>
+<polygon fill="#ede9fe" stroke="#333333" points="1321.5,-572 1168.5,-572 1168.5,-521 1321.5,-521 1321.5,-572"/>
+<text text-anchor="middle" x="1245" y="-556.4" font-family="DejaVu Sans" font-size="12.00">3 · Permission vault</text>
+<text text-anchor="middle" x="1245" y="-543.4" font-family="DejaVu Sans" font-size="12.00">(+ déstructif si risque</text>
+<text text-anchor="middle" x="1245" y="-530.4" font-family="DejaVu Sans" font-size="12.00">DANGEROUS)</text>
+</g>
+<!-- p2&#45;&gt;p3 -->
+<g id="edge10" class="edge">
+<title>p2&#45;&gt;p3</title>
+<path fill="none" stroke="#555555" d="M1219.98,-624.18C1224.04,-611.72 1229.54,-594.88 1234.35,-580.15"/>
+<polygon fill="#555555" stroke="#555555" points="1237.11,-580.7 1236.93,-572.23 1231.79,-578.96 1237.11,-580.7"/>
+</g>
+<!-- p4 -->
+<g id="node13" class="node">
+<title>p4</title>
+<polygon fill="#f5f3ff" stroke="#333333" points="1278,-452.5 1136,-414.5 1278,-376.5 1420,-414.5 1278,-452.5"/>
+<text text-anchor="middle" x="1278" y="-417.9" font-family="DejaVu Sans" font-size="12.00">4 · Risque READ ?</text>
+<text text-anchor="middle" x="1278" y="-404.9" font-family="DejaVu Sans" font-size="12.00">→ exécution directe</text>
+</g>
+<!-- p3&#45;&gt;p4 -->
+<g id="edge11" class="edge">
+<title>p3&#45;&gt;p4</title>
+<path fill="none" stroke="#555555" d="M1251.28,-520.74C1255.74,-503.18 1261.84,-479.16 1267.08,-458.5"/>
+<polygon fill="#555555" stroke="#555555" points="1269.87,-458.92 1269.12,-450.48 1264.44,-457.54 1269.87,-458.92"/>
+</g>
+<!-- p5 -->
+<g id="node14" class="node">
+<title>p5</title>
+<polygon fill="#fde68a" stroke="#333333" points="1413.5,-332 1136.5,-332 1136.5,-242 1413.5,-242 1413.5,-332"/>
+<text text-anchor="middle" x="1275" y="-316.4" font-family="DejaVu Sans" font-size="12.00">PAUSE CONFIRMATION</text>
+<text text-anchor="middle" x="1275" y="-303.4" font-family="DejaVu Sans" font-size="12.00">outil WRITE/DANGEROUS → event SSE</text>
+<text text-anchor="middle" x="1275" y="-290.4" font-family="DejaVu Sans" font-size="12.00">« confirmation » avec le plan complet</text>
+<text text-anchor="middle" x="1275" y="-277.4" font-family="DejaVu Sans" font-size="12.00">batché (BUG&#45;075) : une seule</text>
+<text text-anchor="middle" x="1275" y="-264.4" font-family="DejaVu Sans" font-size="12.00">approbation applique toutes les mutations</text>
+<text text-anchor="middle" x="1275" y="-251.4" font-family="DejaVu Sans" font-size="12.00">(resume via confirm / confirm_all)</text>
+</g>
+<!-- p4&#45;&gt;p5 -->
+<g id="edge13" class="edge">
+<title>p4&#45;&gt;p5</title>
+<path fill="none" stroke="#d97706" d="M1277.12,-376.52C1276.85,-365.25 1276.54,-352.62 1276.26,-340.52"/>
+<polygon fill="#d97706" stroke="#d97706" points="1279.05,-340.18 1276.06,-332.25 1273.45,-340.31 1279.05,-340.18"/>
+<text text-anchor="middle" x="1301" y="-351.2" font-family="DejaVu Sans" font-size="11.00">mutation</text>
+</g>
+<!-- p6 -->
+<g id="node15" class="node">
+<title>p6</title>
+<polygon fill="#dcfce7" stroke="#333333" points="1395.5,-161 1142.5,-161 1142.5,-110 1395.5,-110 1395.5,-161"/>
+<text text-anchor="middle" x="1269" y="-145.4" font-family="DejaVu Sans" font-size="12.00">5 · Handler exécuté</text>
+<text text-anchor="middle" x="1269" y="-132.4" font-family="DejaVu Sans" font-size="12.00">6 · Audit JSON&#45;lines</text>
+<text text-anchor="middle" x="1269" y="-119.4" font-family="DejaVu Sans" font-size="12.00">7 · Redaction secrets (redact_payload)</text>
+</g>
+<!-- p4&#45;&gt;p6 -->
+<g id="edge12" class="edge">
+<title>p4&#45;&gt;p6</title>
+<path fill="none" stroke="#555555" d="M1323.61,-388.38C1367.1,-364.44 1426,-332 1426,-332 1426,-332 1426,-242 1426,-242 1426,-242 1358.97,-196.96 1312.51,-165.73"/>
+<polygon fill="#555555" stroke="#555555" points="1314.01,-163.37 1305.81,-161.24 1310.89,-168.02 1314.01,-163.37"/>
+<text text-anchor="middle" x="1438.5" y="-284.2" font-family="DejaVu Sans" font-size="11.00">read</text>
+</g>
+<!-- p5&#45;&gt;p6 -->
+<g id="edge14" class="edge">
+<title>p5&#45;&gt;p6</title>
+<path fill="none" stroke="#555555" stroke-dasharray="5,2" d="M1273.23,-241.95C1272.3,-218.69 1271.17,-190.62 1270.32,-169.29"/>
+<polygon fill="#555555" stroke="#555555" points="1273.11,-169.06 1269.99,-161.18 1267.51,-169.28 1273.11,-169.06"/>
+<text text-anchor="middle" x="1298" y="-205.2" font-family="DejaVu Sans" font-size="11.00">approuvé</text>
+</g>
+<!-- p6&#45;&gt;tools -->
+<!-- p6&#45;&gt;back -->
+<!-- cluster_tools -->
+<g id="node27" class="node">
+<title>cluster_tools</title>
+<polygon fill="#333333" stroke="#333333" points="1319,-56.5 1219,-56.5 1219,-20.5 1319,-20.5 1319,-56.5"/>
+<text text-anchor="middle" x="1269" y="-35.4" font-family="DejaVu Sans" font-size="12.00">cluster_tools</text>
+</g>
+<!-- p6&#45;&gt;cluster_tools -->
+<!-- answer -->
+<g id="node18" class="node">
+<title>answer</title>
+<polygon fill="#dbeafe" stroke="#333333" points="347,-64 151,-64 151,-13 347,-13 347,-64"/>
+<text text-anchor="middle" x="249" y="-48.4" font-family="DejaVu Sans" font-size="12.00">Affichage UI : bloc</text>
+<text text-anchor="middle" x="249" y="-35.4" font-family="DejaVu Sans" font-size="12.00">« N étapes » Notion&#45;style</text>
+<text text-anchor="middle" x="249" y="-22.4" font-family="DejaVu Sans" font-size="12.00">(pensées + outils dépliables)</text>
+</g>
+<!-- done&#45;&gt;answer -->
+<g id="edge21" class="edge">
+<title>done&#45;&gt;answer</title>
+<path fill="none" stroke="#555555" d="M333.07,-103.39C318.5,-92.32 302.14,-79.89 287.76,-68.96"/>
+<polygon fill="#555555" stroke="#555555" points="289.37,-66.66 281.3,-64.05 285.98,-71.12 289.37,-66.66"/>
+</g>
+<!-- final&#45;&gt;answer -->
+<g id="edge22" class="edge">
+<title>final&#45;&gt;answer</title>
+<path fill="none" stroke="#555555" d="M174.01,-96.95C186.01,-87.76 198.68,-78.05 210.13,-69.28"/>
+<polygon fill="#555555" stroke="#555555" points="212.07,-71.32 216.71,-64.24 208.66,-66.88 212.07,-71.32"/>
+</g>
+<!-- fam_vault -->
+<g id="node19" class="node">
+<title>fam_vault</title>
+<polygon fill="#f0f9ff" stroke="#333333" points="1958,-952.5 1720,-952.5 1720,-808.5 1958,-808.5 1958,-952.5"/>
+<text text-anchor="middle" x="1839" y="-938.5" font-family="DejaVu Sans" font-size="10.00">VAULT · service.py (22)</text>
+<text text-anchor="middle" x="1839" y="-927.5" font-family="DejaVu Sans" font-size="10.00">lecture : list_vaults, list_directory,</text>
+<text text-anchor="middle" x="1839" y="-916.5" font-family="DejaVu Sans" font-size="10.00">list_all_files, read_file, read_file_raw,</text>
+<text text-anchor="middle" x="1839" y="-905.5" font-family="DejaVu Sans" font-size="10.00">search_fulltext, search_advanced,</text>
+<text text-anchor="middle" x="1839" y="-894.5" font-family="DejaVu Sans" font-size="10.00">search_paths, get_graph, get_backlinks,</text>
+<text text-anchor="middle" x="1839" y="-883.5" font-family="DejaVu Sans" font-size="10.00">list_tags, suggest_tags, list_recent,</text>
+<text text-anchor="middle" x="1839" y="-872.5" font-family="DejaVu Sans" font-size="10.00">list_backups, diff_backup</text>
+<text text-anchor="middle" x="1839" y="-861.5" font-family="DejaVu Sans" font-size="10.00">écriture : create_file, create_directory,</text>
+<text text-anchor="middle" x="1839" y="-850.5" font-family="DejaVu Sans" font-size="10.00">append_to_file, edit_file, restore_backup</text>
+<text text-anchor="middle" x="1839" y="-839.5" font-family="DejaVu Sans" font-size="10.00">DANGEROUS : delete_file, delete_directory,</text>
+<text text-anchor="middle" x="1839" y="-828.5" font-family="DejaVu Sans" font-size="10.00">move_path, rename_file, rename_directory,</text>
+<text text-anchor="middle" x="1839" y="-817.5" font-family="DejaVu Sans" font-size="10.00">replace_in_files</text>
+</g>
+<!-- fam_web -->
+<g id="node20" class="node">
+<title>fam_web</title>
+<polygon fill="#f0f9ff" stroke="#333333" points="1938.5,-747 1739.5,-747 1739.5,-702 1938.5,-702 1938.5,-747"/>
+<text text-anchor="middle" x="1839" y="-733" font-family="DejaVu Sans" font-size="10.00">WEB · web.py + crawler.py</text>
+<text text-anchor="middle" x="1839" y="-722" font-family="DejaVu Sans" font-size="10.00">web_search · fetch_url</text>
+<text text-anchor="middle" x="1839" y="-711" font-family="DejaVu Sans" font-size="10.00">crawl_site (≤20 pages, même hôte)</text>
+</g>
+<!-- fam_vault&#45;&gt;fam_web -->
+<!-- fam_doc -->
+<g id="node21" class="node">
+<title>fam_doc</title>
+<polygon fill="#f0f9ff" stroke="#333333" points="1922,-666 1756,-666 1756,-621 1922,-621 1922,-666"/>
+<text text-anchor="middle" x="1839" y="-652" font-family="DejaVu Sans" font-size="10.00">DOCUMENTS · documents.py</text>
+<text text-anchor="middle" x="1839" y="-641" font-family="DejaVu Sans" font-size="10.00">create_pdf · create_docx</text>
+<text text-anchor="middle" x="1839" y="-630" font-family="DejaVu Sans" font-size="10.00">create_xlsx · create_csv</text>
+</g>
+<!-- fam_web&#45;&gt;fam_doc -->
+<!-- fam_xlsx -->
+<g id="node22" class="node">
+<title>fam_xlsx</title>
+<polygon fill="#f0f9ff" stroke="#333333" points="1944.5,-580 1733.5,-580 1733.5,-513 1944.5,-513 1944.5,-580"/>
+<text text-anchor="middle" x="1839" y="-566" font-family="DejaVu Sans" font-size="10.00">TABLEURS · spreadsheets.py</text>
+<text text-anchor="middle" x="1839" y="-555" font-family="DejaVu Sans" font-size="10.00">list_xlsx_sheets · xlsx_to_markdown</text>
+<text text-anchor="middle" x="1839" y="-544" font-family="DejaVu Sans" font-size="10.00">search_workbook · analyze_range</text>
+<text text-anchor="middle" x="1839" y="-533" font-family="DejaVu Sans" font-size="10.00">update_xlsx_cells · append_xlsx_rows</text>
+<text text-anchor="middle" x="1839" y="-522" font-family="DejaVu Sans" font-size="10.00">edit_xlsx_structure</text>
+</g>
+<!-- fam_doc&#45;&gt;fam_xlsx -->
+<!-- fam_dup -->
+<g id="node23" class="node">
+<title>fam_dup</title>
+<polygon fill="#f0f9ff" stroke="#333333" points="1929.5,-437 1748.5,-437 1748.5,-392 1929.5,-392 1929.5,-437"/>
+<text text-anchor="middle" x="1839" y="-423" font-family="DejaVu Sans" font-size="10.00">DOUBLONS · duplicates.py</text>
+<text text-anchor="middle" x="1839" y="-412" font-family="DejaVu Sans" font-size="10.00">find_duplicates</text>
+<text text-anchor="middle" x="1839" y="-401" font-family="DejaVu Sans" font-size="10.00">merge_duplicate_notes (DANG.)</text>
+</g>
+<!-- fam_xlsx&#45;&gt;fam_dup -->
+<!-- fam_git -->
+<g id="node24" class="node">
+<title>fam_git</title>
+<polygon fill="#f0f9ff" stroke="#333333" points="1931,-309.5 1747,-309.5 1747,-264.5 1931,-264.5 1931,-309.5"/>
+<text text-anchor="middle" x="1839" y="-295.5" font-family="DejaVu Sans" font-size="10.00">GIT CONNECTÉ · connected.py</text>
+<text text-anchor="middle" x="1839" y="-284.5" font-family="DejaVu Sans" font-size="10.00">git_list_repos · git_get_file</text>
+<text text-anchor="middle" x="1839" y="-273.5" font-family="DejaVu Sans" font-size="10.00">git_search_issues (Gitea/GitHub)</text>
+</g>
+<!-- fam_dup&#45;&gt;fam_git -->
+<!-- fam_sched -->
+<g id="node25" class="node">
+<title>fam_sched</title>
+<polygon fill="#f0f9ff" stroke="#333333" points="1942.5,-153.5 1735.5,-153.5 1735.5,-117.5 1942.5,-117.5 1942.5,-153.5"/>
+<text text-anchor="middle" x="1839" y="-138.5" font-family="DejaVu Sans" font-size="10.00">SCHEDULER · scheduled.py</text>
+<text text-anchor="middle" x="1839" y="-127.5" font-family="DejaVu Sans" font-size="10.00">list/create/delete/run_scheduled_task</text>
+</g>
+<!-- fam_git&#45;&gt;fam_sched -->
+<!-- fam_notify -->
+<g id="node26" class="node">
+<title>fam_notify</title>
+<polygon fill="#f0f9ff" stroke="#333333" points="1917.5,-61 1760.5,-61 1760.5,-16 1917.5,-16 1917.5,-61"/>
+<text text-anchor="middle" x="1839" y="-47" font-family="DejaVu Sans" font-size="10.00">NOTIFICATIONS · notify.py</text>
+<text text-anchor="middle" x="1839" y="-36" font-family="DejaVu Sans" font-size="10.00">notify_external (Discord,</text>
+<text text-anchor="middle" x="1839" y="-25" font-family="DejaVu Sans" font-size="10.00">Telegram, SMTP, webhook)</text>
+</g>
+<!-- fam_sched&#45;&gt;fam_notify -->
+</g>
+</svg>

docs/features/agent-phase4-166-168-170.md

@@ -0,0 +1,98 @@
+# #166 · #168 · #170 — Agent IA phase 4 : doublons, notifications externes, tâches planifiées
+
+> **Statut :** ✅ livré — **Effort :** ~5 jours | **Impacts :** 🟢
+> **Références :** [Roadmap](../ROADMAP.md#--évolutions-agent-ia-liste-v12--phase-4--ids-obsigate-165--178) · [Changelog](../../CHANGELOG.md)
+> **Guides :** [Assistant IA & Forge](../GUIDES/ASSISTANT_IA_FORGE.md) · [API REST](../GUIDES/API_REST.md) · [MCP](../GUIDES/MCP.md)
+
+## 1. Périmètre
+
+Trois items de la liste v1.2 « Phase 4 » livrés ensemble car ils partagent le
+même socle (registre `@tool`, stores JSON verrouillés, notifications) :
+
+| ID | Fonctionnalité | Entrées |
+|---|---|---|
+| #166 | Détection & fusion de doublons | `backend/services/duplicates.py`, `backend/tools/duplicates.py`, `backend/routers/duplicates.py` |
+| #168 | Notifications externes Discord / Telegram / SMTP / webhook | `backend/notify.py`, `backend/tools/notify.py`, `backend/routers/notify.py` |
+| #170 | Tâches planifiées type cron | `backend/scheduler.py`, `backend/tools/scheduled.py`, `backend/routers/scheduler.py` |
+
+Règle transverse respectée : **tout nouvel outil = `@tool` + libellé
+`labels.py` + clés i18n `ai.step.*` FR/EN + tests** (cf. `ai-tools-roadmap.md` §2).
+
+## 2. #166 — Doublons
+
+- **Score déterministe stdlib** (`similarity_score`) : Jaccard sur tokens
+  (frontmatter exclu, accents conservés) à 70 % + similarité du titre/first-line
+  (`difflib`) à 30 %. Pas de dépendance embeddings — l'index sémantique #70
+  reste un raffinement optionnel, pas un prérequis.
+- **Scan borné** : 500 fichiers `.md` max, 200 Ko/fichier, pré-filtre Jaccard
+  avant le score complet, `truncated` exposé quand le plafond est atteint.
+- **Fusion jamais sans filet** : backup des 2 fichiers avant écriture,
+  outil `merge_duplicate_notes` en `DANGEROUS` (carte « Tout approuver »),
+  route `POST /api/duplicates/merge` exige `{confirm: true}`, stratégies
+  `append` (défaut, avec marqueur d'origine) / `prefer_target` / `prefer_source`.
+- **Outils** : `find_duplicates` (READ), `merge_duplicate_notes` (DANGEROUS).
+
+## 3. #168 — Notifications externes
+
+Canaux `discord` (webhook `discord.com`), `telegram` (Bot API + `chat_id`),
+`smtp` (stdlib, STARTTLS + login) et `webhook` générique (JSON
+`{event, title, message, timestamp, source}`).
+
+- **Secrets** : jamais dans `notify_channels.json` — store `notify_secrets.json`
+  (0600) ou `OBSIGATE_NOTIFY_SECRET_<ID>` (même motif que #9 / BUG-026) ;
+  l'API n'expose que `***` + `has_secret`. Le token Telegram peut aussi venir
+  de `OBSIGATE_TELEGRAM_BOT_TOKEN`.
+- **SSRF** : `validate_webhook_url` / `is_safe_target` réutilisés pour les
+  webhooks génériques et Telegram ; Discord valide son préfixe d'URL.
+- **Déclencheurs** : `manual`, `schedule_failure`, `schedule_success`,
+  `duplicate_found` — choisis par canal. `broadcast()` n'échoue jamais en bloc
+  (résultat par canal, `last_error` persisté).
+- **CRUD admin** (`/api/notify/channels`), test d'envoi authentifié
+  (`POST /api/notify/test`), outil `notify_external` (WRITE → confirmation).
+
+## 4. #170 — Tâches planifiées
+
+Store `data/scheduled_tasks.json` (RLock, écriture atomique tmp+replace).
+Actions = outils existants, aucun nouveau chemin d'écriture :
+
+- `create_file` / `append_to_file` → `backend.services.mutations` ;
+- `notify` → `backend.notify.broadcast`.
+
+Planifications `interval_hours` (≥ 0,25), `daily_time` (`HH:MM`) et `once_at`
+(ISO-8601, one-shot désactivé après exécution). `tick()` exécute les tâches
+dues, enregistre `last_status`/`last_error`/`run_count`/`next_run_at` et émet
+`schedule_failure` via #168 (sauf quand l'action elle-même est `notify` —
+anti-récursion). Boucle de fond dans le lifespan de `main.py` (tick 60 s via
+`asyncio.to_thread`, désactivable par `OBSIGATE_SCHEDULER=0`).
+
+Outils : `create_scheduled_task` / `list_scheduled_tasks` /
+`delete_scheduled_task` / `run_scheduled_task_now` (WRITE sauf list).
+La création vérifie l'accès au vault **et** son existence (404 sinon).
+
+## 5. API REST (toutes avec `response_model`)
+
+| Route | Rôle |
+|---|---|
+| `GET /api/duplicates?vault&threshold&limit&subdir` | paires candidates |
+| `POST /api/duplicates/merge` | fusion (`confirm: true` obligatoire) |
+| `GET/POST /api/notify/channels`, `PATCH/DELETE /api/notify/channels/{id}` | CRUD admin |
+| `POST /api/notify/test` | test broadcast ou canal ciblé |
+| `GET/POST /api/scheduler/tasks`, `PATCH/DELETE /api/scheduler/tasks/{id}`, `POST …/run` | CRUD + exécution manuelle |
+
+## 6. Tests
+
+`tests/test_duplicates.py` (16), `tests/test_notify_channels.py` (14),
+`tests/test_scheduler.py` (18) : services, routes (fixture `client`,
+auth désactivée), outils (confirmation `DANGEROUS` vérifiée), stores isolés
+en tmp, réseau mocké (jamais d'Internet en CI). Labels couverts par le
+garde-fou `test_tool_labels.py` (tout outil IN_APP doit avoir son libellé).
+
+## 7. Limites assumées (V1)
+
+- Similarité lexicale (pas d'embeddings) — seuils réglables par l'agent.
+- Pas d'UI dédiée (API + agent uniquement) ; les clés i18n des étapes
+  existent déjà pour la section « N étapes ».
+- Scheduler in-process (pas de persistance distribuée, tick 60 s) ;
+  Redis/APScheduler resteraient l'option multi-workers.
+- SMTP sans OAuth2 (login STARTTLS) ; Slack natif non ciblé (webhook
+  générique compatible `incoming-webhook` utilisable tel quel).

docs/features/create-file-xlsx-186.md

@@ -0,0 +1,96 @@
+# #186 — Création d'un fichier Excel depuis « Créer un fichier »
+
+> **Statut :** ✅ livré le 2026-10-05 | **Effort :** 0,5 jour | **Impact :** 🟢
+> **Références :** [Roadmap](../ROADMAP.md) · [Changelog](../../CHANGELOG.md) ·
+> [Guide Recherche, PDF, Excel & Excalidraw](../GUIDES/RECHERCHE_PDF_EXCALIDRAW.md) ·
+> [#153 — Visionneuse XLSX](./xlsx-viewer.md)
+
+## 1. Constat
+
+ObsiGate sait **lire et éditer** les classeurs depuis #152/#153, et l'assistant IA sait
+en **produire** un (`create_xlsx`, #92). Mais la modale « Créer un fichier » — celle
+du menu contextuel d'un vault / d'un dossier et de la palette de commandes —
+ne proposait que des formats **texte** :
+
+`.md`, `.txt`, `.py`, `.js`, `.json`, `.yaml`, `.sh`, `.ps1` (+ Excalidraw).
+
+Démarrer un classeur depuis l'UI imposait donc de passer par l'IA (avec
+confirmation) ou de déposer un fichier existant dans le vault. Le point de départ
+naturel manquait alors que l'éditeur complet était disponible.
+
+## 2. Livré (A1-A3)
+
+### A1 — Option Excel dans la liste des types
+
+`frontend/js/ui.js`, `FileOperations.showCreateFileModal()` : ajout de
+`<option value=".xlsx">` dans le `<select id="file-ext-select">`, après `.json`
+(ordre : formats texte, puis formats enrichis, comme `.excalidraw`).
+
+Au passage, les **dix libellés** du sélecteur passent en i18n
+(`modal.ext_md`, `modal.ext_txt`, …, `modal.ext_xlsx`) : ils étaient des chaînes
+françaises codées en dur, ce qui exposait un texte non traduit en mode EN et
+violait la règle « tout texte d'interface existe en FR et en EN ». Les deux
+locales sont alignées (`tests/test_i18n_parity.py`).
+
+Aucun changement pour les autres formats : le nom saisi sans extension reçoit
+celle choisie (`name.endsWith(ext) ? name : name + ext`), donc un nom déjà
+suffiché n'est jamais doublé.
+
+### A2 — Un vrai classeur côté backend
+
+Le point non évident : `POST /api/file/{vault}` **écrit du texte**
+(`file_path.write_text(content)`), et la modale poste `content: ""`. Un `.xlsx`
+n'est pas un fichier texte mais une **archive OPC** (un ZIP) : écrire la charge
+utile vide produisait un fichier de 0 octet que ni `openpyxl`, ni la visionneuse,
+ni Excel n'ouvrent — l'utilisateur aurait vu une erreur à l'ouverture, ou pire,
+un fichier corrompu.
+
+`backend/services/mutations.py` :
+
+- `_empty_xlsx_bytes()` construit l'archive avec openpyxl (une feuille `Feuille1`,
+  le titre par défaut déjà utilisé par l'outil IA `create_xlsx`) — import paresseux,
+  comme le reste du module qui garde openpyxl optionnel à l'import ;
+- `create_file()` écrit ces octets (`write_bytes`) pour cette extension et ignore
+  `content`, qui n'a pas de sens pour un classeur ; `size` renvoie le nombre
+  d'octets réellement écrits (et non `len(content)`, qui aurait valu 0) ;
+- même garde-fou que `.excalidraw` : le squelette est injecté par le **service**,
+  donc la palette, le glisser-déposer, l'IA et l'API en bénéficient, pas seulement
+  la modale.
+
+`openpyxl` reste importé à la demande : un vault sans tableur ne paie pas l'import.
+
+### A3 — Tests
+
+- `tests/test_api_main.py::TestFileCRUD` — `test_create_xlsx_empty_workbook` : le
+  fichier créé est relu par `openpyxl` (`sheetnames == ["Feuille1"]`) **et** servi
+  par `GET /api/file/{vault}` avec `is_xlsx: true` (donc lisible par la visionneuse) ;
+  `test_create_xlsx_in_new_subdir` couvre la création dans un dossier inexistant
+  (auto-créé). Non-régression : sans A2, l'archive serait vide et les deux tests
+  échoueraient.
+- `tests/e2e/xlsx-viewer.spec.js` — bloc « création depuis l'UI » : l'option
+  `.xlsx` existe et son libellé vient des locales, la création passe par le menu
+  contextuel d'un dossier, et le classeur s'ouvre dans la grille (`.xlsx-table` +
+  onglet `Feuille1`) ; l'API est interrogée pour confirmer `is_xlsx`. Le fichier est
+  supprimé en fin de test (le run ne doit pas salir `test_vault/`).
+
+## 3. Limites assumées
+
+- **Le nom de feuille est `Feuille1`**, en dur. Un vrai *nouveau classeur* de
+  Google Sheets le demande ; ici le classeur s'ouvre sur sa seule feuille et
+  l'utilisateur la renomme via le menu Structure. La modale reste celle d'un
+  éditeur de texte, volontairement simple.
+- **`.csv` reste absent de la liste**, alors que le backend l'accepte
+  (`SUPPORTED_EXTENSIONS`) et que la visionneuse sait l'éditer comme tableur
+  (#156-A14). L'écart est réel mais hors périmètre de #186 ; le même correctif
+  s'appliquerait (une ligne dans le `<select>`).
+- **`frontend/app.js` (monolithe obsolète, non chargé par `index.html`)**
+  duplique l'ancienne liste sans `.xlsx`. Le code vivant est dans `frontend/js/`;
+  ce fichier n'a pas été touché.
+- L'outil IA `create_xlsx` reste le chemin pour un classeur **rempli** : la modale
+  crée une grille vierge, comme un `.md` vierge.
+
+## 4. Historique
+
+| Date | Événement |
+|---|---|
+| 2026-10-05 | #186 ouvert puis livré dans la foulée : option `.xlsx` + squelette openpyxl dans `create_file()` |

docs/features/desktop-tauri.md

@@ -86,3 +86,40 @@
   - Python 3.11 embed — téléchargé depuis python.org
   - NSIS (Windows) — pour le générateur d'installateur `.exe`
   - AppImageKit (Linux) — pour le packaging portable
+
+## G. Gestion des vaults & dossiers — #159 — ✅ livré (2026-10-02, v2.50.0)
+
+- [x] Retrait vault/dossier racine par menu contextuel (`ContextMenuManager`,
+  branche `vault`, gate `isTauriEnv()`) → `removeRoot()` dans `desktop.js` :
+  résolution vault/dossier via `list_vaults`/`list_dirs`, confirmation i18n,
+  `remove_vault`/`remove_dir` + `restart_backend` + reload — déregistration
+  seule, zéro suppression disque.
+- [x] Section Configuration `cfg-desktop-roots` (+ entrée TOC i18n FR/EN) :
+  liste des roots injectés, retrait par ligne, ajout vault
+  (`pickAndAddVault`, existant) et ajout dossier (nouvelle commande Rust
+  `pick_folder` — sélecteur sans effet de bord, contrairement à
+  `pick_vault_folder` réservé au wizard). Section masquée hors desktop.
+- [x] Jump list rafraîchie après chaque ajout/retrait de vault
+  (`refresh_jumplist()`).
+- [x] i18n FR/EN (7 clés `config.*`/`desktop.*`), garde-fou ACL automatique
+  (`test_frontend_invokes_are_acl_allowed` : toute commande invoquée par le
+  frontend doit figurer dans `permissions/commands.toml`).
+- [x] Tests : `tests/frontend/desktop-roots.test.mjs` (4 — helpers purs +
+  gating hors desktop), inscrit au CI ; suites frontend/JSDOM vertes,
+  `cargo test` 25 passed.
+
+## H. Premier lancement & section Configuration harmonisée — #160 — ✅ livré (2026-10-02, v2.51.0)
+
+- [x] `default_first_run_config(home)` (pure, testée) : `<home>/ObsiGate`
+  monté comme vault « ObsiGate » ET comme `vault_path`, racine home nommée
+  d'après son dernier segment — remplace `voute_obsidian` + le « bruno »
+  codé en dur ; les champs fenêtre de la config existante sont préservés.
+- [x] `Prise en main.md` : contenu embarqué (`include_str!("prise_en_main.md")`),
+  écrit au premier lancement **si absent** (jamais d'écrasement).
+- [x] Section `cfg-desktop-roots` refondue : markup à classes (zéro style
+  inline), bloc CSS `#160` sur variables (`desktop-roots-*`, motif
+  `webauthn-key-item`), boutons `.config-btn-sm` (primaire/secondaire),
+  override mobile 44px dans le bloc `#config-modal`.
+- [x] Tests : `test_default_first_run_config`, `test_welcome_doc_embedded`
+  — `cargo test` 28 passed ; suites frontend vertes (validate-imports,
+  unit, config-mobile, desktop-roots, settings-order) + E2E locale.

docs/features/directed-shares-196.md

@@ -0,0 +1,143 @@
+# #196 — Partage dirigé entre utilisateurs
+
+> **Statut :** livré | **Ouvert :** 2026-10-10 | **Type :** feature (sharing + auth)
+
+## Problème
+
+Le seul partage existant (#85) était un lien **public** : quiconque possède
+l'URL lit le document, sans compte ni session. Il n'existait aucun moyen de
+partager un document *à un utilisateur précis* de la plateforme — un
+utilisateur ne pouvait ni adresser un document à un autre, ni consulter les
+documents qu'on lui adresse, ni (côté créateur) retirer ce partage.
+
+## Décision d'architecture
+
+Deux formes étaient possibles :
+
+1. **Réutiliser le partage par token existant, dirigé** (retenu) — le record
+   `data/shares.json` gagne `shared_with: [usernames]`. Si la liste est non
+   vide, les pages `/s/{token}` (et `/pdf`, `/raw`) exigent une session et
+   n'acceptent que créateur + admin + destinataires. Vide/absent : le
+   comportement public historique est inchangé (rétrocompatibilité totale,
+   zéro migration — les shares existants n'ont pas le champ).
+2. Octroyer le vault entier au destinataire (`update_user {"vaults": …}`)
+   (écartée) — accès lecture-**écriture** au vault complet au lieu d'un
+   document en lecture seule ; c'est le modèle « collaborateur de vault »,
+   pas « partager un document ». Reste la bonne réponse pour ce besoin-là.
+
+Points de sécurité délibérés :
+
+- **404, jamais 403/401, sur la gate** — un visiteur sans session (ou un
+  utilisateur non destinataire) apprend le même « Share not found or
+  expired » qu'un token inventé : l'existence d'un token dirigé n'est pas
+  confirmable de l'extérieur.
+- **`GET /api/shares` scopé** (correctif au passage) — un non-admin ne voit
+  que les partages qu'il a créés **ou reçus`** (avant : tout le monde voyait
+  tous les partages, fuite préexistante devenue intenable avec du user-to-user).
+  Un admin voit tout.
+- **Révocation réservée au créateur/admin** — un destinataire ne peut pas
+  casser l'accès des autres.
+- Les **destinataires sont validés** à la création (`get_user`) : pas de lien
+  mort vers un compte inexistant.
+
+## Mise en place
+
+| Élément | Où |
+|---|---|
+| Store : champ `shared_with`, param de `create_share` | `backend/share.py` |
+| Gate `_gate_share()` + branchement `/s/{token}`, `/s/{token}/pdf`, `/s/{token}/raw` | `backend/routers/sharing.py` |
+| Scope de `GET /api/shares` (non-admin = créés + reçus) | `backend/routers/sharing.py`, `backend/share.py::list_shares(user=…)` |
+| Révocabilité créateur/admin uniquement | `backend/routers/sharing.py::api_share_revoke` |
+| Validation des destinataires à la création | `backend/routers/sharing.py::api_share_create` |
+| `ShareModel.shared_with` | `backend/schemas.py` |
+| Dialogue : radio public/dirigé + champ destinataires (virgules) | `frontend/js/config.js::openShareDialog` |
+| Destinataires affichés dans la vue « déjà partagé » | `frontend/js/config.js` |
+| Dashboard : cartes reçues (« Partagé par X », ouverture `/s/`, pas de bouton révoquer) | `frontend/js/dashboard.js::DashboardSharedWidget` |
+| i18n FR/EN (6 clés config.* + dashboard.shared_by) | `frontend/locales/{fr,en}.json` |
+
+Ce qui est gratuit par construction : lecture seule (le destinataire ne
+passe jamais par l'éditeur), expiration, compteur d'accès, suivi des
+renommages (`update_shares_after_rename`), masquage des secrets
+(`redact_file_content` déjà dans les 3 routes `/s/*`), isolation des
+dossiers perso #194 (le destinataire ne voit jamais l'arbre du vault de
+l'auteur, seulement le document rendu).
+
+## Tests
+
+`tests/test_directed_shares.py` (9) : création dirigée, destinataire inconnu
+→ 400, anonyme → 404 / destinataire + créateur → 200, non-destinataire →
+404, lien public toujours anonyme, scope de `/api/shares`, destinataire ne
+peut pas révoquer (403), créateur révoque, la révocation coupe l'accès.
+
+## Limites connues
+
+- `shared_with` est une liste plate d'usernames — pas de groupes. Ajouter
+  des groupes quand le besoin sera réel.
+- Pas de notification push : le destinataire découvre les partages reçus au
+  rechargement du dashboard (badge/rafraîchissement suffisent ; SSE existe
+  si un vrai push est demandé).
+- La date d'« expiration » reste globale au partage (pas par destinataire).
+
+## Itération 2 — visibilité & recherche (2026-10-11)
+
+| Élément | Où |
+|---|---|
+| Icône « partagé » (share-2 bleu) sur les fichiers de l'arborescence | `frontend/js/sidebar.js` (`loadSharedPaths` + `sharedFileIconSync`, appliqué dans `loadDirectory` et `incrementalLoadDirectory`) |
+| Dossier virtuel **Partage** à la racine du home du destinataire | `frontend/js/sidebar.js` (injection `virtual-share` + rendu, clic fichier → `/s/{token}`) |
+| Recherche des documents reçus | `backend/services/search.py::_shared_results` (merge dans `search_vaults` avant pagination), `backend/routers/search.py` (passe `username`), `SearchResultItem.share_token` |
+| Clic sur un résultat reçu → page de partage | `frontend/js/search.js` |
+| Invalidation du cache front | `invalidateSharedPaths()` exporté, appelé par `openShareDialog` après création/révocation |
+
+Décisions :
+
+- **Dossier virtuel, pas physique** : l'indexeur exclut les symlinks
+  (sécurité path traversal) et un dossier réel ferait double indexation.
+  La source de vérité reste `data/shares.json`.
+- **Recherche à la volée** (`_shared_results`) : le contenu des documents
+  reçus est lu au moment de la requête, uniquement pour les destinataires —
+  jamais indexé dans le TF-IDF global, donc aucune fuite vers un
+  non-destinataire (testé). ponytail: lecture disque par requête, plafond
+  ~quelques centaines de partages reçus par user ; indexer dans le TF-IDF
+  avec un champ "destinataires" si le volume devient réel.
+- Icône déterminée côté client via `/api/shares` (déjà scopé #196) : la
+  liste des partages actifs "créés OU reçus" suffit — le créateur voit
+  l'icône sur son fichier source, le destinataire voit le dossier Partage.
+
++2 tests : `test_search_finds_received_share_for_recipient`,
+`test_search_does_not_leak_share_to_other_user`.
+
+
+## Itération 3 — ouverture en onglet (2026-10-11)
+
+- **Résolution serveur** : `_resolve_shared_file()` (`backend/routers/files_read.py`)
+  mappe `home-<user>/Partage/<fichier>` vers le fichier source pour les routes
+  `/api/file`, `/api/file/raw`, `/api/file/download`. Résolu AVANT l'ACL vault
+  (le home virtuel peut ne pas être dans `user.vaults`) — l'autorisation réelle
+  est l'appartenance au partage, vérifiée dans le resolver (destinataire seul).
+- **Front** : clic dossier Partage → simple dépliage (plus de `openNav`, fix
+  « Directory not found ») ; clic fichier reçu → `TabManager.openPreview/openPersistent`
+  (arbre, recherche, dashboard) — même parcours qu'un fichier ordinaire.
+- `POST /api/share` : `path` vide/null → 400 (un share `path: None` cassait
+  `/api/shares` en 500).
++2 tests : ouverture applicative du fichier reçu (file + raw), résolution
+scopée par utilisateur (home d'autrui → 403).
+
+
+## Itération 4 — correctifs d'ouverture (2026-10-11)
+
+- **Le partage EST l'autorisation** : après résolution `Partage/…`, l'ACL du
+  vault source n'est plus appliquée (`elif` dans `/api/file`, raw, download) —
+  un destinataire sans accès au vault émetteur ouvrait « Accès refusé à la
+  vault '…' », précisément le cas d'usage du partage. L'appartenance au
+  partage (vérifiée dans `_resolve_shared_file` via `list_shares(user=…)`)
+  reste la seule autorisation.
+- **Chemin canonique `Partage/<token>/<nom>`** : lève l'ambiguïté de deux
+  partages homonymes (le token identifie le partage exact). Fallback par nom
+  conservé pour les liens historiques. Transporté par l'arbre (`data-path`),
+  la recherche et le dashboard.
+- **« Reçu » = adressé à moi** : sidebar `_loadReceivedShares` et dashboard
+  filtrent désormais `shared_with.includes(me)` — un admin voyant TOUS les
+  partages (`/api/shares` non scopé pour lui) n'a plus les partages d'autres
+  comptes dans son dossier Partage (source des « File not found »).
++3 tests : destinataire sans accès au vault source (200), disambiguïsation
+par token, home d'autrui (403). 14 tests au total.

docs/features/file-chat-169.md

@@ -0,0 +1,272 @@
+# Chat intégré par fichier — #169
+
+- **Statut :** ✅ livré le 2026-10-08
+- **Effort :** 3-4 j (réalisé en 1 session) | **Impact :** 🟢
+- **Transport :** SSE existant (#62) — pas de second WebSocket
+
+## Ce qui a été livré
+
+### Backend
+
+- **Store `backend/file_chat.py`** — historique JSON par paire
+  `(vault, path)` sous `data/chats/` :
+  - nom de fichier = SHA-256 de `vault\0path` (32 premiers hex) : aucun
+    séparateur de chemin utilisateur dans le nom → traversal impossible ;
+  - plafond **500 messages** par fichier (les plus vieux supprimés) ;
+  - texte tronqué à **4000 caractères** ;
+  - écriture atomique (tmp + move) ; fichier corrompu → historique vide
+    (fallback, pas de crash).
+- **Routes `backend/routers/file_chat.py`** (tag OpenAPI « Files » dérivé) :
+  - `GET /api/file/{vault}/chat?path=…` → historique chronologique ;
+  - `POST /api/file/{vault}/chat` `{path, text}` → ajout + broadcast SSE ;
+  - garde commune : `require_auth` + `check_vault_access` +
+    `resolve_safe_path` (traversal → 403/500 via le handler `ServiceError`) ;
+  - `text` ou `path` vides → 400 ; vault inconnu → 404.
+- **Schémas** `ChatMessageItem` / `ChatHistoryResponse` /
+  `ChatMessageResponse` dans `backend/schemas.py` (`response_model` sur les
+  deux routes).
+- **Broadcast** : `sse_manager.broadcast("chat_message", {vault, path, message})`.
+
+### Frontend
+
+- **`frontend/js/filechat.js`** — panneau latéral :
+  - bouton 💬 (`.btn-chat`) dans le groupe nav de la toolbar fichier
+    (viewer.js), toggle ouvre/ferme ;
+  - historique rendu chronologiquement, bulles « mine » à droite,
+    `textContent` pour le corps (pas d'injection HTML) ;
+  - envoi POST optimiste + dédoublonnage par `id` à la réception SSE ;
+  - panneau fermé / autre fichier → **toast** « Nouveau message de … »
+    (silencier si c'est son propre message).
+- **`frontend/js/sync.js`** — listener SSE `chat_message` avec import
+  dynamique de `filechat.js` (pas de cycle d'imports).
+- **CSS** bloc `#169` : panneau fixe 340 px, **plein écran ≤ 768 px**,
+  variables CSS avec fallbacks, input 16 px (anti-zoom iOS).
+- **i18n** : 10 clés `chat.*` dans `fr.json` et `en.json`.
+
+## Tests
+
+- `tests/test_file_chat.py` — 15 tests : roundtrip store, isolation par
+  fichier, plafond de rétention, troncature, traversal hashée, fichier
+  corrompu, routes (200/400/404/403), fixture autouse isolant `CHAT_DIR`.
+- `tests/frontend/filechat.test.mjs` — 6 tests JSDOM : empty state, rendu
+  chronologique + classe `mine`, anti-injection HTML, append live + dédup
+  par id, isolation inter-fichiers, toggle. Locales réellement chargées
+  (fetch simulé vers `frontend/locales/`).
+- Les deux sont ajoutés au pipeline CI (`.gitea/workflows/ci.yml`).
+
+## #190 — Suivi du document, chat général, ordre des onglets (2026-10-08)
+
+### A. Le panneau suit le document
+
+- En-tête du panneau : `.file-chat-target` affiche le titre du document
+  (l'attribut `title` porte le chemin complet).
+- `followFileChat(vault, path, title)` est appelé en tête de `renderFile()` :
+  panneau ouvert + autre document → re-cible (reload de l'historique) ;
+  panneau fermé → no-op. Le bouton 💬 transmet `data.title`.
+
+### B. Chat général en onglet sidebar
+
+- Onglet `#sidebar-tab-chat` (dernier, `message-circle`) + panneau
+  `#sidebar-panel-chat` (liste + 📎 + saisie + Envoyer, Entrée = envoyer).
+- **Store** : rien de nouveau — les sentinelles `GLOBAL_VAULT="__global__"` /
+  `GLOBAL_PATH="general"` réutilisent `add_message`/`get_messages`.
+- **Routes** : `GET/POST /api/chat`, `POST /api/chat/upload`,
+  `GET /api/chat/attachment/{name}`.
+- **Pièces jointes** : allow-list d'extensions (11 : images + vidéos), 25 MB,
+  nom de stockage = UUID (le nom client n'est jamais utilisé), résolution
+  par comparaison au nom + allow-list (aucun chemin utilisateur).
+- **Messages non lus** : timestamp de dernière visite dans
+  `localStorage['obsigate-chat-unread']`, comptage des messages plus récents
+  d'un autre auteur, pastille rouge `99+` sur l'onglet, effacée à l'ouverture.
+- **URL** : linkification `http(s)://` au rendu (texte autour en `TextNode`,
+  donc pas d'injection).
+- **SSE** : `vault === "__global__"` route vers la liste sidebar (append +
+  clear) ou vers badge + toast selon que l'onglet est actif.
+
+### C. Ordre des onglets + filtre = recherche chat
+
+- `index.html` : le bloc `.sidebar-filter` est **déplacé après** `.sidebar-tabs`.
+- `switchSidebarTab` : placeholder `sidebar.filter_chat`, dispatch `chat`.
+- `initSidebarFilter` (`sidebar.js`) : `routeFilter`/`routeClear` routent
+  vers `filterChatMessages()` (texte **et** auteur, insensible à la casse).
+
+## #191 — Suppression, messages privés, boîte compacte, link preview (2026-10-08)
+
+### A. Suppression d'un post
+
+- `DELETE /api/chat/{id}` et `DELETE /api/chat/dm/{peer}/{id}` :
+  **auteur du message ou admin** (403 sinon), 404 si l'id n'existe pas.
+- Store : `delete_message(vault, path, id)` — écriture atomique,
+  `False` si absent ; broadcast SSE `chat_deleted` `{vault, path, id}`.
+- Frontend : bouton 🗑 (`.file-chat-del`, visible au survol) rendu dans
+  `_messageEl` uniquement si l'URL de suppression est fournie **et**
+  que l'utilisateur est auteur/admin ; `confirm()` natif ; retrait local
+  + retrait en direct chez tous via `onChatDeleted` (relais `sync.js`).
+
+### B. Messages privés 2 utilisateurs
+
+- Store : `DM_VAULT = "__dm__"`, `dm_path(a, b)` = paire **triée** → les
+  deux participants lisent/écrivent le même document, indépendamment de
+  l'ordre.
+- Routes : `GET /api/chat/users` (destinataires — usernames +
+  display_names, **sans soi-même**, aucun hash/mot de passe exposé),
+  `GET/POST /api/chat/dm/{username}` (404 utilisateur inconnu, 400 DM à
+  soi), `DELETE /api/chat/dm/{username}/{id}`.
+- Frontend : rangée de pastilles `.chat-channels` (« Général » + un
+  bouton par utilisateur) au-dessus du fil ; `_channel` état courant,
+  `_channelKey`/`_channelUrl`/`_channelDelUrl` ; placeholder dédié
+  `chat.placeholder_dm` ; non-lus **par canal** (compteurs dans
+  `localStorage`, l'ancien mélange timestamp/compteur est devenu un
+  compteur unique `{"general": n, "dm:x": n}`, remis à zéro à l'ouverture,
+  pastille = total) ; les DM SSE routés par `_pairOf(path)`.
+
+### C. Boîte d'édition compacte
+
+- Bouton d'envoi réduit à une icône `send` (`.file-chat-send-icon`) dans
+  les deux formulaires (panneau document + sidebar) ; la saisie garde
+  toute la largeur. `safeCreateIcons()` à la fin du `_renderShell`.
+
+### D. Link preview
+
+- `build_preview(text)` (store) : 1ʳᵉ URL du texte → garde SSRF
+  `_assert_public_http_url` (host privé/loopback rejeté, schémas non
+  http refusés) → `httpx.get` 5 s, 512 Ko, `follow_redirects` (limite
+  httpx = 20) → parse OG par regex (`og:title` avec repli `<title>`,
+  `og:description`, `og:image`, `og:site_name`) →
+  `{url, title, description, image, site}`.
+- **Best-effort** : n'importe quelle erreur (URL morte, timeout, garde)
+  → `None`, le message passe quand même ; cache borné **200 entrées**.
+- Frontend : `_previewEl` rend une carte cliquable (vignette lazy
+  `no-referrer`, site en capitales, titre/description tronqués 2 lignes)
+  sous le corps du message.
+- Schéma : `ChatMessageItem.preview`.
+
+### Tests #191
+
+- pytest `TestDelete` (3), `TestPrivateChat` (8), `TestLinkPreview` (8,
+  dont le happy path avec `httpx.get` mocké — un `max_redirects`
+  inexistante sur `httpx.get` levait un TypeError silencieusement avalé
+  par le `try`, testé par `test_build_preview_happy_path_parses_og`).
+- JSDOM `filechat.test.mjs` +5 : carte preview, bouton supprimer
+  (droit auteur/admin), `onChatDeleted`, compteurs non-lus,
+  routage DM isolé du général (16 au total).
+
+## #192 — Saisie auto-agrandissante, accusé de réception, vignette de lien (2026-10-08)
+
+### A. Boîte de saisie qui grandit avec le texte
+
+`<input type="text">` → `<textarea rows="1">` (panneau document créé dans
+`_renderShell()`, sidebar statique dans `index.html`). `_autoGrow(el)`
+pose `height: auto` puis `min(scrollHeight, 160)px` à chaque `input`, la
+règle CSS `textarea.file-chat-input` ajoute `resize: none` +
+`overflow-y: auto` (au-delà du plafond la zone défile) et la hauteur repasse
+à une ligne après l'envoi. `Entrée` (sans `Maj`) est interceptée dans les
+deux formulaires → envoi, `Maj+Entrée` garde le retour à la ligne. Le
+placeholder de la sidebar est aussi appliqué à l'init (`t()`), le HTML ne
+portant que le FR.
+
+### B. Accusé de réception (✓ envoyé / ✓✓ lu)
+
+- **Store** (`backend/file_chat.py`) : le document de conversation gagne
+  `read = {username: dernier_ts}` (`get_read()` / `mark_read()`), sous le
+  `_LOCK` du read-modify-write partagé avec l'ajout et la suppression.
+- **API** : les trois `GET` d'historique renvoient `read` (schéma
+  `ChatHistoryResponse.read`) ; nouveau `POST /api/chat/read`
+  (`ChatReadResponse`) avec `_check_read()` — général = tout membre, DM =
+  pair uniquement (403 sinon), fichier = ACL vault + `resolve_safe_path` —
+  qui marque la lecture et diffuse `chat_read`
+  `{vault, path, user, ts, read}` en SSE.
+- **Client** (`filechat.js`) : carte de lecture par surface (`_fileRead`,
+  `_channelRead`). Un message est « lu » dès qu'un **autre** participant a
+  un `ts ≥` celui du message (ma propre lecture ne compte pas).
+  `_messageEl()` affiche `✓`/`✓✓` (`.file-chat-status`, bleu accent quand
+  lu) ; `_applyRead()` fait basculer les indicateurs affichés ;
+  `_syncRead()` fusionne une carte reçue ; `_markRead(vault, path)` (POST
+  fire-and-forget) est émis à l'ouverture d'une conversation **et** à la
+  réception d'un message pendant qu'elle est affichée. `onChatRead()`
+  (relais `chat_read` ajouté dans `sync.js`) actualise en direct et
+  notifie l'expéditeur par toast `chat.read_by` quand un de ses messages
+  passe à ✓✓ — jamais pour son propre écho.
+
+### C. BUG-109 — vignette des tuiles de lien
+
+`img-src 'self' data: blob:` interdit toute `og:image` distante, et une
+`og:image` relative était résolue contre l'origine d'ObsiGate (404).
+`_proxy_image(img_url, page_url)` téléverse la vignette à l'envoi dans
+`chat_uploads` via `save_attachment()` (allow-list + nom UUID) et renvoie
+`/api/chat/attachment/<uuid>` — résolution `urljoin` contre la page,
+garde SSRF réutilisée, plafond `PREVIEW_IMAGE_MAX` (2 Mo), dérivation de
+l'extension depuis le `content-type`. Échec isolé → `image = ""`, la
+carte reste (jamais de message perdu).
+
+### Tests #192
+
+- pytest `TestReadReceipts` (7) : roundtrip store, messages préservés,
+  `POST /api/chat/read` (enregistrement + restitution par le `GET`),
+  403 DM hors pair, 400 champs manquants, ACL vault, broadcast `chat_read`
+  (spy sur `sse_manager`) ; `TestLinkPreview` +2 (proxy same-origin avec
+  fichier écrit sur disque, dégradation sans vignette).
+- JSDOM `filechat.test.mjs` +3 (19) : indicateur ✓/✓✓ (ma propre carte de
+  lecture exclue, aucun indicateur sur les messages des autres), bascule en
+  direct + notification + pas d'écho, textarea (tagName/rows, hauteur
+  pilotée, `Entrée` intercepté / `Maj+Entrée` non).
+
+## #193 — Rendu markdown des posts (2026-10-09)
+
+Un post du chat s'affiche désormais **comme un document** : titres, listes,
+tableaux, citations, blocs de code colorés — au lieu du texte brut avec liens
+cliquables.
+
+### A. Le rendu vient du serveur (pas de second moteur markdown)
+
+- `backend/file_chat.py::_decorate()` ajoute un champ `html` à chaque message
+  en réutilisant `backend/render.py::_render_markdown()` — **le pipeline exact
+  des documents** : mistune (tableaux, strikethrough, notes, listes de tâches),
+  résolution des wikilinks, normalisation des sauts de ligne, masquage des
+  secrets (#188) et **sanitizer BUG-021** en sortie. Aucun markdown côté client,
+  donc aucun XSS nouveau à traiter : la sanitisation est déjà éprouvée.
+- `ChatMessageItem.html` (schéma de réponse) : sans ce champ, `response_model`
+  filtrait la clé.
+- Le `html` est calculé **à la lecture** (`get_messages()`) et à l'ajout
+  (`_append()`), donc il n'est **jamais persisté** dans `data/chats/*.json` :
+  un message reste du texte, le rendu suit les évolutions du pipeline.
+- L'écho SSE part avec le `html` : les autres clients voient le rendu sans
+  attendre un refresh.
+- Un échec de rendu n'emporte pas le message : repli silencieux (`html = ""`),
+  le client affiche le texte brut.
+
+### B. Frontend : `.md-content` + highlight.js
+
+- `_fillBody()` injecte le `html` dans un `<div class="md-content">` (la
+  typographie des documents) puis appelle `safeHighlight()` sur chaque
+  `pre code` — le même helper (et les mêmes alias de langages) que le viewer.
+  Mermaid n'est pas déclenché dans le chat.
+- Repli intact : un message sans `html` (écho optimiste d'un autre client)
+  repasse par l'ancien chemin texte + URL cliquable.
+- CSS : `.file-chat-body.file-chat-md` annule le `white-space: pre-wrap` hérité
+  de la bulle (sinon les retours à la ligne du HTML source créaient des lignes
+  vides) et compacte `.md-content` (tailles, marges, `pre`/`table` en
+  `overflow-x: auto`) pour tenir dans une bulle de 92 % de large.
+
+### Tests #193
+
+- pytest `TestMarkdownRendering` (7) : `html` présent à l'ajout **et** à la
+  lecture, `html` **absent** du JSON stocké, classe `language-xxx` conservée
+  (ce sur quoi hljs se branche), tableaux/listes, `<script>` neutralisé,
+  routes `POST/GET` (chat de fichier + chat général) et écho SSE porteur du
+  `html`. Suite : 1689 passed.
+- JSDOM `filechat.test.mjs` +2 (27) : post avec `html` → `.md-content`,
+  `<strong>`, `pre code.language-python` ; post sans `html` → texte brut et URL
+  cliquable conservés.
+
+## Décisions
+
+- **SSE plutôt qu'un second WebSocket** : le transport de #62 (EventSource
+  `/api/events`, auth par cookie) existe déjà côté client dans `sync.js` ;
+  un WS par fichier aurait dupliqué reconnexion/heartbeat/auth pour zéro
+  bénéfice sur du messages-postés.
+- **Pas d'événement dans le panneau de sync** (`_addEvent`) : les messages
+  de chat gonfleraient l'historique d'événements d'index sans valeur.
+- **Tag OpenAPI** : pas de tag maison (`file-chat`) — non déclaré dans
+  `TAGS_METADATA`, ce qui cassait `test_used_tags_are_declared`. Les routes
+  `/api/file/*` sont dérivées automatiquement sous « Files ».

docs/features/secret-mask-188.md

@@ -0,0 +1,57 @@
+# Fiche — #188 · Secrets masqués : couverture universelle + clic pour copier
+
+- **Statut** : ✅ livré le 2026-10-08 (ouvert le 2026-10-08)
+- **Effort** : ~1 jour · **Impact** : 🟡
+- **Zones** : `backend/secret_redactor.py`, `backend/render.py`,
+  `backend/routers/files_read.py`, `frontend/js/viewer.js`,
+  `frontend/style.css`, `frontend/locales/{fr,en}.json`
+
+## Problème
+
+Le redacteur (`secret_redactor.py`) ne masquait que les JWT, les clés
+`sk-`/`pk-`/`rk-`, `AKIA…`, `ghp_…`, les connection strings et les
+affectations `api_key=`/`token=`/`secret=` de **20 caractères ou plus**.
+Résultat : la majorité des clés API réelles (Google, Slack, Stripe, GitLab,
+Hugging Face, npm…) et **tous les mots de passe courts** passaient en clair
+dans l'aperçu markdown, et un masque affiché (`[CLÉ API MASQUÉE]`) n'était
+pas récupérable : il fallait ouvrir la source pour relire la valeur.
+
+## Solution
+
+1. **Détection universelle** — une alternation unique de formats
+   fournisseur (OpenAI/Anthropic `sk-`, Stripe `sk_live_`/`whsec_`, GitLab
+   `glpat-`, GitHub `ghp_`/`github_pat_`, Google `AIza…`/`ya29.`, AWS
+   `AKIA`/`ASIA`, Slack `xoxb-`, SendGrid `SG.`, Hugging Face `hf_`, npm,
+   Docker, Resend, Square, Atlassian, Discord, Telegram, `Bearer …`) en
+   plus des motifs déjà présents ; le plancher des affectations génériques
+   passe de 20 à 8 caractères.
+2. **Mots de passe** — motif dédié (`[MOT DE PASSE MASQUÉ]`) valable toute
+   longueur et toute quote (`password=`, `"passwd": "…"`, `db_password=`,
+   `passphrase=`, `mot de passe=`), qualificateur inclus. `PWD=` (dossier de
+   travail shell) reste épargné : `pwd` n'est reconnu que qualifié.
+3. **Clic → copie** — le pipeline de rendu passe par des
+   **placeholders** (`\uE000n\uE001`) qui survivent à la conversion markdown
+   (un `<span>` littéral dans un bloc de code serait affiché tel quel), puis
+   `restore_masks()` les réécrit après le rendu :
+   - **aperçu authentifié** (`GET /api/file/…`, `click_to_copy=True`) :
+     `<span class="secret-mask" data-secret="valeur">[CLÉ API MASQUÉE]</span>` —
+     la valeur n'est jamais affichée, un clic la copie (listener délégué
+     unique sur la zone de contenu, toast i18n FR/EN, infobulle) ;
+   - **partages publics, exports PDF, contexte IA / MCP** : libellé seul,
+     la valeur ne quitte pas le serveur.
+   Les blocs `<pre><code>` portant un masque ne sont pas re-colorés
+   (highlight.js reconstruirait le markup et perdrait le badge).
+
+## Hors périmètre (volontaire)
+
+- La vue « source » (fichier brut) et les aperçus de fichiers
+  **non-markdown** ne sont pas masqués : c'est le fichier lui-même qui est
+  affiché, le redacteur ne s'y appliquait jamais.
+- Le serveur MCP / l'assistant IA continuent de recevoir les libellés seuls
+  (inchangé).
+
+## Tests
+
+`tests/test_api_main.py::TestSecretRedactor` : formats fournisseurs
+(paramétrés), mots de passe (paramétrés), `PWD=` non masqué, round-trip
+placeholder → span cliquable, rendu markdown cliquable vs libellé seul.

docs/features/tiktak-integration-197-200.md

@@ -0,0 +1,132 @@
+# Intégration TikTak ↔ ObsiGate — socle côté ObsiGate (#197 → #200)
+
+> **Statut :** ✅ livré — **IDs stables :** #197, #198, #199, #200
+> **Issues Gitea :** Projets/ObsiGate #4, #3, #2, #1 (même ordre)
+> **Référence d'analyse :** `Projets/ticktick-clone`, `docs/SYNCHRO-OBSIGATE.md` v1.1
+> (décisions §8 : vault dédié « TikTak », transport API REST, TikTak maître en conflit)
+
+## Contexte
+
+TikTak projette ses tâches/notes en fichiers Markdown dans un vault ObsiGate dédié
+via l'API REST fichiers. Côté ObsiGate, quatre manques bloquaient une synchronisation
+propre : réconciliation sans relire chaque fichier (#197), webhooks filtrables (#198),
+clé API à moindre privilège (#199), procédure de provisionnement (#200).
+
+## #197 — Listes de fichiers : `mtime` + `size` (Gitea #4)
+
+**Constat.** `GET /api/vault/{vault}/files` et l'outil MCP `list_all_files` exposaient
+déjà `size`/`modified`, mais pas `GET /api/vault/{vault}/paths` (seulement
+`vault/path/name/type`), ni `GET /api/browse/{vault}`, ni l'outil `list_directory`.
+
+**Livré.**
+- `GET /api/vault/{vault}/paths` : chaque entrée fichier expose `size`, `mtime`
+  (epoch) et `mtime_iso` (issus de l'index — source unique, même contrat que
+  `list_all_files`) ; les répertoires portent `None`.
+- `GET /api/browse/{vault}` : `modified`/`modified_iso` sur les fichiers.
+- Outil MCP `list_directory` : `size`/`mtime`/`mtime_iso` sur les fichiers.
+- Cohérence read-after-write : `PUT /api/file/{vault}/save` rafraîchit l'index de
+  façon synchrone (`update_single_file`), au lieu de dépendre du watcher.
+- **Bug latent corrigé au passage** : `update_single_file`/`remove_single_file`
+  exigeaient un chemin absolu alors que toutes les routes leur passent un chemin
+  relatif au vault — le rafraîchissement post-écriture était un no-op silencieux
+  (masqué en prod par le watcher). Les deux fonctions acceptent désormais les deux
+  formes.
+
+**Réconciliation type (un seul appel) :** snapshot `{path: (mtime, size)}`, puis
+re-liste et comparaison — démontré par
+`tests/test_sync_lists.py::TestReconciliationScenario`.
+
+## #198 — Webhooks : `vault` + filtre `vault` / `path_prefix` (Gitea #3)
+
+**Constat.** Les charges utiles contenaient déjà `vault`, mais sans filtre un
+consommateur recevait tous les vaults. De plus `file_modified` (événement souscrit
+mais jamais émis) manquait pour tirer les retours de synchro.
+
+**Livré.**
+- Filtres optionnels par webhook : `vault` (égalité exacte) et `path_prefix`
+  (égalité ou sous-arbre — `Maison` matche `Maison/a.md`, pas `Maison2/a.md` ;
+  sur renommage/déplacement, `old_path` **ou** `new_path` suffit pour être prévenu).
+  Sans filtre : reçoit tout, comme avant (compatibilité).
+- `POST /api/webhooks` accepte `vault`/`path_prefix` ; `PATCH` les modifie
+  (`""` réinitialise) ; `GET` les expose (`WebhookModel.vault/path_prefix`).
+- `PUT /api/file/{vault}/save` émet désormais `file_modified`
+  (`{"vault", "path"}`) — la sauvegarde tableur/IA reste hors périmètre (documenté).
+- UI : champs filtre à la création + badge dans la liste ; aide intégrée FR/EN
+  mise à jour (`file_modified` émis, filtrage documenté).
+- Filtrage pur et testable : `backend/webhooks.py::webhook_matches` ;
+  `tests/test_webhook_filters.py` (matching, persistance, dispatch simulé :
+  le webhook filtré sur « TikTak » ne reçoit que ses événements, avec
+  `vault: "TikTak"` dans la charge).
+
+## #199 — Clés API à portée limitée (Gitea #2)
+
+**Constat.** Les clés longue durée portaient toutes les permissions du compte.
+
+**Livré.**
+- Création : `POST /api/auth/tokens` accepte `vaults` (sous-ensemble des vaults
+  du créateur, défaut = tous — `400` si inconnu, `403` si hors d'accès) et
+  `scope` (`"full"` défaut | `"files"`).
+- Restriction vault : le JWT embarque les vaults autorisés → `check_vault_access`
+  (REST) et `require_vault_access` (MCP/outils) refusent le reste en 403.
+- Périmètre `files` : fichiers (CRUD, listes, recherche, backups lecture/restauration),
+  `GET /api/vaults`, `/api/search*`, `/mcp`. Tout le reste (admin, config, IA,
+  webhooks, partages, **gestion des clés elle-même** — anti-escalade) → **403**
+  via `TokenScopeMiddleware` (`backend/auth/scope.py`, stateless : claim lu sans
+  vérification pour le refus, signature toujours vérifiée en aval).
+- MCP : `call_tool` + `propose_*` refusent les outils hors `FILES_SCOPE_TOOLS`
+  (`token_scope_denied`), `list_tools` filtré pour ces tokens, ressources
+  `vault://` couvertes.
+- UI : sélecteur de portée + champ vaults à la création, badge de portée et
+  vaults dans la liste (i18n FR/EN).
+- Compatibilité : clés existantes (sans `scope`) = `full`, comportement inchangé.
+- Tests : `tests/test_scoped_tokens.py` (13 cas : création/validation, lecture/
+  écriture OK, 403 autre vault, 403 hors périmètre, non-régression full, outils).
+
+## #200 — Provisionnement du vault « TikTak » (Gitea #1, exploitation)
+
+Opération unique côté hébergement (aucun code requis — endpoints déjà testés) :
+
+```bash
+# 1. Dossier sur l'hôte
+mkdir -p /NFS/OBSIDIAN_DOC/TikTak
+
+# 2. Montage conteneur (docker-compose.yml, puis recreate)
+# volumes:
+#   - /NFS/OBSIDIAN_DOC/TikTak:/vaults/TikTak
+
+# 3. Déclarer le vault SANS redémarrage (admin, persisté via data/vaults.json)
+curl -X POST $BASE/api/vaults/add -H "Authorization: Bearer $ADMIN" \
+  -H 'Content-Type: application/json' -d '{"name":"TikTak","path":"/vaults/TikTak"}'
+
+# 4. Octroyer le vault au compte de synchro (ACL par vault, UI admin ou API)
+
+# 5. Clé à portée limitée pour TikTak (cf. #199)
+curl -X POST $BASE/api/auth/tokens -H "Authorization: Bearer $ADMIN" \
+  -H 'Content-Type: application/json' \
+  -d '{"name":"TikTak sync","expiry":"never","vaults":["TikTak"],"scope":"files"}'
+
+# 6. Webhook retour filtré (optionnel, phase 3 TikTak)
+curl -X POST $BASE/api/webhooks -H "Authorization: Bearer $ADMIN" \
+  -H 'Content-Type: application/json' \
+  -d '{"name":"TikTak retour","url":"https://tiktak…/hooks/obsigate","events":["file_created","file_modified","file_deleted","file_renamed"],"vault":"TikTak"}'
+```
+
+**Acceptation :** le vault « TikTak » est visible ; un `.md` créé via
+`POST /api/file/TikTak` (clé limitée, pas admin) est lu, cherché et édité sans erreur :
+
+```bash
+KEY=<clé de l'étape 5>
+curl -X POST $BASE/api/file/TikTak -H "Authorization: Bearer $KEY" \
+  -H 'Content-Type: application/json' -d '{"path":"Inbox/sonde.md","content":"# sonde\n"}'
+curl -s "$BASE/api/file/TikTak/raw?path=Inbox/sonde.md" -H "Authorization: Bearer $KEY"
+curl -s "$BASE/api/search?q=sonde&vault=TikTak" -H "Authorization: Bearer $KEY"
+```
+
+## Fichiers touchés (rappel)
+
+| # | Backend | Frontend | Tests |
+|---|---|---|---|
+| 197 | `services/search.py`, `services/vaults.py`, `schemas.py`, `indexer.py`, `routers/files_write.py`, `tools/service.py` | — | `tests/test_sync_lists.py` |
+| 198 | `webhooks.py`, `schemas.py`, `routers/webhooks.py`, `routers/files_write.py` | `js/config.js`, `index.html`, `locales/{fr,en}.json` | `tests/test_webhook_filters.py` |
+| 199 | `auth/jwt_handler.py`, `auth/middleware.py`, `auth/scope.py` (nouveau), `auth/router.py`, `main.py`, `tools/context.py`, `tools/registry.py`, `tools/api.py`, `mcp/server.py`, `openapi_docs.py` | `js/config.js`, `index.html`, `locales/{fr,en}.json` | `tests/test_scoped_tokens.py` |
+| 200 | — (runbook) | — | — (recette manuelle ci-dessus) |

docs/features/user-home-194.md

@@ -0,0 +1,107 @@
+# #194 — Dossier personnel par utilisateur
+
+> **Statut :** livré | **Ouvert :** 2026-10-09 | **Type :** feature (auth + vaults)
+
+## Problème
+
+Un utilisateur créé dans ObsiGate n'avait aucun espace propre : il ne voyait
+que les vaults qu'un admin lui attribuait à la main, et rien n'était préparé
+sur le disque à sa création.
+
+## Décision d'architecture
+
+Deux formes étaient possibles :
+
+1. **Un vault par utilisateur** (retenu) — `<racine>/<user>` devient le vault
+   `home-<user>`, octroyé dans `user.vaults`. L'ACL par vault existante
+   (`backend/auth/middleware.py::check_vault_access`, appliquée partout :
+   API, MCP, search, push, tools) fait l'isolation **sans rien inventer**.
+2. Un vault `Home` unique + ACL par sous-dossier (écartée) — il n'existe
+   aucune ACL par chemin dans le code ; il aurait fallu la brancher dans
+   `files_read`, `files_media`, `history`, `backups`, `mcp/tools`, `push`…
+   Surface de sécurité trop grande pour un gain marginal.
+
+Décisions produit validées : nom `home-<user>`, dossier **conservé** à la
+suppression du compte, racine `/NFS/OBSIDIAN_DOC/Home` montée `/vaults/Home`.
+
+## Mise en place
+
+| Élément | Où |
+|---|---|
+| Service idempotent `ensure_user_home()` / `release_user_home()` / `ensure_all_user_homes()` | `backend/user_home.py` |
+| Registre persistant des vaults dynamiques `data/vaults.json`, fusionné par `load_vault_config()` | `backend/indexer.py` (`persist_vault` / `unpersist_vault`) |
+| Appel à la création et à la suppression d'un compte | `backend/auth/router.py` (`POST/DELETE /api/auth/admin/users`) |
+| Passe de réparation/migration au démarrage | `backend/main.py` (`lifespan` → après le watcher) |
+| Persistance des vaults ajoutés par `/api/vaults/add` + retrait | `backend/routers/vaults.py` |
+| Montage + variable d'environnement | `docker-compose.yml` (`/NFS/OBSIDIAN_DOC/Home:/vaults/Home`, `OBSIGATE_HOME_ROOT=/vaults/Home`) |
+
+## Garde-fous
+
+- **Fonctionnalité inactive sans `OBSIGATE_HOME_ROOT`** : dev, tests et
+  desktop n'ont aucun comportement modifié.
+- **Validation du nom** : `^[a-zA-Z0-9_-]{2,32}$` (même grammaire que
+  `CreateUserRequest.username_valid`), re-vérifiée avant de construire un
+  chemin — défense en profondeur contre le path traversal.
+- **Nom de vault sans `/` ni `::`** : le nom sert de segment d'URL
+  (`/api/file/{vault}/…`) et de clé d'index `vault::path`.
+- **Auto-réparation** : `ensure_all_user_homes()` au démarrage crée les
+  dossiers manquants, ré-enregistre les vaults perdus et octroie l'accès aux
+  users créés hors API. Toute erreur disque (NFS indisponible) est
+  journalisée et rattrapée au boot.
+- **Suppression de compte** : index/watcher/registre refermés, dossier sur
+  disque conservé.
+
+## Bug corrigé au passage
+
+- `load_vault_config()` ne lisait que les env `VAULT_N_*`/`DIR_N_*` : tout
+  vault ajouté à la volée (y compris via `/api/vaults/add`) disparaissait au
+  premier reindex complet et au redémarrage. → `data/vaults.json`.
+- `reload_single_vault()` perdait l'entrée `vault_config[vault]` après
+  `remove_vault_from_index()`.
+
+## Tests
+
+- `tests/test_user_home.py` (10) : création (dossier + vault + octroi +
+  registre), idempotence, username invalide, désactivation sans variable,
+  relecture du registre par `load_vault_config`, `release` (dossier
+  conservé), isolation `check_vault_access` entre users, passe de réparation.
+- `tests/test_auth_api.py::TestUserHome` (2) : provisionnement via l'API
+  (création → dossier, vault visible, alice ne voit que son home, suppression
+  → vault refermé / dossier conservé) + absence de dossier sans
+  `OBSIGATE_HOME_ROOT`.
+
+## UI — arborescence (incrément)
+
+- **Ordre** : tri stable `home-*` en premier, appliqué à la source
+  (`frontend/js/sidebar.js::_homeFirst`, sur les deux sites qui alimentent
+  `state.allVaults`) → arborescence, sélecteurs et refreshs homogènes.
+- **Icône** : `getVaultIcon()` (`frontend/js/viewer.js`) renvoie
+  `icon("home", size)` pour `home-*` → même pipeline lucide que le reste de
+  l'app (`safeCreateIcons`, `stroke: currentColor`, suit le thème).
+- **Test local** : `docker-compose.test-win.yml` monte
+  `test_home:/vaults/Home` + `OBSIGATE_HOME_ROOT=/vaults/Home`
+  (`test_home/` est dans `.gitignore`).
+- **Vérifié live** (instance 2020, Playwright) : ordre `home-admin, TestDir,
+  TestVault` (l'admin ne voit plus le home des autres), `svg.lucide-home`
+  rendu, placeholder `<i>` remplacé.
+
+## Isolation — « * » ne couvre pas les dossiers persos
+
+- **Racine** : `check_vault_access` (`backend/auth/middleware.py`) renvoie
+  ``vault_name in vaults`` pour tout vault ``home-*``, quel que soit le ``*``.
+  Toutes les routes (89 usages) passent par cette fonction.
+- **Filtres « * » en dur remplacés** par cet appel : dashboard
+  (`routers/config.py`), conflits, liens retour, favoris, abonnements push.
+- **Recherche** : `services/search.search_vaults(is_allowed=…)` filtre les
+  bruts **avant** pagination — ``total`` et page restent justes.
+- **Octroi** : `_grant` n'écarte plus les comptes ``*`` → l'admin reçoit son
+  propre ``home-admin`` (réparé au démarrage pour les comptes existants).
+- **Reste ouvert** (fuite pré-existante, hors #194) : `/api/search/advanced`,
+  `/api/tags`, `/api/tags/suggest`, `/api/tree-search` et `/api/suggest` ne
+  filtrent pas par vault accessible — à traiter dans une tâche dédiée.
+
+## Impact utilisateur
+
+Aucune nouvelle chaîne i18n : les noms de vault sont des données, la liste
+provient déjà de `GET /api/vaults`. Le dossier apparaît tout seul dans le
+sélecteur de vaults de l'utilisateur concerné.