docs: commentaire 15 -> 16 themes integres (meme compteur obsolete que test_themes.py)

.env.example

@@ -104,3 +104,41 @@ DEEPSEEK_MODEL=deepseek-chat
 # OBSIGATE_GITEA_URL=https://git.example.net
 # OBSIGATE_GITEA_TOKEN=
 # OBSIGATE_GITHUB_TOKEN=
+
+# ── Fusion / dev-prod — URL publiques de l'écosystème (#223) ──
+# Aucun nom public n'est figé dans le code : ces variables portent les
+# URL des autres applications. Valeurs par défaut (si absentes) = noms
+# OFFICIELS de la production. Depuis BUG-120, les URL sœurs se dérivent
+# de l'hôte de l'agent (agent<SUFFIXE>.dracodev.net, lu via
+# AGENT_EVENEMENTS_URL / DRACO_AGENT_URL) : en dev, rien d'autre à
+# déclarer pour obtenir les noms en -dev. Une variable explicite
+# reste prioritaire sur la dérivation, par exemple :
+#   DRACO_TIKTAK_URL=https://tiktak-dev.dracodev.net
+# DRACO_AGENT_URL=https://agent.dracodev.net
+# DRACO_OBSIGATE_URL=https://og.dracodev.net
+# DRACO_FLOWDECK_URL=https://flowdeck.dracodev.net
+# DRACO_TIKTAK_URL=https://tiktak.dracodev.net
+# DRACO_KANBANTE_URL=https://kanbante.dracodev.net
+# DRACO_GITEA_URL=https://git.dracodev.net
+
+# ── Fusion — émission d'événements vers le service d'agents (#220) ──
+# URL complète de réception ; à défaut, dérivée de DRACO_AGENT_URL.
+# AGENT_EVENEMENTS_URL=https://agent.dracodev.net/api/v1/evenements
+# AGENT_EVENEMENTS_CLE=<clé propre à ObsiGate, jamais commitée>
+# AGENT_EVENEMENTS_DOMAINES={"NomDuVault": "famille"}
+
+# ── Fusion — émettrice SSO draco_session (#216/#217) ──
+# DRACO_SESSION_SECRET=<secret partagé, jamais commité>
+# DRACO_SESSION_SECRET_PREV=<ancien secret, fenêtre de rotation>
+# DRACO_SESSION_COOKIE_DOMAIN=.dracodev.net
+# DRACO_SSO_MACHINE_KEY=<clé machine des révocations, jamais commitée>
+
+# ── Coffre Secrets ObsiGate (Phases 1–2, voir docs/COFFRE-sauvegarde-restauration.md) ──
+# Activation (défaut : désactivé — toutes les routes répondent 503 sinon) :
+# OBSIGATE_SECRETS_ENABLED=true
+# Clé maître 256 bits, base64 de 32 octets, rendue une seule fois par
+# POST /api/coffres/admin/generer-kek ; à sauvegarder HORS dépôt, HORS note :
+# OBSIGATE_KEK=<kek-base64-32-octets>
+# … ou fichier 0600, hors dépôt et hors arborescence des vaults :
+# OBSIGATE_KEK_FILE=/chemin/hors/depot/kek.txt
+# Aucune autre variable ne doit contenir une valeur de secret du coffre.

.gitea/workflows/ci.yml

@@ -180,7 +180,13 @@ jobs:
         # PYSEC-2026-3910 / PYSEC-2026-3911 (pypdf, DoS de ressources sur
         # l'extraction de texte et la lecture d'outlines — donc atteignables
         # via backend/pdf_reader.py) sont corrigés par le plancher
-        # pypdf>=6.16.1 (BUG-093).
+        # pypdf>=6.16.1 (BUG-093), relevé à pypdf>=6.21.2 par #224 (11 CVE
+        # sur la 6.19.0 de la toolcache, corrigées au plus tard en 6.21.2).
+        # #224 ajoute les planchers brotli>=1.2.1 (PYSEC-2026-4322,
+        # GHSA-9v8h-qqgm-4m35), filelock>=4.2.1 (CVE-2026-112940,
+        # CVE-2026-112913, CVE-2026-112907) et opentelemetry-api>=1.45.1
+        # (CVE-2026-114603) : paquets transitifs ou préinstallés dans la
+        # toolcache, audités mais jamais alignés sans plancher explicite.
         # 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

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.73.1**.
+> [Unreleased](#unreleased). La dernière version livrée est **2.81.0**.
 
 ---
 
@@ -14,6 +14,227 @@ et [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [2.81.0] — 2026-10-28
+
+---
+
+## [2.80.2] — 2026-10-27
+
+### Corrigé
+
+- **CI lint (mypy)** — 3 erreurs dans le Coffre Secrets : annotation explicite `type[Any] | None` pour `AESGCM` dans `coffre_crypto.py` (le repli sans `cryptography` reste `None`, et `_require_aesgcm()` retourne désormais la classe pour un narrowing propre) ; annotation `dict[str, Any]` du coffre dans `create_coffre` (`coffre_store.py`), qui inférait ses valeurs en `str | None` et refusait le dict de `wrap_dek` ainsi que `coffre["id"]` en argument. Aucun `type: ignore` aveugle ajouté, aucun changement de comportement.
+
+- **Bouton Nouveau secret inoperant (console NotFoundError)** — `valeurField` appelait `wrap.insertBefore(input, eyeBtn)` alors que le bouton oeil n'avait jamais ete rattache a `wrap` : l'oeil est desormais ajoute a `wrap` avant le premier `build`, la modale de creation (et celle de rotation) s'ouvre.
+- **CI security (pip-audit)** — plancher `msgpack>=1.2.3` : la version transitive 1.2.1 etait signalee pour CVE-2026-114613 (correctif 1.2.3).
+
+---
+
+## [2.80.1] — 2026-10-27
+
+### Ajouté
+
+- **Coffre Secrets — Phase 1** (contenu de la release 2.80.0, dont l'entrée changelog manquait) : chiffrement par enveloppe AES-256-GCM, API `/api/coffres`, nœud virtuel Secrets sous le Home de l'utilisateur.
+
+### Corrigé
+
+- **Étiquette de version 2.80.0** — le tag v2.80.0 pointait sur un contenu dont le fichier `VERSION` valait encore 2.79.0 (un merge ne déclenche pas le bump automatique) ; `VERSION` et tous les fichiers dérivés passent à 2.80.1, pour que la version affichée corresponde au tag de la prochaine release.
+- **CI lint (ruff)** — 60 erreurs corrigées dans `backend/` : alias `datetime.UTC` (Python 3.11+), `TimeoutError` natif, tri d'imports et import inutilisé dans `coffre_store.py`, `.encode()` sans argument redondant, `fromisoformat` gérant « Z » ; aucune règle ruff masquée, aucun changement de comportement.
+
+---
+
+## [2.79.0] — 2026-10-26
+
+### Ajouté
+
+- **Panneau Spark : version du service d'agents visible en mode
+  sidebar (#225)** — le pied du panneau Spark
+  (`frontend/draco-panneau.js`, asset partagé des 4 applications)
+  affiche la ligne discrète « Service d'agents vX », comme la
+  console pleine page. La version est lue en direct dans la santé
+  du service (`GET /healthz` de l'origine injectée par l'hôte), à
+  l'ouverture du panneau, avec cache de session ; jamais une
+  valeur codée en dur — service injoignable, rien d'affiché.
+  Demande de Bruno (2026-10-26), carte fusion #64 ; même
+  livraison : TikTak 0.61.3, Flowdeck 7.83.1, Kanbante 0.37.1.
+
+---
+
+## [2.78.2] — 2026-10-26
+
+### Corrigé
+
+- **Menu inter-apps : les URL sœurs suivaient l'environnement de
+  l'agent (BUG-120, suite de #223)** — sur la dev
+  (`og-dev.dracodev.net`), le `window.DRACO_URLS` servi donnait
+  l'agent en `-dev` mais les applications sœurs (ObsiGate, Flowdeck,
+  TikTak, Kanbante) en noms **prod** : seule l'URL de l'agent avait
+  une dérivation de repli, et le `.env` dev ne déclare pas les quatre
+  `DRACO_<APP>_URL`. Résolution d'une URL sœur dans
+  `backend/draco_config.py`, inchangée dans son contrat : (1) la
+  variable explicite prime ; (2) à défaut, **dérivation
+  d'environnement** depuis l'hôte de l'agent tel qu'ObsiGate le
+  connaît déjà (`agent_url()`, qui lit `AGENT_EVENEMENTS_URL`) — si
+  cet hôte est de la forme `agent<SUFFIXE>.dracodev.net`, l'URL sœur
+  devient `https://<slug><SUFFIXE>.dracodev.net` (`og`, `flowdeck`,
+  `tiktak`, `kanbante`) ; hôte hors motif (autre domaine, LAN, IP,
+  port) → **aucune dérivation**, jamais de lien deviné ; (3) défaut
+  officiel. L'URL Gitea ne change pas. Aucune variable supplémentaire
+  à déclarer en dev. Tests `tests/test_draco_config.py` étendus
+  (dérivation `-dev`, priorité de l'explicite, hôtes hors motif,
+  non-régression sans env). Redéploiement Docker requis.
+
+---
+
+## [2.78.1] — 2026-10-25
+
+### Corrigé
+
+- **Sécurité des dépendances — `pip-audit` rouge sur 2.78.0 (#224)** —
+  le job `security` du run CI 2303 signalait 17 vulnérabilités dans
+  4 paquets hérités de l'environnement du runner (versions
+  préinstallées dans la toolcache, jamais alignées car « already
+  satisfied » — même piège que BUG-093). Planchers explicites dans
+  `backend/requirements.txt` : `pypdf>=6.21.2` (11 CVE sur la 6.19.0,
+  dont CVE-2026-113786 et CVE-2026-115572/115585/115580),
+  `brotli>=1.2.1` (PYSEC-2026-4322, GHSA-9v8h-qqgm-4m35),
+  `filelock>=4.2.1` (CVE-2026-112940, CVE-2026-112913,
+  CVE-2026-112907) et `opentelemetry-api>=1.45.1`
+  (CVE-2026-114603). Garde-fou `TestDependencySecurityFloors`
+  étendu ; aucun code applicatif touché, aucun nouvel ignore
+  `pip-audit`. Redéploiement Docker requis.
+
+---
+
+## [2.78.0] — 2026-10-25
+
+### Modifié
+
+- **Dev/prod sans noms publics en dur (#223, Fusion)** — toutes les URL
+  publiques de l'écosystème dracodev viennent désormais de la
+  configuration (`backend/draco_config.py` : `DRACO_AGENT_URL`,
+  `DRACO_OBSIGATE_URL`, `DRACO_FLOWDECK_URL`, `DRACO_TIKTAK_URL`,
+  `DRACO_KANBANTE_URL`, `DRACO_GITEA_URL` ; défauts = noms officiels,
+  l'environnement dev déclare ses noms en `-dev` dans son seul `.env`).
+  La CSP (`connect-src`/`frame-src`) dérive l'origine de l'agent de la
+  config (à défaut, de l'origine d'`AGENT_EVENEMENTS_URL`) ; le backend
+  injecte `window.DRACO_URLS` dans `index.html` pour le panneau Spark,
+  la barre d'apps et les liens inter-apps ; les références croisées
+  reconnaissent les hôtes officiels et configurés et leur URL
+  d'affichage est reconstruite depuis la config à la lecture (aucune
+  donnée stockée migrée). WebAuthn confirmé dérivé de la requête /
+  `OBSIGATE_WEBAUTHN_*` (aucun changement). Redéploiement Docker
+  requis ; en dev, déclarer les noms en `-dev` dans le `.env` du poste.
+
+---
+
+## [2.77.1] — 2026-10-24
+
+### Corrigé
+
+- **Panneau Spark : « mode console » bloqué par la CSP (BUG-119, Fusion)** —
+  la surimpression du panneau Spark V3 (#222) charge la console du service
+  d'agents (`https://agent.dracodev.net`) dans une iframe, mais la CSP servie
+  limitait `frame-src` à `'self' blob:` : le navigateur refusait le
+  chargement (« This content is blocked »). `frame-src` autorise désormais
+  aussi `https://agent.dracodev.net` — déjà présente dans `connect-src`
+  pour le panneau texte ; aucune autre directive n'est modifiée. Test de
+  non-régression dans `tests/test_security_headers.py`. Redéploiement
+  Docker requis pour l'activer côté ObsiGate.
+
+---
+
+## [2.77.0] — 2026-10-23
+
+### Modifié
+
+- **Panneau Spark V3 : la console en surimpression pleine page
+  (#222, Fusion)** — le bouton « Console ⤢ » du panneau Spark
+  (asset vendangé, octet-identique dans les 4 apps) n'ouvre plus
+  la console web du service d'agents en nouvel onglet (#221) :
+  elle s'ouvre **dans la même page**, en surimpression née à la
+  largeur du panneau et étendue à toute la fenêtre par
+  transition, avec le lien profond conservé (`?disc=<id>` et
+  `?app=obsigate`). Sa barre offre les deux sorties : « Mode
+  sidebar » (retour à l'agent en barre latérale) et « Fermer
+  l'agent ». Les styles sont injectés par le panneau lui-même ;
+  côté service (0.20.0), la console autorise l'encadrement par
+  les 4 applications. Même livraison dans TikTak 0.60.0,
+  Flowdeck 7.81.0 et Kanbante 0.29.0. Redéploiement Docker
+  requis pour l'activer côté ObsiGate.
+
+---
+
+## [2.76.1] — 2026-10-22
+
+### Ajouté
+
+- **Panneau Spark : bouton « Console ↗ » (#221, Fusion)** — la
+  barre des discussions du panneau Spark (asset vendangé,
+  octet-identique dans les 4 apps) gagne un bouton « Console ↗ »
+  qui ouvre la console web du service d'agents
+  (https://agent.dracodev.net/) dans un nouvel onglet, sur la
+  discussion actuellement affichée (`?disc=<id>`, URL construite
+  au clic) et avec l'app d'origine (`?app=obsigate`, déduite du
+  sous-domaine `og`). Même livraison dans TikTak 0.59.1,
+  Flowdeck 7.80.1 et Kanbante 0.28.1. Redéploiement Docker
+  requis pour l'activer côté ObsiGate.
+
+---
+
+## [2.76.0] — 2026-10-22
+
+### Ajouté
+
+- **Émission d'événements vers le journal du service d'agents
+  (#220, Fusion — Lot 2 vague 5)** — ObsiGate émet ses mutations de
+  notes **explicites** au journal d'activité du service d'agents
+  (contrat ACC-0.2) : `obsigate.note.created / edited / moved /
+  deleted`, enveloppes signées HMAC-SHA256 (clé
+  `AGENT_EVENEMENTS_CLE`), envoyées en arrière-plan sans jamais
+  bloquer le métier, inactives tant que la clé n'est pas posée.
+  Points d'accroche : les endpoints d'écriture de l'API web (acteur
+  `user`) et la couche outils / serveur MCP (acteur `agent:mcp`).
+  **Garde-fou : jamais le watcher** — les modifications faites hors
+  API (Obsidian, éditeur externe) n'émettent rien. Domaine par vault
+  via `AGENT_EVENEMENTS_DOMAINES`, repli `pro` (Q-A ouverte).
+  Redéploiement Docker requis, puis pose de la clé des deux côtés
+  pour activer.
+
+---
+
+## [2.75.0] — 2026-10-22
+
+### Ajouté
+
+- **Panneau Spark v2 (#219, Fusion — Lot 1)** — les assets partagés
+  `frontend/draco-panneau.js` / `frontend/draco-panneau.css` passent
+  en v2, à l'identique dans les quatre applications : réponses de
+  l'agent en **Markdown rendu** (HTML produit par le service
+  d'agents 0.10.0, sanitizé côté serveur), **largeur réglable**
+  persistée, **thème clair/sombre** aligné sur l'application hôte
+  (suivi en direct de `html[data-theme]`), et **discussions façon
+  Muse** — discussion principale perpétuelle et discussions
+  parallèles créées, archivées, supprimées depuis le tiroir du
+  panneau. Aucun code propre à ObsiGate n'est modifié ;
+  redéploiement Docker requis.
+
+---
+
+## [2.74.0] — 2026-10-22
+
+### Ajouté
+
+- **Panneau Spark intégré (#218, Fusion)** — le bouton Spark de la
+  barre commune ouvre le panneau de l'agent commun (conversation,
+  Aujourd'hui, approbations, missions longues), comme dans TikTak,
+  Flowdeck et Kanbante : assets partagés `frontend/draco-panneau.js`
+  et `frontend/draco-panneau.css` vendangés à l'identique, action
+  `spark` branchée sur `DRACO_PANNEAU.toggle()`. La CSP nomme
+  `https://agent.dracodev.net` en `connect-src` (seul hôte ajouté).
+  Redéploiement Docker requis.
+
+---
+
 ## [2.73.1] — 2026-10-21
 
 ### Corrigé

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.73.1-blue.svg)]()
+[![Version](https://img.shields.io/badge/Version-2.81.0-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/)
@@ -977,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.73.1).
+Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.81.0).
 
 ---
 
-*Projet : ObsiGate | Version : 2.73.1 | Dernière mise à jour : Septembre 2026*
+*Projet : ObsiGate | Version : 2.81.0 | 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.73.1-blue.svg)]()
+[![Version](https://img.shields.io/badge/Version-2.81.0-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/)
@@ -1152,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.73.1).
+See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.81.0).
 
 ---
 
-*Project: ObsiGate | Version: 2.73.1 | Last updated: September 2026*
+*Project: ObsiGate | Version: 2.81.0 | Last updated: September 2026*

VERSION

@@ -1 +1 @@
-2.73.1
+2.81.0

backend/admin.py

@@ -10,7 +10,7 @@ import logging
 import os
 import shutil
 import time
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -244,7 +244,7 @@ def _build_stats_payload() -> dict:
         "disk_used_gb": disk_used_gb,
         "disk_total_gb": disk_total_gb,
         "uptime_seconds": int(_server_uptime_seconds()),
-        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "timestamp": datetime.now(UTC).isoformat(),
     }
 
 

backend/agent_journal.py

@@ -0,0 +1,184 @@
+"""Émission d'événements vers le journal du service d'agents
+(Fusion, Lot 2 vague 5 — contrat ACC-0.2, Roadmap #220).
+
+ObsiGate émet ses mutations de notes **explicites** vers
+``POST /api/v1/evenements`` du service d'agents, qui les expose dans
+le journal de sa console. L'enveloppe ne contient qu'une référence,
+un libellé et un lien — jamais le contenu de la note :
+``{id, type, occurred_at, actor, domain, source_app,
+object{ref, label, url}}``.
+
+**Garde-fou (conception validée)** : ce module n'est appelé que
+depuis les points d'écriture explicites de l'API web —
+:mod:`backend.routers.files_write` (session utilisateur, acteur
+``user``) et la couche outils :mod:`backend.tools.service`
+(serveur MCP d'ObsiGate, acteur ``agent:mcp`` ; assistant intégré,
+acteur ``user``). Le **watcher** (:mod:`backend.watcher`) et
+l'indexeur ne l'appellent **jamais** : le vault principal compte
+plus de 220 000 fichiers, un branchement sur les événements du
+système de fichiers inonderait le journal. Une modification faite
+hors API (éditeur externe, synchro disque…) reste donc invisible
+du journal — c'est voulu.
+
+Authentification : signature HMAC-SHA256 du corps brut, en-tête
+``X-Draco-Signature``, clé propre à ObsiGate
+(``AGENT_EVENEMENTS_CLE``, jamais en dur). Sans clé, le module est
+**inactif** : aucun appel, aucun bruit. URL surchargée par
+``AGENT_EVENEMENTS_URL``.
+
+Discipline « au mieux » (même esprit que TikTak et Kanbante) :
+l'envoi part dans un fil d'arrière-plan démon, délai maximal 2 s,
+et toute erreur est avalée avec une ligne de journal — une panne
+du récepteur ne doit jamais casser ni ralentir le métier.
+
+Domaine : ObsiGate ne modélise pas encore le domaine d'un vault
+(question Q-A du programme Fusion toujours ouverte). La
+correspondance peut être déclarée par ``AGENT_EVENEMENTS_DOMAINES``
+(JSON ``{"NomDuVault": "famille"}``) ; repli ``pro``, qui est aussi
+le défaut du journal du service.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import logging
+import os
+import threading
+import uuid
+from datetime import UTC, datetime
+from urllib.parse import quote
+
+import httpx
+
+logger = logging.getLogger("obsigate.agent_journal")
+
+SOURCE_APP = "obsigate"
+# Défaut officiel, conservé pour référence : depuis #223, ``_url()``
+# passe par la config centralisée (``backend.draco_config``) — jamais
+# un nom d'environnement particulier.
+URL_DEFAUT = "https://agent.dracodev.net/api/v1/evenements"
+DELAI_S = 2.0
+
+TYPE_CREE = "obsigate.note.created"
+TYPE_EDITE = "obsigate.note.edited"
+TYPE_DEPLACE = "obsigate.note.moved"
+TYPE_SUPPRIME = "obsigate.note.deleted"
+
+ACTEUR_USER = "user"
+ACTEUR_MCP = "agent:mcp"
+
+
+def _cle() -> str:
+    return os.environ.get("AGENT_EVENEMENTS_CLE", "").strip()
+
+
+def _url() -> str:
+    # #223 : AGENT_EVENEMENTS_URL d'abord ; à défaut, l'URL du service
+    # configurée (DRACO_AGENT_URL) complétée du chemin d'événements ;
+    # à défaut, le défaut officiel.
+    explicite = os.environ.get("AGENT_EVENEMENTS_URL", "").strip()
+    if explicite:
+        return explicite
+    from backend.draco_config import agent_url
+
+    return f"{agent_url()}/api/v1/evenements"
+
+
+def actif() -> bool:
+    """L'émission n'existe que si la clé d'ObsiGate est configurée."""
+    return bool(_cle())
+
+
+def domaine_du_vault(vault: str) -> str:
+    """Domaine journal du vault : correspondance déclarée dans
+    ``AGENT_EVENEMENTS_DOMAINES`` (JSON), repli ``pro``."""
+    brut = os.environ.get("AGENT_EVENEMENTS_DOMAINES", "").strip()
+    if brut:
+        try:
+            correspondance = json.loads(brut)
+        except ValueError:
+            correspondance = {}
+        if isinstance(correspondance, dict):
+            domaine = correspondance.get(vault)
+            if isinstance(domaine, str) and domaine:
+                return domaine
+    return "pro"
+
+
+def lien_fichier(vault: str, chemin: str) -> str:
+    """Lien profond ObsiGate vers un fichier (format ``#file=`` lu
+    par le frontend : ``#file=<vault>:<chemin>``, décodé en URI)."""
+    return f"/#file={quote(vault, safe='')}:{quote(chemin, safe='/')}"
+
+
+def construire_enveloppe(
+    type_: str,
+    vault: str,
+    chemin: str,
+    actor: str = ACTEUR_USER,
+) -> tuple[dict, bytes]:
+    """L'enveloppe ACC-0.2 et son corps JSON exact (celui qui est
+    signé puis envoyé — la signature porte sur ces octets-là).
+    ``chemin`` est le chemin relatif au vault ; pour un déplacement,
+    c'est le **nouveau** chemin (la référence pointe sur l'objet tel
+    qu'il existe après l'opération)."""
+    env = {
+        "id": uuid.uuid4().hex,
+        "type": type_,
+        "occurred_at": datetime.now(UTC).isoformat(),
+        "actor": actor or ACTEUR_USER,
+        "domain": domaine_du_vault(vault),
+        "source_app": SOURCE_APP,
+        "object": {
+            "ref": f"fichier:{vault}/{chemin}",
+            "label": chemin.rsplit("/", 1)[-1] if chemin else vault,
+            "url": lien_fichier(vault, chemin),
+        },
+    }
+    corps = json.dumps(env, ensure_ascii=False).encode("utf-8")
+    return env, corps
+
+
+def _signer(corps: bytes) -> str:
+    return hmac.new(_cle().encode("utf-8"), corps, hashlib.sha256).hexdigest()
+
+
+def _envoyer(corps: bytes) -> None:
+    """Le POST signé, dans le fil d'arrière-plan. Avale tout : le
+    journal distant est un confort, jamais une dépendance."""
+    try:
+        with httpx.Client(timeout=DELAI_S, trust_env=False) as client:
+            client.post(
+                _url(),
+                content=corps,
+                headers={
+                    "Content-Type": "application/json",
+                    "X-Draco-Signature": _signer(corps),
+                },
+            )
+    except Exception as exc:  # panne, délai, DNS… : on log et on passe
+        logger.warning("événement non livré au journal du service (%s)", exc)
+
+
+def emettre(
+    type_: str,
+    vault: str,
+    chemin: str,
+    actor: str = ACTEUR_USER,
+) -> bool:
+    """Émet un événement en tâche de fond. Retourne True si l'envoi
+    a été déclenché, False si le module est inactif (pas de clé) ou
+    si l'enveloppe n'a pas pu être construite. Ne lève jamais."""
+    if not actif():
+        return False
+    try:
+        _env, corps = construire_enveloppe(type_, vault, chemin, actor)
+    except Exception:
+        logger.warning("événement %s non construit", type_, exc_info=True)
+        return False
+    threading.Thread(
+        target=_envoyer, args=(corps,), daemon=True, name="obsigate-evenements"
+    ).start()
+    return True

backend/audit.py

@@ -10,7 +10,7 @@ Format: JSON lines (one JSON object per line) for easy parsing.
 import json
 import logging
 import os
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 
 logger = logging.getLogger("obsigate.audit")
@@ -54,7 +54,7 @@ def log_file_save(
 ):
     """Log a file save (PUT) operation."""
     _write_entry({
-        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "timestamp": datetime.now(UTC).isoformat(),
         "action": "file_save",
         "username": username,
         "ip": ip or "unknown",
@@ -72,7 +72,7 @@ def log_file_delete(
 ):
     """Log a file delete operation."""
     _write_entry({
-        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "timestamp": datetime.now(UTC).isoformat(),
         "action": "file_delete",
         "username": username,
         "ip": ip or "unknown",
@@ -88,7 +88,7 @@ def log_config_change(
 ):
     """Log a configuration change."""
     _write_entry({
-        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "timestamp": datetime.now(UTC).isoformat(),
         "action": "config_change",
         "username": username,
         "ip": ip or "unknown",
@@ -99,7 +99,7 @@ def log_config_change(
 def log_vault_add(username: str, vault_name: str, vault_path: str, ip: str | None = None):
     """Log a vault addition."""
     _write_entry({
-        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "timestamp": datetime.now(UTC).isoformat(),
         "action": "vault_add",
         "username": username,
         "ip": ip or "unknown",
@@ -111,7 +111,7 @@ def log_vault_add(username: str, vault_name: str, vault_path: str, ip: str | Non
 def log_vault_remove(username: str, vault_name: str, ip: str | None = None):
     """Log a vault removal."""
     _write_entry({
-        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "timestamp": datetime.now(UTC).isoformat(),
         "action": "vault_remove",
         "username": username,
         "ip": ip or "unknown",
@@ -119,6 +119,41 @@ def log_vault_remove(username: str, vault_name: str, ip: str | None = None):
     })
 
 
+def log_coffre_event(
+    username: str,
+    action: str,
+    coffre: str | None = None,
+    secret_ref: str | None = None,
+    consommateur: str | None = None,
+    resultat: str | None = None,
+    contexte_id: str | None = None,
+    ip: str | None = None,
+):
+    """Journal d'un événement du coffre Secrets (Phase 1b).
+
+    Règle absolue : aucun champ ne contient jamais une valeur de secret,
+    un texte chiffré, un nonce ou un jeton. Seules des références
+    (coffre:<slug>/<nom>), des identifiants et des codes de résultat.
+    """
+    entry = {
+        "timestamp": datetime.now(UTC).isoformat(),
+        "action": action,
+        "username": username,
+        "ip": ip or "unknown",
+    }
+    if coffre is not None:
+        entry["coffre"] = coffre
+    if secret_ref is not None:
+        entry["secret_ref"] = secret_ref
+    if consommateur is not None:
+        entry["consommateur"] = consommateur
+    if resultat is not None:
+        entry["resultat"] = resultat
+    if contexte_id is not None:
+        entry["contexte_id"] = contexte_id
+    _write_entry(entry)
+
+
 def get_recent_entries(limit: int = 100, action: str | None = None) -> list:
     """Read the most recent audit log entries.
 

backend/auth/router.py

@@ -7,6 +7,7 @@ import binascii
 import logging
 import os
 import re
+from datetime import UTC
 
 from fastapi import APIRouter, Body, Depends, HTTPException, Request, Response
 from pydantic import BaseModel, validator
@@ -696,7 +697,7 @@ async def mfa_webauthn_register(
 
     Returns recovery codes when MFA is newly enabled (they were never issued).
     """
-    from datetime import datetime, timezone
+    from datetime import datetime
 
     from .user_store import get_user, update_user
     from .webauthn_mfa import complete_registration, resolve_relying_party
@@ -716,7 +717,7 @@ async def mfa_webauthn_register(
         logger.warning(f"WebAuthn registration failed for {current_user['username']}: {e}")
         raise HTTPException(400, "Validation du credential WebAuthn échouée")
 
-    record["registered_at"] = datetime.now(timezone.utc).isoformat()
+    record["registered_at"] = datetime.now(UTC).isoformat()
     creds = list(user.get("webauthn_credentials", []))
     creds = [c for c in creds if c.get("credential_id") != record["credential_id"]]
     creds.append(record)

backend/auth/user_store.py

@@ -8,7 +8,7 @@ import logging
 import shutil
 import threading
 import uuid
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from pathlib import Path
 
 from .password import hash_password
@@ -97,8 +97,8 @@ def create_user(
             "active": True,
             "language": "fr",  # default UI language
             "avatar": None,  # profile picture data-URL (#113)
-            "created_at": datetime.now(timezone.utc).isoformat(),
-            "password_changed_at": datetime.now(timezone.utc).timestamp(),
+            "created_at": datetime.now(UTC).isoformat(),
+            "password_changed_at": datetime.now(UTC).timestamp(),
             "last_login": None,
             "failed_attempts": 0,
             "locked_until": None,
@@ -126,7 +126,7 @@ def update_user(username: str, updates: dict) -> dict:
         if "password" in safe_updates:
             safe_updates["password_hash"] = hash_password(safe_updates.pop("password"))
             # BUG-028: invalidate every token issued before this change.
-            safe_updates["password_changed_at"] = datetime.now(timezone.utc).timestamp()
+            safe_updates["password_changed_at"] = datetime.now(UTC).timestamp()
 
         data["users"][username].update(safe_updates)
         _write(data)
@@ -148,7 +148,7 @@ def delete_user(username: str):
 def record_login_success(username: str):
     """Record a successful login: update last_login, reset failed attempts."""
     update_user(username, {
-        "last_login": datetime.now(timezone.utc).isoformat(),
+        "last_login": datetime.now(UTC).isoformat(),
         "failed_attempts": 0,
         "locked_until": None,
     })
@@ -171,7 +171,7 @@ def record_login_failure(username: str) -> int:
         # Lock after 5 failed attempts (15 minutes)
         if attempts >= 5:
             locked_until = (
-                datetime.now(timezone.utc) + timedelta(minutes=15)
+                datetime.now(UTC) + timedelta(minutes=15)
             ).isoformat()
             updates["locked_until"] = locked_until
             logger.warning(f"Account '{username}' locked after {attempts} failed attempts")
@@ -189,7 +189,7 @@ def is_locked(username: str) -> bool:
     if not user or not user.get("locked_until"):
         return False
     locked_until = datetime.fromisoformat(user["locked_until"])
-    if datetime.now(timezone.utc) > locked_until:
+    if datetime.now(UTC) > locked_until:
         # Lock expired — unlock
         update_user(username, {"locked_until": None, "failed_attempts": 0})
         return False

backend/bookslm_routes.py

@@ -591,7 +591,7 @@ async def api_bookslm_agent(
                 while True:
                     try:
                         kind, item = await asyncio.wait_for(queue.get(), timeout=0.25)
-                    except asyncio.TimeoutError:
+                    except TimeoutError:
                         if run_task.done():
                             break
                         continue

backend/coffre_crypto.py

@@ -0,0 +1,215 @@
+"""Chiffrement par enveloppe du coffre Secrets ObsiGate (Phase 1a).
+
+Principe (spec §5) : deux niveaux de clés, jamais de valeur en clair au repos.
+
+- KEK : clé maître 256 bits, fournie par l'opérateur via ``OBSIGATE_KEK``
+  (base64, 32 octets) ou ``OBSIGATE_KEK_FILE`` (fichier 0600, hors dépôt,
+  hors arborescence des vaults). Elle n'est JAMAIS dérivée du secret
+  d'application, jamais journalisée, jamais renvoyée par API.
+- DEK : une clé aléatoire par coffre, stockée uniquement chiffrée par la KEK.
+- Version de secret : ciphertext AES-256-GCM + nonce unique + tag GCM
+  (le tag est inclus dans le ciphertext renvoyé par ``AESGCM.encrypt``).
+  Un tag invalide ou un fichier altéré = refus, jamais de valeur fausse.
+
+Le module reste importable sans ``cryptography`` installé : les opérations
+échouent alors avec ``CryptoIndisponibleError`` au lieu de casser le
+démarrage de l'application (le routeur répond 503 dans ce cas).
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import logging
+import os
+import stat
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("obsigate.coffre_crypto")
+
+# Annotation explicite : sans elle, mypy refuse l'assignation de deux types
+# (la classe AESGCM importée, puis None dans le repli sans cryptography)
+# et le commentaire `type: ignore[assignment]` ne couvre pas ce code [misc].
+AESGCM: type[Any] | None
+try:  # cryptography est une dépendance de la Phase 1a (requirements.txt)
+    from cryptography.exceptions import InvalidTag
+    from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+except Exception:  # pragma: no cover - environnement sans cryptography
+    AESGCM = None
+    InvalidTag = Exception  # type: ignore[assignment,misc]
+
+
+class CoffreCryptoError(Exception):
+    """Erreur générique du chiffrement du coffre."""
+
+
+class KEKAbsenteError(CoffreCryptoError):
+    """Aucune KEK configurée (ni OBSIGATE_KEK, ni OBSIGATE_KEK_FILE)."""
+
+
+class KEKInvalideError(CoffreCryptoError):
+    """KEK mal formée (ni base64 32 octets, ni hex 64 caractères)."""
+
+
+class TagInvalideError(CoffreCryptoError):
+    """Authentification GCM échouée : données altérées ou mauvaise clé."""
+
+
+class CryptoIndisponibleError(CoffreCryptoError):
+    """La bibliothèque ``cryptography`` n'est pas installée."""
+
+
+def _require_aesgcm() -> type[Any]:
+    """Retourne la classe AESGCM, ou lève si cryptography est absent.
+
+    Retourner la classe (plutôt qu'un simple garde) permet à mypy de
+    savoir que l'appelant détient bien un constructible, et non None.
+    """
+    if AESGCM is None:
+        raise CryptoIndisponibleError(
+            "cryptography n'est pas installé (dépendance Phase 1a)"
+        )
+    return AESGCM
+
+
+def parse_kek(raw: str) -> bytes:
+    """Parse une KEK : base64 (32 octets) ou hex (64 caractères).
+
+    Accepte le base64 standard et URL-safe, avec ou sans padding.
+    """
+    value = (raw or "").strip()
+    if not value:
+        raise KEKInvalideError("KEK vide")
+    # Hex d'abord si la forme correspond (64 caractères hex).
+    if len(value) == 64:
+        try:
+            decoded = bytes.fromhex(value)
+        except ValueError:
+            decoded = b""
+        if len(decoded) == 32:
+            return decoded
+    padded = value + "=" * (-len(value) % 4)
+    for decoder in (base64.urlsafe_b64decode, base64.b64decode):
+        try:
+            decoded = decoder(padded)
+        except (binascii.Error, ValueError):
+            continue
+        if len(decoded) == 32:
+            return decoded
+    raise KEKInvalideError("KEK invalide : attendu base64 de 32 octets")
+
+
+def generate_kek_b64() -> str:
+    """Génère une KEK 256 bits, encodée base64 (à sauvegarder hors dépôt)."""
+    return base64.b64encode(os.urandom(32)).decode("ascii")
+
+
+def load_kek() -> bytes:
+    """Charge la KEK depuis l'environnement ou le fichier dédié.
+
+    Priorité : ``OBSIGATE_KEK`` puis ``OBSIGATE_KEK_FILE``. Le fichier doit
+    être en 0600 (aucun droit groupe/autre) ; sinon, refus explicite.
+    """
+    env_kek = os.environ.get("OBSIGATE_KEK", "").strip()
+    if env_kek:
+        return parse_kek(env_kek)
+    kek_file = os.environ.get("OBSIGATE_KEK_FILE", "").strip()
+    if kek_file:
+        path = Path(kek_file)
+        try:
+            mode = path.stat().st_mode
+        except OSError as exc:
+            raise KEKAbsenteError(f"Fichier KEK illisible : {kek_file}") from exc
+        if mode & (stat.S_IRWXG | stat.S_IRWXO):
+            raise KEKInvalideError(
+                "Fichier KEK trop permissif : attendu 0600, "
+                f"droits groupe/autre détectés sur {kek_file}"
+            )
+        try:
+            return parse_kek(path.read_text(encoding="utf-8"))
+        except OSError as exc:
+            raise KEKAbsenteError(f"Fichier KEK illisible : {kek_file}") from exc
+    raise KEKAbsenteError("Aucune KEK configurée (OBSIGATE_KEK / OBSIGATE_KEK_FILE)")
+
+
+def kek_presente() -> bool:
+    """True si une KEK valide est chargeable, False sinon (jamais d'exception)."""
+    try:
+        load_kek()
+    except CoffreCryptoError:
+        return False
+    return True
+
+
+def generate_dek() -> bytes:
+    """Génère une DEK aléatoire 256 bits pour un coffre."""
+    return os.urandom(32)
+
+
+def _b64(data: bytes) -> str:
+    return base64.b64encode(data).decode("ascii")
+
+
+def _unb64(value: str) -> bytes:
+    return base64.b64decode(value)
+
+
+def encrypt_with_key(key: bytes, plaintext: bytes, aad: bytes) -> dict:
+    """Chiffre avec AES-256-GCM. Retourne {nonce, ciphertext} en base64."""
+    aesgcm = _require_aesgcm()
+    nonce = os.urandom(12)
+    ciphertext = aesgcm(key).encrypt(nonce, plaintext, aad)
+    return {"nonce": _b64(nonce), "ciphertext": _b64(ciphertext)}
+
+
+def decrypt_with_key(key: bytes, nonce_b64: str, ciphertext_b64: str, aad: bytes) -> bytes:
+    """Déchiffre avec AES-256-GCM. Tag invalide -> TagInvalideError."""
+    aesgcm = _require_aesgcm()
+    try:
+        return aesgcm(key).decrypt(_unb64(nonce_b64), _unb64(ciphertext_b64), aad)
+    except InvalidTag as exc:
+        raise TagInvalideError("Tag GCM invalide : données altérées ou mauvaise clé") from exc
+    except (binascii.Error, ValueError) as exc:
+        raise TagInvalideError("Données chiffrées mal formées") from exc
+
+
+def wrap_dek(dek: bytes, kek: bytes, coffre_id: str) -> dict:
+    """Chiffre une DEK avec la KEK (AAD = identifiant du coffre)."""
+    return encrypt_with_key(kek, dek, coffre_id.encode("utf-8"))
+
+
+def unwrap_dek(wrapped: dict, kek: bytes, coffre_id: str) -> bytes:
+    """Déchiffre une DEK avec la KEK."""
+    return decrypt_with_key(
+        kek, wrapped["nonce"], wrapped["ciphertext"], coffre_id.encode("utf-8")
+    )
+
+
+def encrypt_secret_value(dek: bytes, secret_id: str, version: int, valeur: str) -> dict:
+    """Chiffre une valeur de secret (AAD = secret_id:version)."""
+    aad = f"{secret_id}:{version}".encode()
+    return encrypt_with_key(dek, valeur.encode("utf-8"), aad)
+
+
+def decrypt_secret_value(
+    dek: bytes, secret_id: str, version: int, nonce_b64: str, ciphertext_b64: str
+) -> str:
+    """Déchiffre une valeur de secret."""
+    aad = f"{secret_id}:{version}".encode()
+    return decrypt_with_key(dek, nonce_b64, ciphertext_b64, aad).decode("utf-8")
+
+
+def reencrypt_secret_value(
+    ancienne_dek: bytes,
+    nouvelle_dek: bytes,
+    secret_id: str,
+    version: int,
+    nonce_b64: str,
+    ciphertext_b64: str,
+) -> dict:
+    """Re-chiffre une version avec une nouvelle DEK (rotation DEK)."""
+    valeur = decrypt_secret_value(
+        ancienne_dek, secret_id, version, nonce_b64, ciphertext_b64
+    )
+    return encrypt_secret_value(nouvelle_dek, secret_id, version, valeur)

backend/coffre_migration.py

@@ -0,0 +1,306 @@
+"""Migration Phase 2 du coffre Secrets ObsiGate (issue #20).
+
+Bascule des clés aujourd'hui en clair dans ``data/api_keys.json`` vers le
+coffre d'instance « ObsiGate interne » (slug ``obsigate-interne``).
+
+Format source (constaté dans ``backend/ai.py`` et
+``backend/tools/secrets.py``) : un dictionnaire plat ``{NOM: valeur}``.
+Seules les entrées dont le nom ressemble à un secret sont migrables :
+clés IA et clés d'outils. Les valeurs non secrètes (par exemple
+``OBSIGATE_GITEA_URL``) ne sont JAMAIS migrées et ne sont jamais
+touchées par la purge.
+
+Règles de sécurité, non négociables :
+- Aucune fonction de ce module ne renvoie une valeur, ne la journalise,
+  ni ne l'écrit ailleurs que dans le coffre (chiffrée, via le store).
+  Les aperçus ne contiennent que des noms, des types et ``has_value``.
+- L'import ne supprime rien : il crée des secrets dans le coffre et
+  laisse ``api_keys.json`` intact. La purge est une étape séparée, qui
+  exige ``confirmer=True`` et ne supprime que les noms listés.
+- Un secret déjà présent dans le coffre n'est JAMAIS écrasé : il est
+  signalé dans ``deja_existants`` et la valeur du coffre est conservée.
+
+Limite connue, documentée dans ``docs/COFFRE-sauvegarde-restauration.md`` :
+les lecteurs actuels (``backend/ai.py``, ``backend/tools/secrets.py``)
+lisent encore ``api_keys.json`` (chemin relatif ``data/``, sans passer
+par ``OBSIGATE_DATA_DIR``). Purger le clair sans avoir branché le
+lecteur concerné sur le coffre rend donc la clé inaccessible à ce
+lecteur : la purge reste un choix explicite de l'opérateur, confirmé
+deux fois côté interface (import, puis purge).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+from pathlib import Path
+from typing import Any
+
+from backend.coffre_store import (
+    ValidationError,
+    create_coffre,
+    create_secret,
+    get_coffre,
+    get_secret,
+    resolve_data_dir,
+)
+
+logger = logging.getLogger("obsigate.coffre_migration")
+
+_lock = threading.RLock()
+
+COFFRE_INTERNE_SLUG = "obsigate-interne"
+COFFRE_INTERNE_NOM = "ObsiGate interne"
+
+# (nom dans api_keys.json, type de secret, service d'affichage).
+# Miroir des clés lues par backend/ai.py (clés IA) et par
+# backend/tools/secrets.py TOOL_KEY_NAMES (clés d'outils). L'URL Gitea
+# est volontairement absente : ce n'est pas un secret.
+CLES_MIGRABLES: tuple[tuple[str, str, str], ...] = (
+    ("DEEPSEEK_API_KEY", "api_key", "DeepSeek"),
+    ("OPENROUTER_API_KEY", "api_key", "OpenRouter"),
+    ("GEMINI_API_KEY", "api_key", "Gemini"),
+    ("NVIDIA_API_KEY", "api_key", "NVIDIA"),
+    ("QWENCLOUD_API_KEY", "api_key", "QwenCloud"),
+    ("XIAOMI_API_KEY", "api_key", "Xiaomi"),
+    ("MISTRAL_API_KEY", "api_key", "Mistral"),
+    ("OBSIGATE_TAVILY_API_KEY", "api_key", "Tavily"),
+    ("OBSIGATE_BRAVE_API_KEY", "api_key", "Brave"),
+    ("OBSIGATE_SERPAPI_API_KEY", "api_key", "SerpAPI"),
+    ("OBSIGATE_EXA_API_KEY", "api_key", "Exa"),
+    ("OBSIGATE_GITEA_TOKEN", "token", "Gitea"),
+    ("OBSIGATE_GITHUB_TOKEN", "token", "GitHub"),
+)
+
+_NOMS_MIGRABLES = {nom for nom, _, _ in CLES_MIGRABLES}
+
+
+def _nom_secret(nom_source: str) -> str:
+    """Nom de secret dérivé du nom source (minuscules, valide NOM_SECRET_RE)."""
+    return nom_source.lower()
+
+
+def _api_keys_path(base: Path) -> Path:
+    return base / "api_keys.json"
+
+
+def _read_api_keys(base: Path) -> dict:
+    path = _api_keys_path(base)
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as exc:
+        logger.warning("api_keys.json illisible (%s) : %s", path, exc)
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _write_api_keys(base: Path, data: dict) -> None:
+    """Écriture atomique tmp+rename, fichier final en 0600 (best-effort)."""
+    path = _api_keys_path(base)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    try:
+        os.chmod(tmp, 0o600)
+    except OSError:
+        pass
+    os.replace(tmp, path)
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+
+
+def lister_candidats(data_dir: str | Path | None = None) -> list:
+    """Aperçu de migration : métadonnées seules, jamais de valeur.
+
+    Chaque candidat porte ``nom`` (nom dans le coffre), ``source`` (nom
+    dans api_keys.json), ``type``, ``service``, ``has_value`` (une valeur
+    non vide est présente dans le fichier) et ``deja_existant`` (un
+    secret de ce nom existe déjà dans le coffre d'instance).
+    """
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        cles = _read_api_keys(base)
+        coffre = get_coffre(COFFRE_INTERNE_SLUG, base)
+        candidats = []
+        for source, type_secret, service in CLES_MIGRABLES:
+            nom = _nom_secret(source)
+            valeur = cles.get(source)
+            candidats.append(
+                {
+                    "nom": nom,
+                    "source": source,
+                    "type": type_secret,
+                    "service": service,
+                    "has_value": isinstance(valeur, str) and bool(valeur.strip()),
+                    "deja_existant": (
+                        get_secret(coffre["id"], nom, base) is not None
+                        if coffre is not None
+                        else False
+                    ),
+                }
+            )
+        return candidats
+
+
+def importer_api_keys(
+    data_dir: str | Path | None = None, cree_par: str = ""
+) -> dict:
+    """Importe les entrées avec valeur vers le coffre d'instance.
+
+    Ne supprime rien dans ``api_keys.json``. Retourne uniquement des
+    noms et des comptes : ``migres``, ``deja_existants``, ``sans_valeur``.
+    Lève ``KEKAbsenteError`` / ``CryptoIndisponibleError`` si le coffre
+    ne peut pas chiffrer (le routeur les traduit en 503).
+    """
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        cles = _read_api_keys(base)
+        coffre = get_coffre(COFFRE_INTERNE_SLUG, base)
+        if coffre is None:
+            coffre = create_coffre(
+                slug=COFFRE_INTERNE_SLUG,
+                nom=COFFRE_INTERNE_NOM,
+                proprietaire=(cree_par or "admin").strip(),
+                perimetre="instance",
+                description="Coffre d'instance : clés IA et clés d'outils migrées depuis api_keys.json (Phase 2).",
+                data_dir=base,
+            )
+        migres: list[str] = []
+        deja_existants: list[str] = []
+        sans_valeur: list[str] = []
+        for source, type_secret, service in CLES_MIGRABLES:
+            nom = _nom_secret(source)
+            valeur = cles.get(source)
+            if not (isinstance(valeur, str) and valeur.strip()):
+                sans_valeur.append(nom)
+                continue
+            if get_secret(coffre["id"], nom, base) is not None:
+                deja_existants.append(nom)
+                continue
+            create_secret(
+                coffre,
+                nom,
+                type_secret,
+                valeur,
+                service=service,
+                note="Migré depuis api_keys.json (Phase 2).",
+                data_dir=base,
+            )
+            migres.append(nom)
+        return {
+            "coffre": COFFRE_INTERNE_SLUG,
+            "migres": migres,
+            "deja_existants": deja_existants,
+            "sans_valeur": sans_valeur,
+        }
+
+
+def purger_api_keys(
+    noms: list[str] | None,
+    data_dir: str | Path | None = None,
+    confirmer: bool = False,
+) -> dict:
+    """Supprime du clair les noms listés, après confirmation explicite.
+
+    ``confirmer`` doit valoir True, sinon refus (jamais automatique).
+    Seuls les noms migrables sont acceptés ; un nom inconnu refuse
+    l'opération entière, pour ne jamais supprimer une clé par erreur.
+    Retourne ``supprimes`` et ``absents`` (noms, jamais de valeurs).
+    """
+    if not confirmer:
+        raise ValidationError(
+            "Suppression du clair refusée : confirmation explicite requise"
+        )
+    demandes = [(n or "").strip().lower() for n in (noms or [])]
+    # Accepte indifféremment le nom source (DEEPSEEK_API_KEY) ou le nom
+    # de secret (deepseek_api_key) ; tout le reste refuse l'opération.
+    noms_secrets = {_nom_secret(source) for source in _NOMS_MIGRABLES}
+    inconnus = [
+        n
+        for n in demandes
+        if n.upper() not in _NOMS_MIGRABLES and n not in noms_secrets
+    ]
+    if inconnus:
+        raise ValidationError(f"Noms inconnus, purge annulée : {', '.join(inconnus)}")
+    sources_a_supprimer = set()
+    for demande in demandes:
+        for source, _, _ in CLES_MIGRABLES:
+            if demande in (source.lower(), _nom_secret(source)):
+                sources_a_supprimer.add(source)
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        cles = _read_api_keys(base)
+        supprimes: list[str] = []
+        absents: list[str] = []
+        for source in sorted(sources_a_supprimer):
+            if source in cles:
+                del cles[source]
+                supprimes.append(_nom_secret(source))
+            else:
+                absents.append(_nom_secret(source))
+        _write_api_keys(base, cles)
+        return {"supprimes": supprimes, "absents": absents}
+
+
+def creer_consommateur_avec_octrois(
+    nom: str,
+    octrois_demandes: list[dict[str, Any]] | None,
+    cree_par: str,
+    data_dir: str | Path | None = None,
+) -> tuple[dict, str, list, list]:
+    """Enregistre un consommateur et ses octrois en une seule opération.
+
+    Retourne (consommateur public, jeton à usage unique, octrois créés,
+    erreurs). Une erreur sur un octroi (coffre ou secret introuvable)
+    n'annule pas le consommateur ni les autres octrois : elle est
+    signalée dans ``erreurs`` (noms seuls, jamais de valeurs). Le coffre
+    lui-même n'est jamais modifié par cette opération.
+    """
+    from backend.coffre_store import (  # import local : évite un cycle
+        IntrouvableError,
+        create_consommateur,
+        create_octroi,
+    )
+
+    base = resolve_data_dir(data_dir)
+    consommateur, jeton = create_consommateur(nom, cree_par, base)
+    crees: list[dict] = []
+    erreurs: list[dict] = []
+    for demande in octrois_demandes or []:
+        slug = str(demande.get("coffre_slug", "") or "")
+        secret_nom = str(demande.get("secret_nom", "") or "") or None
+        try:
+            coffre = get_coffre(slug, base)
+            if coffre is None:
+                raise IntrouvableError(f"Coffre introuvable : {slug}")
+            secret_id = None
+            if secret_nom is not None:
+                secret = get_secret(coffre["id"], secret_nom, base)
+                if secret is None:
+                    raise IntrouvableError(f"Secret introuvable : {secret_nom}")
+                secret_id = secret["id"]
+            octroi = create_octroi(
+                coffre=coffre,
+                cible_type="consommateur",
+                cible_id=consommateur["id"],
+                secret_id=secret_id,
+                cree_par=cree_par,
+                expiration=demande.get("expiration"),
+                data_dir=base,
+            )
+            crees.append(octroi)
+        except (IntrouvableError, ValidationError) as exc:
+            erreurs.append(
+                {
+                    "coffre_slug": slug,
+                    "secret_nom": secret_nom,
+                    "erreur": str(exc),
+                }
+            )
+    return consommateur, jeton, crees, erreurs

backend/coffre_store.py

@@ -0,0 +1,860 @@
+"""Store du coffre Secrets ObsiGate (Phase 1a).
+
+Patron repris de ``backend/tools/secrets.py`` : JSON dans ``data/``,
+écriture atomique (tmp + rename), verrou ``RLock`` sur les cycles
+lecture-modification-écriture, répertoire honorant ``OBSIGATE_DATA_DIR``.
+
+Fichiers (permissions 0600) :
+- ``data/coffres.json`` : coffres (métadonnées + DEK chiffrées),
+  consommateurs (jetons hachés SHA-256 seulement, jamais en clair),
+  octrois (références, statuts, expirations).
+- ``data/coffres_valeurs.json`` : versions chiffrées des secrets.
+
+Aucune valeur en clair n'est jamais persistée ici, et aucune fonction de
+ce module ne journalise de valeur ni de texte chiffré.
+
+Modèle :
+- Coffre : id, slug, nom, description, proprietaire, perimetre
+  (personnel | partage | instance), dek_chiffree (ou None en mode
+  dégradé sans KEK), statut (actif | archive), dates.
+- Secret : id, coffre_id, nom, type, service, note, expiration,
+  version_courante, cree_le, modifie_le, derniere_utilisation.
+- Version : numero, nonce, ciphertext, cree_le, remplacee_le.
+  Seule la version courante est distribuable.
+- Consommateur : id (sert de jti), nom, jeton_hash, jeton_prefixe,
+  statut (actif | revoque), cree_par, cree_le.
+- Octroi : id, coffre_id, secret_id (None = tout le coffre),
+  cible_type (consommateur | utilisateur | executeur | workspace),
+  cible_id, expiration, statut (actif | revoque | expire),
+  cree_par, cree_le, revoque_le.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import logging
+import os
+import re
+import secrets as _secrets
+import threading
+import uuid
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+from backend.coffre_crypto import (
+    decrypt_secret_value,
+    encrypt_secret_value,
+    generate_dek,
+    load_kek,
+    parse_kek,
+    reencrypt_secret_value,
+    unwrap_dek,
+    wrap_dek,
+)
+
+logger = logging.getLogger("obsigate.coffre_store")
+
+_lock = threading.RLock()
+
+SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9_-]{2,63}$")
+NOM_SECRET_RE = re.compile(r"^[a-z0-9][a-z0-9_-]{2,127}$")
+TYPES_SECRET = {"api_key", "token", "password", "certificate", "autre"}
+PERIMETRES = {"personnel", "partage", "instance"}
+CIBLES_OCTROI = {"consommateur", "utilisateur", "executeur", "workspace"}
+
+MAX_VALEUR = 65536
+MAX_TEXTE = 2000
+DUREE_OCTROI_DEFAUT_JOURS = 90
+
+# Motifs refusés dans les champs de métadonnées (description, note) :
+# une valeur ressemblant à un secret ne doit jamais transiter par un champ
+# qui, lui, est renvoyé en clair dans les métadonnées.
+_SECRET_LIKE_PATTERNS = (
+    re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----"),
+    re.compile(r"\bsk-[A-Za-z0-9]{8,}\b"),
+    re.compile(r"\bgh[opsu]_[A-Za-z0-9]{8,}\b"),
+    re.compile(r"\bAKIA[0-9A-Z]{16}\b"),
+    re.compile(
+        r"(?i)\b(token|secret|mot_de_passe|password|api[-_]?key)\s*[:=]\s*\S+"
+    ),
+)
+
+
+class StoreError(Exception):
+    """Erreur générique du store."""
+
+
+class CoffreExisteError(StoreError):
+    pass
+
+
+class SecretExisteError(StoreError):
+    pass
+
+
+class IntrouvableError(StoreError):
+    pass
+
+
+class ValidationError(StoreError):
+    pass
+
+
+class SecretExpireError(StoreError):
+    pass
+
+
+def resolve_data_dir(data_dir: str | Path | None = None) -> Path:
+    """Répertoire de persistance (OBSIGATE_DATA_DIR, défaut ``data``)."""
+    if data_dir is not None:
+        return Path(data_dir)
+    return Path(os.environ.get("OBSIGATE_DATA_DIR", "data"))
+
+
+def _coffres_path(base: Path) -> Path:
+    return base / "coffres.json"
+
+
+def _valeurs_path(base: Path) -> Path:
+    return base / "coffres_valeurs.json"
+
+
+def _now_iso() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def _parse_date(value: str | None) -> datetime | None:
+    """Parse une date ISO (datetime) ou une date seule (fin de journée UTC)."""
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    if len(text) == 10:
+        text = text + "T23:59:59+00:00"
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError as exc:
+        raise ValidationError(f"Date invalide : {value!r}") from exc
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    return parsed
+
+
+def est_expire(expiration: str | None, maintenant: datetime | None = None) -> bool:
+    """True si la date d'expiration est passée (None = jamais)."""
+    parsed = _parse_date(expiration)
+    if parsed is None:
+        return False
+    ref = maintenant or datetime.now(UTC)
+    return parsed <= ref
+
+
+def _read_json(path: Path, default: dict) -> dict:
+    if not path.exists():
+        return json.loads(json.dumps(default))
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as exc:
+        logger.warning("Store coffre illisible (%s) : %s", path, exc)
+        return json.loads(json.dumps(default))
+    return data if isinstance(data, dict) else json.loads(json.dumps(default))
+
+
+def _write_json(path: Path, data: dict) -> None:
+    """Écriture atomique tmp+rename, fichier final en 0600."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    try:
+        os.chmod(tmp, 0o600)
+    except OSError:
+        pass
+    os.replace(tmp, path)
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+
+
+def _load_coffres(base: Path) -> dict:
+    return _read_json(
+        _coffres_path(base),
+        {"coffres": [], "consommateurs": [], "octrois": []},
+    )
+
+
+def _load_valeurs(base: Path) -> dict:
+    return _read_json(_valeurs_path(base), {"versions": {}})
+
+
+def _save_coffres(base: Path, data: dict) -> None:
+    _write_json(_coffres_path(base), data)
+
+
+def _save_valeurs(base: Path, data: dict) -> None:
+    _write_json(_valeurs_path(base), data)
+
+
+def valider_slug(slug: str) -> str:
+    value = (slug or "").strip().lower()
+    if not SLUG_RE.match(value):
+        raise ValidationError(
+            "Slug invalide : 3 à 64 caractères, minuscules, chiffres, - ou _"
+        )
+    return value
+
+
+def valider_nom_secret(nom: str) -> str:
+    value = (nom or "").strip().lower()
+    if not NOM_SECRET_RE.match(value):
+        raise ValidationError(
+            "Nom de secret invalide : 3 à 128 caractères, minuscules, chiffres, - ou _"
+        )
+    return value
+
+
+def refuser_valeur_dans_metadonnees(texte: str | None, champ: str) -> None:
+    """Refuse une valeur ressemblant à un secret dans un champ métadonnée."""
+    if not texte:
+        return
+    for motif in _SECRET_LIKE_PATTERNS:
+        if motif.search(texte):
+            raise ValidationError(
+                f"Le champ {champ} ressemble à une valeur de secret ; "
+                "utilisez le champ valeur du secret, jamais une métadonnée"
+            )
+
+
+def _valider_texte(texte: str | None, champ: str) -> str:
+    value = (texte or "").strip()
+    if len(value) > MAX_TEXTE:
+        raise ValidationError(f"Le champ {champ} dépasse {MAX_TEXTE} caractères")
+    refuser_valeur_dans_metadonnees(value, champ)
+    return value
+
+
+# ---------------------------------------------------------------------------
+# Coffres
+# ---------------------------------------------------------------------------
+
+def list_coffres(data_dir: str | Path | None = None) -> list:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        return list(_load_coffres(base)["coffres"])
+
+
+def get_coffre(slug: str, data_dir: str | Path | None = None) -> dict | None:
+    base = resolve_data_dir(data_dir)
+    slug = valider_slug(slug)
+    with _lock:
+        for coffre in _load_coffres(base)["coffres"]:
+            if coffre["slug"] == slug:
+                return coffre
+    return None
+
+
+def get_coffre_or_404(slug: str, data_dir: str | Path | None = None) -> dict:
+    coffre = get_coffre(slug, data_dir)
+    if coffre is None:
+        raise IntrouvableError(f"Coffre introuvable : {slug}")
+    return coffre
+
+
+def get_coffre_by_id(coffre_id: str, data_dir: str | Path | None = None) -> dict | None:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        for coffre in _load_coffres(base)["coffres"]:
+            if coffre["id"] == coffre_id:
+                return coffre
+    return None
+
+
+def get_octroi(octroi_id: str, data_dir: str | Path | None = None) -> dict | None:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        for octroi in _load_coffres(base)["octrois"]:
+            if octroi["id"] == octroi_id:
+                return octroi
+    return None
+
+
+def create_coffre(
+    slug: str,
+    nom: str,
+    proprietaire: str,
+    perimetre: str = "personnel",
+    description: str = "",
+    data_dir: str | Path | None = None,
+) -> dict:
+    """Crée un coffre. Sans KEK, la DEK reste None (mode dégradé) : les
+    métadonnées sont créées, mais aucun secret ne pourra être ajouté tant
+    que la KEK n'est pas configurée."""
+    base = resolve_data_dir(data_dir)
+    slug = valider_slug(slug)
+    if perimetre not in PERIMETRES:
+        raise ValidationError(f"Périmètre invalide : {perimetre}")
+    if not (proprietaire or "").strip():
+        raise ValidationError("Propriétaire requis")
+    description = _valider_texte(description, "description")
+    nom = (nom or "").strip()
+    if not nom or len(nom) > 128:
+        raise ValidationError("Nom de coffre requis (128 caractères max)")
+    with _lock:
+        data = _load_coffres(base)
+        if any(c["slug"] == slug for c in data["coffres"]):
+            raise CoffreExisteError(f"Coffre déjà existant : {slug}")
+        coffre: dict[str, Any] = {
+            "id": str(uuid.uuid4()),
+            "slug": slug,
+            "nom": nom,
+            "description": description,
+            "proprietaire": proprietaire.strip(),
+            "perimetre": perimetre,
+            "dek_chiffree": None,
+            "statut": "actif",
+            "cree_le": _now_iso(),
+        }
+        try:
+            kek = load_kek()
+        except Exception:
+            kek = None
+        if kek is not None:
+            coffre["dek_chiffree"] = wrap_dek(generate_dek(), kek, coffre["id"])
+        data["coffres"].append(coffre)
+        _save_coffres(base, data)
+        return coffre
+
+
+def ensure_dek(coffre: dict, data_dir: str | Path | None = None) -> bytes:
+    """Retourne la DEK en clair (mémoire seulement). Génère et persiste la
+    DEK si le coffre a été créé en mode dégradé et que la KEK est là."""
+    base = resolve_data_dir(data_dir)
+    kek = load_kek()  # lève KEKAbsenteError si aucune KEK
+    if coffre.get("dek_chiffree"):
+        return unwrap_dek(coffre["dek_chiffree"], kek, coffre["id"])
+    with _lock:
+        data = _load_coffres(base)
+        for item in data["coffres"]:
+            if item["id"] == coffre["id"]:
+                if item.get("dek_chiffree"):
+                    return unwrap_dek(item["dek_chiffree"], kek, item["id"])
+                dek = generate_dek()
+                item["dek_chiffree"] = wrap_dek(dek, kek, item["id"])
+                _save_coffres(base, data)
+                return dek
+    raise IntrouvableError("Coffre introuvable pour génération de DEK")
+
+
+# Les secrets vivent dans coffres.json (métadonnées), leurs versions dans
+# coffres_valeurs.json (chiffrées). Les deux chargements sont faits ici
+# pour garder une seule source de vérité dans ce module.
+def _load_tout(base: Path) -> tuple[dict, dict]:
+    data = _load_coffres(base)
+    if "secrets" not in data:
+        data["secrets"] = []
+    return data, _load_valeurs(base)
+
+
+def compter_secrets(coffre_id: str, data_dir: str | Path | None = None) -> int:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        data, _ = _load_tout(base)
+        return sum(1 for s in data["secrets"] if s["coffre_id"] == coffre_id)
+
+
+def list_secrets(coffre_id: str, data_dir: str | Path | None = None) -> list:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        data, _ = _load_tout(base)
+        return [s for s in data["secrets"] if s["coffre_id"] == coffre_id]
+
+
+def get_secret(
+    coffre_id: str, nom: str, data_dir: str | Path | None = None
+) -> dict | None:
+    base = resolve_data_dir(data_dir)
+    nom = valider_nom_secret(nom)
+    with _lock:
+        data, _ = _load_tout(base)
+        for secret in data["secrets"]:
+            if secret["coffre_id"] == coffre_id and secret["nom"] == nom:
+                return secret
+    return None
+
+
+def secret_metadata(secret: dict, octrois_actifs: int = 0) -> dict:
+    """Vue métadonnées seules d'un secret : jamais de valeur, jamais de
+    texte chiffré, jamais de nonce."""
+    return {
+        "id": secret["id"],
+        "nom": secret["nom"],
+        "type": secret["type"],
+        "service": secret.get("service", ""),
+        "note": secret.get("note", ""),
+        "expiration": secret.get("expiration"),
+        "expire": est_expire(secret.get("expiration")),
+        "version": secret["version_courante"],
+        "has_value": True,
+        "cree_le": secret["cree_le"],
+        "modifie_le": secret["modifie_le"],
+        "derniere_utilisation": secret.get("derniere_utilisation"),
+        "octrois_actifs": octrois_actifs,
+        "reference": f"coffre:{secret['coffre_slug']}/{secret['nom']}",
+    }
+
+
+def create_secret(
+    coffre: dict,
+    nom: str,
+    type_secret: str,
+    valeur: str,
+    service: str = "",
+    expiration: str | None = None,
+    note: str = "",
+    data_dir: str | Path | None = None,
+) -> dict:
+    """Chiffre et stocke un secret (nouvelle version 1)."""
+    base = resolve_data_dir(data_dir)
+    nom = valider_nom_secret(nom)
+    if type_secret not in TYPES_SECRET:
+        raise ValidationError(f"Type de secret invalide : {type_secret}")
+    if not valeur or len(valeur) > MAX_VALEUR:
+        raise ValidationError("Valeur requise (64 KiB max)")
+    service = (service or "").strip()
+    if len(service) > 128:
+        raise ValidationError("Service trop long (128 caractères max)")
+    note = _valider_texte(note, "note")
+    if expiration is not None:
+        _parse_date(expiration)
+    dek = ensure_dek(coffre, base)  # KEKAbsenteError si pas de KEK
+    with _lock:
+        data, valeurs = _load_tout(base)
+        if any(
+            s["coffre_id"] == coffre["id"] and s["nom"] == nom
+            for s in data["secrets"]
+        ):
+            raise SecretExisteError(f"Secret déjà existant : {nom}")
+        secret_id = str(uuid.uuid4())
+        chiffre = encrypt_secret_value(dek, secret_id, 1, valeur)
+        secret = {
+            "id": secret_id,
+            "coffre_id": coffre["id"],
+            "coffre_slug": coffre["slug"],
+            "nom": nom,
+            "type": type_secret,
+            "service": service,
+            "note": note,
+            "expiration": expiration,
+            "version_courante": 1,
+            "cree_le": _now_iso(),
+            "modifie_le": _now_iso(),
+            "derniere_utilisation": None,
+        }
+        data["secrets"].append(secret)
+        valeurs["versions"][secret_id] = [
+            {
+                "numero": 1,
+                "nonce": chiffre["nonce"],
+                "ciphertext": chiffre["ciphertext"],
+                "cree_le": secret["cree_le"],
+                "remplacee_le": None,
+            }
+        ]
+        _save_coffres(base, data)
+        _save_valeurs(base, valeurs)
+        return secret
+
+
+def rotate_secret(
+    coffre: dict, nom: str, valeur: str, data_dir: str | Path | None = None
+) -> dict:
+    """Rotation : nouvelle version active immédiatement, l'ancienne n'est
+    plus distribuable (seule la version courante est lue à la distribution)."""
+    base = resolve_data_dir(data_dir)
+    nom = valider_nom_secret(nom)
+    if not valeur or len(valeur) > MAX_VALEUR:
+        raise ValidationError("Valeur requise (64 KiB max)")
+    dek = ensure_dek(coffre, base)
+    with _lock:
+        data, valeurs = _load_tout(base)
+        secret = None
+        for item in data["secrets"]:
+            if item["coffre_id"] == coffre["id"] and item["nom"] == nom:
+                secret = item
+                break
+        if secret is None:
+            raise IntrouvableError(f"Secret introuvable : {nom}")
+        nouvelle_version = secret["version_courante"] + 1
+        chiffre = encrypt_secret_value(dek, secret["id"], nouvelle_version, valeur)
+        versions = valeurs["versions"].setdefault(secret["id"], [])
+        for version in versions:
+            if version["remplacee_le"] is None:
+                version["remplacee_le"] = _now_iso()
+        versions.append(
+            {
+                "numero": nouvelle_version,
+                "nonce": chiffre["nonce"],
+                "ciphertext": chiffre["ciphertext"],
+                "cree_le": _now_iso(),
+                "remplacee_le": None,
+            }
+        )
+        secret["version_courante"] = nouvelle_version
+        secret["modifie_le"] = _now_iso()
+        _save_coffres(base, data)
+        _save_valeurs(base, valeurs)
+        return secret
+
+
+def delete_secret(
+    coffre: dict, nom: str, data_dir: str | Path | None = None
+) -> tuple[dict, list]:
+    """Supprime un secret, ses versions et ses octrois (cascade)."""
+    base = resolve_data_dir(data_dir)
+    nom = valider_nom_secret(nom)
+    with _lock:
+        data, valeurs = _load_tout(base)
+        secret = None
+        for item in data["secrets"]:
+            if item["coffre_id"] == coffre["id"] and item["nom"] == nom:
+                secret = item
+                break
+        if secret is None:
+            raise IntrouvableError(f"Secret introuvable : {nom}")
+        data["secrets"] = [s for s in data["secrets"] if s["id"] != secret["id"]]
+        valeurs["versions"].pop(secret["id"], None)
+        octrois_supprimes = [
+            o for o in data["octrois"] if o.get("secret_id") == secret["id"]
+        ]
+        data["octrois"] = [
+            o for o in data["octrois"] if o.get("secret_id") != secret["id"]
+        ]
+        _save_coffres(base, data)
+        _save_valeurs(base, valeurs)
+        return secret, octrois_supprimes
+
+
+def distribuer_valeur(
+    coffre: dict, secret: dict, data_dir: str | Path | None = None
+) -> str:
+    """Déchiffre la version courante d'un secret (après contrôles d'octroi
+    faits par le routeur). Refuse un secret expiré (410 côté routeur)."""
+    base = resolve_data_dir(data_dir)
+    if est_expire(secret.get("expiration")):
+        raise SecretExpireError("Secret expiré")
+    dek = ensure_dek(coffre, base)
+    with _lock:
+        _, valeurs = _load_tout(base)
+        versions = valeurs["versions"].get(secret["id"], [])
+        courante = None
+        for version in versions:
+            if version["numero"] == secret["version_courante"]:
+                courante = version
+                break
+        if courante is None:
+            raise IntrouvableError("Version courante introuvable")
+        return decrypt_secret_value(
+            dek,
+            secret["id"],
+            secret["version_courante"],
+            courante["nonce"],
+            courante["ciphertext"],
+        )
+
+
+def toucher_utilisation(secret_id: str, data_dir: str | Path | None = None) -> None:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        data, _ = _load_tout(base)
+        for secret in data["secrets"]:
+            if secret["id"] == secret_id:
+                secret["derniere_utilisation"] = _now_iso()
+                _save_coffres(base, data)
+                return
+
+
+def rotate_dek(coffre_slug: str, data_dir: str | Path | None = None) -> dict:
+    """Rotation DEK : re-chiffre toutes les versions du coffre avec une
+    nouvelle DEK, puis remplace la DEK chiffrée du coffre."""
+    base = resolve_data_dir(data_dir)
+    coffre = get_coffre_or_404(coffre_slug, base)
+    kek = load_kek()
+    ancienne_dek = ensure_dek(coffre, base)
+    nouvelle_dek = generate_dek()
+    with _lock:
+        data, valeurs = _load_tout(base)
+        secrets_coffre = [s for s in data["secrets"] if s["coffre_id"] == coffre["id"]]
+        for secret in secrets_coffre:
+            nouvelles_versions = []
+            for version in valeurs["versions"].get(secret["id"], []):
+                nouvelles_versions.append(
+                    {
+                        **reencrypt_secret_value(
+                            ancienne_dek,
+                            nouvelle_dek,
+                            secret["id"],
+                            version["numero"],
+                            version["nonce"],
+                            version["ciphertext"],
+                        ),
+                        "numero": version["numero"],
+                        "cree_le": version["cree_le"],
+                        "remplacee_le": version["remplacee_le"],
+                    }
+                )
+            valeurs["versions"][secret["id"]] = nouvelles_versions
+        for item in data["coffres"]:
+            if item["id"] == coffre["id"]:
+                item["dek_chiffree"] = wrap_dek(nouvelle_dek, kek, item["id"])
+                coffre = item
+                break
+        _save_coffres(base, data)
+        _save_valeurs(base, valeurs)
+        return coffre
+
+
+def rotate_kek(nouvelle_kek_b64: str, data_dir: str | Path | None = None) -> int:
+    """Rotation KEK : re-chiffre uniquement les DEK avec la nouvelle KEK.
+    L'opérateur doit ensuite remplacer OBSIGATE_KEK / OBSIGATE_KEK_FILE
+    par la nouvelle valeur (cette fonction ne touche pas à l'environnement).
+    Retourne le nombre de coffres re-chiffrés."""
+    base = resolve_data_dir(data_dir)
+    ancienne_kek = load_kek()
+    nouvelle_kek = parse_kek(nouvelle_kek_b64)
+    count = 0
+    with _lock:
+        data = _load_coffres(base)
+        for coffre in data["coffres"]:
+            if not coffre.get("dek_chiffree"):
+                continue
+            dek = unwrap_dek(coffre["dek_chiffree"], ancienne_kek, coffre["id"])
+            coffre["dek_chiffree"] = wrap_dek(dek, nouvelle_kek, coffre["id"])
+            count += 1
+        _save_coffres(base, data)
+        return count
+
+
+# ---------------------------------------------------------------------------
+# Consommateurs (jetons serveur-à-serveur, hachés, révocables par jti)
+# ---------------------------------------------------------------------------
+
+def _hash_jeton(jeton: str) -> str:
+    return hashlib.sha256(jeton.encode("utf-8")).hexdigest()
+
+
+def list_consommateurs(data_dir: str | Path | None = None) -> list:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        return [
+            {k: v for k, v in c.items() if k != "jeton_hash"}
+            for c in _load_coffres(base)["consommateurs"]
+        ]
+
+
+def create_consommateur(
+    nom: str, cree_par: str, data_dir: str | Path | None = None
+) -> tuple[dict, str]:
+    """Crée un consommateur et retourne (métadonnées, jeton à usage unique).
+    Le jeton n'est JAMAIS persisté : seul son hash SHA-256 est stocké."""
+    base = resolve_data_dir(data_dir)
+    nom = (nom or "").strip()
+    if not nom or len(nom) > 128:
+        raise ValidationError("Nom de consommateur requis (128 caractères max)")
+    jeton = "csk_" + _secrets.token_urlsafe(32)
+    with _lock:
+        data = _load_coffres(base)
+        consommateur = {
+            "id": str(uuid.uuid4()),
+            "nom": nom,
+            "jeton_hash": _hash_jeton(jeton),
+            "jeton_prefixe": jeton[:12],
+            "statut": "actif",
+            "cree_par": cree_par,
+            "cree_le": _now_iso(),
+        }
+        data["consommateurs"].append(consommateur)
+        _save_coffres(base, data)
+        public = {k: v for k, v in consommateur.items() if k != "jeton_hash"}
+        return public, jeton
+
+
+def verifier_jeton_consommateur(
+    jeton: str, data_dir: str | Path | None = None
+) -> dict | None:
+    """Retourne le consommateur (sans hash) si le jeton correspond, sinon None."""
+    if not jeton:
+        return None
+    base = resolve_data_dir(data_dir)
+    cible = _hash_jeton(jeton)
+    with _lock:
+        for consommateur in _load_coffres(base)["consommateurs"]:
+            if hmac.compare_digest(consommateur.get("jeton_hash", ""), cible):
+                return {
+                    k: v for k, v in consommateur.items() if k != "jeton_hash"
+                }
+    return None
+
+
+def revoquer_consommateur(
+    consommateur_id: str, data_dir: str | Path | None = None
+) -> dict:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        data = _load_coffres(base)
+        for consommateur in data["consommateurs"]:
+            if consommateur["id"] == consommateur_id:
+                consommateur["statut"] = "revoque"
+                _save_coffres(base, data)
+                return {
+                    k: v
+                    for k, v in consommateur.items()
+                    if k != "jeton_hash"
+                }
+    raise IntrouvableError("Consommateur introuvable")
+
+
+# ---------------------------------------------------------------------------
+# Octrois
+# ---------------------------------------------------------------------------
+
+def list_octrois(coffre_id: str, data_dir: str | Path | None = None) -> list:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        return [
+            o for o in _load_coffres(base)["octrois"] if o["coffre_id"] == coffre_id
+        ]
+
+
+def compter_octrois_actifs(
+    secret_id: str, data_dir: str | Path | None = None
+) -> int:
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        return sum(
+            1
+            for o in _load_coffres(base)["octrois"]
+            if o.get("secret_id") == secret_id
+            and o["statut"] == "actif"
+            and not est_expire(o.get("expiration"))
+        )
+
+
+def create_octroi(
+    coffre: dict,
+    cible_type: str,
+    cible_id: str,
+    secret_id: str | None,
+    cree_par: str,
+    expiration: str | None = None,
+    data_dir: str | Path | None = None,
+) -> dict:
+    base = resolve_data_dir(data_dir)
+    if cible_type not in CIBLES_OCTROI:
+        raise ValidationError(f"Type de cible invalide : {cible_type}")
+    if not (cible_id or "").strip():
+        raise ValidationError("Cible d'octroi requise")
+    if secret_id is not None:
+        with _lock:
+            data = _load_coffres(base)
+            if not any(
+                s["id"] == secret_id and s["coffre_id"] == coffre["id"]
+                for s in data["secrets"]
+            ):
+                raise IntrouvableError("Secret introuvable dans ce coffre")
+    if expiration is None:
+        expiration = (datetime.now(UTC) + timedelta(days=DUREE_OCTROI_DEFAUT_JOURS)).isoformat()
+    else:
+        _parse_date(expiration)
+    with _lock:
+        data = _load_coffres(base)
+        octroi = {
+            "id": str(uuid.uuid4()),
+            "coffre_id": coffre["id"],
+            "secret_id": secret_id,
+            "cible_type": cible_type,
+            "cible_id": cible_id.strip(),
+            "expiration": expiration,
+            "statut": "actif",
+            "cree_par": cree_par,
+            "cree_le": _now_iso(),
+            "revoque_le": None,
+        }
+        data["octrois"].append(octroi)
+        _save_coffres(base, data)
+        return octroi
+
+
+def revoquer_octroi(octroi_id: str, data_dir: str | Path | None = None) -> dict:
+    """Révocation : statut -> revoque (conservé pour distinguer
+    octroi_revoque de octroi_absent à la distribution)."""
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        data = _load_coffres(base)
+        for octroi in data["octrois"]:
+            if octroi["id"] == octroi_id:
+                octroi["statut"] = "revoque"
+                octroi["revoque_le"] = _now_iso()
+                _save_coffres(base, data)
+                return octroi
+    raise IntrouvableError("Octroi introuvable")
+
+
+def statut_octroi_consommateur(
+    consommateur_id: str,
+    coffre_id: str,
+    secret_id: str,
+    data_dir: str | Path | None = None,
+) -> tuple[str, dict | None]:
+    """Statut d'accès d'un consommateur à un secret.
+
+    Retourne ("ok" | "revoque" | "expire" | "absent", octroi). Un octroi
+    coffre-wide (secret_id None) couvre tous les secrets du coffre.
+    Priorité : ok > revoque > expire > absent (un octroi révoqué ne doit
+    jamais être masqué par l'absence d'un autre octroi)."""
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        candidats = [
+            o
+            for o in _load_coffres(base)["octrois"]
+            if o["cible_type"] == "consommateur"
+            and o["cible_id"] == consommateur_id
+            and o["coffre_id"] == coffre_id
+            and (o.get("secret_id") is None or o["secret_id"] == secret_id)
+        ]
+    for octroi in candidats:
+        if octroi["statut"] == "actif" and not est_expire(octroi.get("expiration")):
+            return "ok", octroi
+    for octroi in candidats:
+        if octroi["statut"] == "revoque":
+            return "revoque", octroi
+    for octroi in candidats:
+        if octroi["statut"] == "actif" and est_expire(octroi.get("expiration")):
+            return "expire", octroi
+    return "absent", None
+
+
+def secrets_accessibles_utilisateur(
+    username: str, coffre: dict, data_dir: str | Path | None = None
+) -> set | None:
+    """Secrets d'un coffre visibles par un utilisateur via octroi.
+
+    Retourne None si un octroi coffre-wide actif existe (tout le coffre),
+    sinon l'ensemble des ids de secrets octroyés, sinon l'ensemble vide."""
+    base = resolve_data_dir(data_dir)
+    with _lock:
+        octrois = [
+            o
+            for o in _load_coffres(base)["octrois"]
+            if o["cible_type"] == "utilisateur"
+            and o["cible_id"] == username
+            and o["coffre_id"] == coffre["id"]
+            and o["statut"] == "actif"
+            and not est_expire(o.get("expiration"))
+        ]
+    if any(o.get("secret_id") is None for o in octrois):
+        return None
+    return {o["secret_id"] for o in octrois if o.get("secret_id")}

backend/draco_config.py

@@ -0,0 +1,197 @@
+"""URLs publiques de l'écosystème dracodev — par configuration (#223).
+
+Règle dev/prod (Bruno, 2026-10-25) : **aucun nom public de
+l'écosystème n'est figé dans le code vivant**. Chaque URL publique
+vient de l'environnement ; les valeurs par défaut sont les noms
+**officiels** (sans suffixe) de la future production. L'environnement
+dev déclare ses noms en ``-dev`` dans son seul ``.env`` — le code
+n'en connaît aucun.
+
+Variables (voir ``.env.example``) :
+
+- ``DRACO_AGENT_URL``     — base publique du service d'agents ;
+  à défaut, l'origine est **dérivée** de ``AGENT_EVENEMENTS_URL``
+  (la configuration réelle de l'émission d'événements, #220), puis
+  le défaut officiel.
+- ``DRACO_OBSIGATE_URL``  — base publique d'ObsiGate (liens profonds).
+- ``DRACO_FLOWDECK_URL``  — base publique de Flowdeck.
+- ``DRACO_TIKTAK_URL``    — base publique de TikTak.
+- ``DRACO_KANBANTE_URL``  — base publique de Kanbante.
+- ``DRACO_GITEA_URL``     — base publique de Gitea (les cartes
+  Kanbante *sont* des issues Gitea, contrat liens-profonds) ;
+  distincte de ``OBSIGATE_GITEA_URL`` (source connectée de
+  l'assistant, réglable depuis l'UI, pas une URL d'affichage).
+
+Résolution d'une URL sœur (BUG-120) : la variable explicite prime ;
+à défaut, l'**environnement est dérivé de l'hôte de l'agent** tel
+qu'ObsiGate le connaît déjà (:func:`agent_url`) — si cet hôte est de
+la forme ``agent<SUFFIXE>.dracodev.net`` (``-dev`` en dev, vide en
+prod), l'URL sœur est ``https://<slug><SUFFIXE>.dracodev.net``. Un
+hôte hors motif (autre domaine, LAN, IP, port) ne dérive **rien** :
+on ne fabrique jamais un lien deviné, le défaut officiel s'applique.
+L'installation pointe donc les bons liens selon son environnement
+sans déclarer les quatre ``DRACO_<APP>_URL``.
+
+Ce module ne lit l'environnement qu'à l'appel (jamais à l'import) :
+les tests et un changement de ``.env`` suivi d'un redémarrage
+prennent effet sans état figé.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from urllib.parse import urlparse
+
+# Défauts officiels (production future) — jamais de nom en ``-dev`` ici.
+DEFAUTS: dict[str, str] = {
+    "agent": "https://agent.dracodev.net",
+    "obsigate": "https://og.dracodev.net",
+    "flowdeck": "https://flowdeck.dracodev.net",
+    "tiktak": "https://tiktak.dracodev.net",
+    "kanbante": "https://kanbante.dracodev.net",
+    "gitea": "https://git.dracodev.net",
+}
+
+_VARIABLES: dict[str, str] = {
+    "agent": "DRACO_AGENT_URL",
+    "obsigate": "DRACO_OBSIGATE_URL",
+    "flowdeck": "DRACO_FLOWDECK_URL",
+    "tiktak": "DRACO_TIKTAK_URL",
+    "kanbante": "DRACO_KANBANTE_URL",
+    "gitea": "DRACO_GITEA_URL",
+}
+
+# Slugs d'hôte des applications sœurs pour la dérivation
+# d'environnement (BUG-120) : premier label de ``<slug>.dracodev.net``
+# (et de ``<slug>-dev.dracodev.net`` en dev). Gitea est **exclue** :
+# son URL ne se dérive jamais.
+_SLUGS_HOTE: dict[str, str] = {
+    "obsigate": "og",
+    "flowdeck": "flowdeck",
+    "tiktak": "tiktak",
+    "kanbante": "kanbante",
+}
+
+# Premier label de l'hôte de l'agent : ``agent`` suivi d'un suffixe
+# d'environnement éventuel (``-dev`` en dev, vide en prod).
+_MOTIF_AGENT = re.compile(r"^agent(-[a-z0-9-]*)?$")
+
+
+def _nettoyer(valeur: str) -> str:
+    return valeur.strip().rstrip("/")
+
+
+def origine(url: str) -> str:
+    """Origine ``schéma://hôte[:port]`` d'une URL (``""`` si illisible)."""
+    u = urlparse(url or "")
+    if u.scheme and u.netloc:
+        return f"{u.scheme}://{u.netloc}"
+    return ""
+
+
+def agent_url() -> str:
+    """Base publique du service d'agents.
+
+    Priorité : ``DRACO_AGENT_URL``, puis l'origine de
+    ``AGENT_EVENEMENTS_URL`` (déjà la configuration réelle du poste),
+    puis le défaut officiel.
+    """
+    explicite = _nettoyer(os.environ.get(_VARIABLES["agent"], ""))
+    if explicite:
+        return explicite
+    evenements = _nettoyer(os.environ.get("AGENT_EVENEMENTS_URL", ""))
+    if evenements:
+        derivee = origine(evenements)
+        if derivee:
+            return derivee
+    return DEFAUTS["agent"]
+
+
+def agent_origine() -> str:
+    """Origine du service d'agents, pour la CSP (``connect-src``/``frame-src``)."""
+    return origine(agent_url()) or DEFAUTS["agent"]
+
+
+def _suffixe_environnement() -> str | None:
+    """Suffixe d'environnement déduit de l'hôte de l'agent (BUG-120).
+
+    Lit l'hôte de :func:`agent_url` — l'origine de l'agent telle
+    qu'ObsiGate la connaît déjà (``DRACO_AGENT_URL``, à défaut
+    ``AGENT_EVENEMENTS_URL``). Si cet hôte est exactement de la forme
+    ``agent<SUFFIXE>.dracodev.net`` sans port, retourne ``SUFFIXE``
+    (``-dev`` en dev, ``""`` en prod). Sinon (autre domaine, LAN, IP,
+    port exotique) retourne ``None`` : aucune dérivation, on ne
+    fabrique jamais un lien deviné.
+    """
+    u = urlparse(agent_url())
+    hote = (u.hostname or "").lower()
+    labels = hote.split(".")
+    if len(labels) != 3 or labels[1:] != ["dracodev", "net"]:
+        return None
+    try:
+        if u.port is not None:
+            return None
+    except ValueError:
+        return None
+    motif = _MOTIF_AGENT.match(labels[0])
+    if motif is None:
+        return None
+    return motif.group(1) or ""
+
+
+def app_url(app: str) -> str:
+    """Base publique d'une application de l'écosystème (sans ``/`` final).
+
+    Résolution d'une URL sœur (BUG-120) : ``DRACO_<APP>_URL``
+    explicite d'abord ; à défaut, dérivation d'environnement depuis
+    l'hôte de l'agent (:func:`_suffixe_environnement`) ; à défaut,
+    le défaut officiel. L'URL Gitea ne se dérive jamais.
+    """
+    if app == "agent":
+        return agent_url()
+    variable = _VARIABLES[app]
+    explicite = _nettoyer(os.environ.get(variable, ""))
+    if explicite:
+        return explicite
+    if app in _SLUGS_HOTE:
+        suffixe = _suffixe_environnement()
+        if suffixe is not None:
+            return f"https://{_SLUGS_HOTE[app]}{suffixe}.dracodev.net"
+    return DEFAUTS[app]
+
+
+def app_hote(app: str) -> str:
+    """Nom d'hôte (minuscules) de l'URL publique configurée de *app*."""
+    return (urlparse(app_url(app)).hostname or "").lower()
+
+
+def hotes_reconnus() -> dict[str, str]:
+    """``{hôte: app}`` pour le parseur de liens profonds.
+
+    Contient **toujours** les hôtes officiels (un lien collé depuis la
+    production reste reconnaissable en dev, et réciproquement) **plus**
+    l'hôte résolu de chaque application (les noms en ``-dev`` du poste,
+    déclarés dans son ``.env`` ou dérivés de l'hôte de l'agent).
+    """
+    hotes: dict[str, str] = {}
+    for app, defaut in DEFAUTS.items():
+        hote = (urlparse(defaut).hostname or "").lower()
+        if hote:
+            hotes[hote] = app
+    for app in DEFAUTS:
+        hote = app_hote(app)
+        if hote:
+            hotes[hote] = app
+    return hotes
+
+
+def urls_publiques() -> dict[str, str]:
+    """Carte des URL publiques injectée à l'hôte web (``window.DRACO_URLS``).
+
+    C'est le contrat d'injection de dracodev-commons : l'application
+    hôte (ici ObsiGate, qui sert ``index.html``) fournit les URL aux
+    assets partagés (panneau Spark, barre, liens) — les assets ne
+    portent que les défauts officiels en repli.
+    """
+    return {app: app_url(app) for app in DEFAUTS}

backend/export.py

@@ -359,7 +359,7 @@ def export_epub(vault_path: Path, file_path: Path) -> bytes:
 
     rendered = _render_body(body, path.parent, vault_path, path)
 
-    uid = f"obsigate-{_slugify(title)}-{int(datetime.datetime.now(tz=datetime.timezone.utc).timestamp())}"
+    uid = f"obsigate-{_slugify(title)}-{int(datetime.datetime.now(tz=datetime.UTC).timestamp())}"
     xhtml = f"""<?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE html>
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
@@ -383,7 +383,7 @@ def export_epub(vault_path: Path, file_path: Path) -> bytes:
     <dc:title>{html_mod.escape(title)}</dc:title>
     <dc:creator>{html_mod.escape(author)}</dc:creator>
     <dc:language>fr</dc:language>
-    <meta property="dcterms:modified">{datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')}</meta>
+    <meta property="dcterms:modified">{datetime.datetime.now(datetime.UTC).strftime('%Y-%m-%dT%H:%M:%SZ')}</meta>
   </metadata>
   <manifest>
     <item id="ncx" href="toc.ncx" media-type="application/x-dtbncx+xml"/>

backend/external_refs.py

@@ -24,7 +24,7 @@ import uuid
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
-from urllib.parse import parse_qs, unquote, urlparse
+from urllib.parse import parse_qs, quote, unquote, urlparse
 
 logger = logging.getLogger("obsigate.external_refs")
 
@@ -64,26 +64,87 @@ def _write_refs(username: str, refs: list[dict[str, Any]]) -> None:
 
 # ------------------------------------------------------------ parseur d'URL
 
+def build_deep_link(target_app: str, target_type: str, target_id: str) -> str | None:
+    """Construit l'URL profonde d'affichage depuis la **configuration**
+    courante (#223), ou ``None`` si la forme est inconnue.
+
+    Les références stockées portent une URL absolue figée au moment du
+    collage (voir ``add_ref``) : elle peut nommer l'autre environnement
+    (un lien collé en prod, lu en dev). L'affichage ne l'utilise donc
+    jamais telle quelle — il reconstruit l'URL depuis
+    ``(target_app, target_type, target_id)`` et les bases publiques
+    configurées (``backend.draco_config``), au moment de la lecture.
+    Aucune donnée stockée n'est migrée ni réécrite.
+    """
+    from backend.draco_config import app_url
+
+    if target_app == "tiktak":
+        if target_type == "task":
+            return f"{app_url('tiktak')}/?task={quote(target_id, safe='')}"
+        if target_type == "list":
+            return f"{app_url('tiktak')}/?list={quote(target_id, safe='')}"
+        return None
+    if target_app == "obsigate" and target_type == "note":
+        return f"{app_url('obsigate')}/#file={quote(target_id, safe=':')}"
+    if target_app == "flowdeck":
+        if target_type == "page":
+            return f"{app_url('flowdeck')}/pages/{quote(target_id, safe='')}"
+        if target_type == "project":
+            return f"{app_url('flowdeck')}/collections/{quote(target_id, safe='')}"
+        return None
+    if target_app == "kanbante" and target_type == "card":
+        m = re.fullmatch(r"([^/]+)/([^/#]+)#(\d+)", target_id or "")
+        if m:
+            owner, repo, num = m.groups()
+            return f"{app_url('gitea')}/{owner}/{repo}/issues/{num}"
+        return None
+    return None
+
+
+def _avec_url_affichee(ref: dict[str, Any]) -> dict[str, Any]:
+    """Copie de la référence dont ``target_url`` est reconstruite
+    depuis la config courante (#223) — le stockage n'est pas touché."""
+    construite = build_deep_link(
+        str(ref.get("target_app") or ""),
+        str(ref.get("target_type") or ""),
+        str(ref.get("target_id") or ""),
+    )
+    if construite is None:
+        return ref
+    copie = dict(ref)
+    copie["target_url"] = construite
+    return copie
+
+
 def parse_deep_link(url: str) -> tuple[str, str, str, str] | None:
     """Reconnaît une URL profonde des applications dracodev.
 
     Formes figées par ``dracodev-commons/contrats/liens-profonds.md``.
     Retourne ``(target_app, target_type, target_id, label_par_défaut)``
     ou ``None`` si l'URL ne correspond à aucune forme du contrat.
+
+    Hôtes reconnus (#223) : les hôtes **officiels** et les hôtes
+    **configurés** de chaque application (``backend.draco_config``) —
+    un lien collé depuis l'environnement courant (noms en ``-dev``
+    déclarés dans son ``.env``) comme depuis l'autre environnement
+    est donc reconnu ; aucun nom d'environnement n'est figé ici.
     """
+    from backend.draco_config import hotes_reconnus
+
     try:
         u = urlparse((url or "").strip())
     except ValueError:
         return None
     host = (u.hostname or "").lower()
-    if host == "tiktak.dracodev.net":
+    app = hotes_reconnus().get(host)
+    if app == "tiktak":
         q = parse_qs(u.query)
         if q.get("task"):
             return ("tiktak", "task", q["task"][0], f"TikTak · tâche {q['task'][0]}")
         if q.get("list"):
             return ("tiktak", "list", q["list"][0], f"TikTak · liste {q['list'][0]}")
         return None
-    if host == "og.dracodev.net":
+    if app == "obsigate":
         frag = u.fragment or ""
         if frag.startswith("file="):
             cible = unquote(frag[5:])
@@ -91,7 +152,7 @@ def parse_deep_link(url: str) -> tuple[str, str, str, str] | None:
                 nom = cible.rsplit("/", 1)[-1]
                 return ("obsigate", "note", cible, f"ObsiGate · {nom}")
         return None
-    if host == "flowdeck.dracodev.net":
+    if app == "flowdeck":
         m = re.fullmatch(r"/pages/(\d+)", u.path or "")
         if m:
             return ("flowdeck", "page", m.group(1), f"Flowdeck · page {m.group(1)}")
@@ -99,7 +160,7 @@ def parse_deep_link(url: str) -> tuple[str, str, str, str] | None:
         if m:
             return ("flowdeck", "project", m.group(1), f"Flowdeck · projet {m.group(1)}")
         return None
-    if host == "git.dracodev.net":
+    if app == "gitea":
         m = re.fullmatch(r"/([^/]+)/([^/]+)/issues/(\d+)", u.path or "")
         if m:
             owner, repo, num = m.groups()
@@ -111,20 +172,25 @@ def parse_deep_link(url: str) -> tuple[str, str, str, str] | None:
 # ------------------------------------------------------------ CRUD
 
 def list_refs(username: str, vault: str, path: str) -> list[dict[str, Any]]:
-    """Références posées sur une note, dans l'ordre de création."""
+    """Références posées sur une note, dans l'ordre de création.
+
+    ``target_url`` de chaque référence retournée est **reconstruite
+    depuis la config courante** (#223, ``_avec_url_affichee``) : la
+    valeur stockée, figée au collage, n'est jamais servie telle quelle.
+    """
     if not username:
         return []
     return [
-        r for r in _read_refs(username)
+        _avec_url_affichee(r) for r in _read_refs(username)
         if r.get("owner_vault") == vault and r.get("owner_path") == path
     ]
 
 
 def get_ref(username: str, ref_id: str) -> dict[str, Any] | None:
-    """Une référence par son identifiant, ou ``None``."""
+    """Une référence par son identifiant, ou ``None`` (URL reconstruite, #223)."""
     for r in _read_refs(username):
         if r.get("id") == ref_id:
-            return r
+            return _avec_url_affichee(r)
     return None
 
 
@@ -169,4 +235,4 @@ def delete_ref(username: str, ref_id: str) -> dict[str, Any] | None:
         return None
     removed = next(r for r in refs if r.get("id") == ref_id)
     _write_refs(username, kept)
-    return removed
+    return _avec_url_affichee(removed)

backend/guide_export.py

@@ -355,7 +355,7 @@ def _export_footer(lang: str) -> str:
     template = loc.get("guide105.export_footer", "")
     if "%s" not in template and "{" not in template:
         template = "ObsiGate {version}"
-    today = datetime.datetime.now(tz=datetime.timezone.utc).date().isoformat()
+    today = datetime.datetime.now(tz=datetime.UTC).date().isoformat()
     return _collapse(template).format(version=_app_version(), date=today)
 
 

backend/indexer.py

@@ -5,7 +5,7 @@ import os
 import re
 import threading
 from collections.abc import Callable
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -581,7 +581,7 @@ def _scan_vault(
             try:
                 relative = fpath.relative_to(vault_root)
                 stat = fpath.stat()
-                modified = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat()
+                modified = datetime.fromtimestamp(stat.st_mtime, tz=UTC).isoformat()
 
                 # #86 differential scan: reuse the previous entry when neither
                 # size nor mtime changed — skips the disk read + parse below.
@@ -866,7 +866,7 @@ async def build_index(progress_callback=None) -> None:
 
     # Record timestamp of full index rebuild
     global _last_full_index_ts
-    _last_full_index_ts = datetime.now(timezone.utc).isoformat()
+    _last_full_index_ts = datetime.now(UTC).isoformat()
 
     # Build attachment index
     from backend.attachment_indexer import build_attachment_index
@@ -1033,7 +1033,7 @@ def _index_single_file_sync(vault_name: str, vault_path: str, file_path: str, va
             return None
 
         stat = fpath.stat()
-        modified = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat()
+        modified = datetime.fromtimestamp(stat.st_mtime, tz=UTC).isoformat()
 
         # PDF handling — binary, must go through pdf_reader (same as _scan_vault)
         tags: list[str] = []

backend/main.py

@@ -186,15 +186,21 @@ class SecurityHeadersMiddleware(BaseHTTPMiddleware):
             # avec un nonce frais (`backend.csp`) ou servis par 'self'/CDN
             # listés s'exécutent. `style-src` garde 'unsafe-inline' (attributs
             # `style=` et `el.style` omniprésents — chantier séparé).
+            # #223 : l'origine du service d'agents n'est pas figée — elle
+            # est dérivée de la configuration (DRACO_AGENT_URL, sinon
+            # l'origine d'AGENT_EVENEMENTS_URL, sinon le défaut officiel).
+            from backend.draco_config import agent_origine
+
+            agent = agent_origine()
             response.headers["Content-Security-Policy"] = (
                 "default-src 'self'; "
                 f"script-src 'self' 'nonce-{nonce}' blob: https://cdnjs.cloudflare.com https://unpkg.com https://esm.sh https://cdn.jsdelivr.net https://static.cloudflareinsights.com; "
                 "style-src 'self' 'unsafe-inline' https://cdnjs.cloudflare.com https://fonts.googleapis.com https://cdn.jsdelivr.net https://esm.sh; "
                 "img-src 'self' data: blob:; "
-                "connect-src 'self' blob: https://esm.sh https://unpkg.com https://cdnjs.cloudflare.com https://fonts.googleapis.com https://fonts.gstatic.com https://cdn.jsdelivr.net; "
+                f"connect-src 'self' blob: https://esm.sh https://unpkg.com https://cdnjs.cloudflare.com https://fonts.googleapis.com https://fonts.gstatic.com https://cdn.jsdelivr.net {agent}; "
                 "font-src 'self' data: https://fonts.gstatic.com https://esm.sh; "
                 "worker-src 'self' blob:; "
-                "frame-src 'self' blob:; "
+                f"frame-src 'self' blob: {agent}; "
                 "object-src 'none'; "
                 "base-uri 'self'; "
                 "form-action 'self'; "
@@ -524,6 +530,7 @@ from backend.auth.middleware import (
 from backend.auth.router import router as auth_router
 from backend.bookslm_routes import router as bookslm_router
 from backend.routers.backups import router as backups_router
+from backend.routers.coffres import router as coffres_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
@@ -558,6 +565,7 @@ 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(coffres_router)  # Coffre Secrets Phase 1b — JAMAIS dans vaults.py
 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
@@ -829,6 +837,36 @@ def _html_with_nonce(request: Request, name: str) -> str:
         request.state.csp_nonce,
     )
 
+
+def _index_html(request: Request) -> str:
+    """``index.html`` + injection des URL publiques de l'écosystème (#223).
+
+    Contrat d'injection de dracodev-commons : l'hôte (ObsiGate, qui
+    sert la page) fournit les URL aux assets partagés — panneau Spark,
+    barre d'apps, liens inter-apps lisent ``window.DRACO_URLS`` et ne
+    portent que les défauts officiels en repli. Les valeurs viennent
+    de :mod:`backend.draco_config` (environnement ; défauts officiels,
+    noms en ``-dev`` déclarés par le seul ``.env`` du poste). Le script
+    injecté passe par le même mécanisme de nonce CSP que les autres
+    scripts inline de la page.
+    """
+    import json as _json
+
+    from backend.csp import inject_csp_nonce
+    from backend.draco_config import urls_publiques
+
+    html = (FRONTEND_DIR / "index.html").read_text(encoding="utf-8")
+    script = (
+        "<script>window.DRACO_URLS = "
+        + _json.dumps(urls_publiques()).replace("<", "\\u003c")
+        + ";</script>"
+    )
+    if "</head>" in html:
+        html = html.replace("</head>", script + "</head>", 1)
+    else:  # repli défensif : tout en tête de document
+        html = script + html
+    return inject_csp_nonce(html, request.state.csp_nonce)
+
 if FRONTEND_DIR.exists():
     # ``Cache-Control`` for /static is set by SecurityHeadersMiddleware (no-cache).
     app.mount("/static", StaticFiles(directory=str(FRONTEND_DIR)), name="static")
@@ -907,5 +945,5 @@ if FRONTEND_DIR.exists():
         """Serve the SPA index.html for all non-API routes."""
         index_file = FRONTEND_DIR / "index.html"
         if index_file.exists():
-            return HTMLResponse(content=_html_with_nonce(request, "index.html"), headers={"Cache-Control": "no-cache"})
+            return HTMLResponse(content=_index_html(request), headers={"Cache-Control": "no-cache"})
         raise HTTPException(status_code=404, detail="Frontend not found")

backend/notify.py

@@ -25,7 +25,7 @@ import os
 import smtplib
 import threading
 import uuid
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from email.message import EmailMessage
 from pathlib import Path
 from typing import Any
@@ -182,7 +182,7 @@ def create_channel(name: str, channel_type: str, config: dict[str, Any]) -> dict
             "type": channel_type,
             "enabled": True,
             "config": normalized,
-            "created_at": datetime.now(timezone.utc).isoformat(),
+            "created_at": datetime.now(UTC).isoformat(),
             "last_sent_at": None,
             "last_error": None,
         }
@@ -287,7 +287,7 @@ def _send_webhook(url: str, title: str, message: str, trigger: str) -> None:
             "event": trigger,
             "title": title,
             "message": message,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "timestamp": datetime.now(UTC).isoformat(),
             "source": "obsigate-notify",
         },
         timeout=10.0,
@@ -345,6 +345,6 @@ def _mark_sent(channel_id: str, error: str | None) -> None:
         channels = _read_channels()
         for channel in channels:
             if channel.get("id") == channel_id:
-                channel["last_sent_at"] = datetime.now(timezone.utc).isoformat()
+                channel["last_sent_at"] = datetime.now(UTC).isoformat()
                 channel["last_error"] = error
         _write_channels(channels)

backend/openapi_docs.py

@@ -41,6 +41,7 @@ TAGS_METADATA: list[dict[str, str]] = [
     {"name": "Webhooks", "description": "HTTP callbacks signed with HMAC-SHA256 for file events."},
     {"name": "Conflicts", "description": "Detect and resolve Syncthing sync-conflict files."},
     {"name": "Admin", "description": "Admin-only system monitoring: stats, audit log, backup stats and live stream."},
+    {"name": "Coffres Secrets", "description": "Secret vaults: encrypted coffres, secrets, consumers, grants and distribution — metadata only, values are never exposed."},
     {"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)."},

backend/push.py

@@ -6,7 +6,7 @@ import base64
 import json
 import logging
 import os
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -185,7 +185,7 @@ async def subscribe_push(
         "keys": request.subscription.keys,
         "vault": request.vault,
         "username": username,
-        "created_at": datetime.now(timezone.utc).isoformat()
+        "created_at": datetime.now(UTC).isoformat()
     }
     
     _push_subscriptions.append(subscription)

backend/requirements.txt

@@ -16,13 +16,16 @@ sortedcontainers>=2.4.0
 snowballstemmer>=2.2.0
 weasyprint>=70.0
 httpx>=0.27.0
-# Plancher de sécurité (BUG-093) : 6.16.0 est vulnérable à deux DoS de
-# ressources (PYSEC-2026-3910 outlines, PYSEC-2026-3911 XForm, fix 6.16.1),
-# atteignables via backend/pdf_reader.py (PDF fournis par l'utilisateur).
-# Le plancher doit être >= 6.16.1 : l'image Act du runner embarque 6.16.0
-# dans sa toolcache Python, donc un plancher trop bas est « already satisfied »
-# et n'est jamais mis à niveau.
-pypdf>=6.16.1
+# Plancher de sécurité (BUG-093, relevé par #224) : 6.16.0 est vulnérable à
+# deux DoS de ressources (PYSEC-2026-3910 outlines, PYSEC-2026-3911 XForm,
+# fix 6.16.1), atteignables via backend/pdf_reader.py (PDF fournis par
+# l'utilisateur). #224 : la version préinstallée dans la toolcache du
+# runner (6.19.0) est frappée par 11 CVE supplémentaires (dont
+# CVE-2026-113786, CVE-2026-115572, CVE-2026-115585, CVE-2026-115580),
+# corrigées au plus tard en 6.21.2 — le plancher doit être >= 6.21.2 :
+# en dessous, pip répond « already satisfied » pour la toolcache et
+# n'aligne jamais (même piège que BUG-093).
+pypdf>=6.21.2
 pyotp>=2.10.0
 segno>=1.5.0
 webauthn==2.6.0
@@ -55,3 +58,24 @@ multidict>=6.9.1
 # transitive (httpx/requests) — sans plancher explicite, pip-audit
 # signale la version héritée de l'environnement.
 certifi>=2026.10.19
+# Planchers de sécurité (#224) : paquets transitifs ou préinstallés dans
+# la toolcache du runner, audités par pip-audit (CI, bloquant) mais jamais
+# alignés sans plancher explicite — « already satisfied » (même piège que
+# BUG-093). Versions relevées par le job security du run sur 2.78.0 :
+# brotli 1.2.0 (transitive fonttools[woff] via weasyprint) — PYSEC-2026-4322
+# et GHSA-9v8h-qqgm-4m35, corrigées en 1.2.1.
+brotli>=1.2.1
+# filelock 3.32.3 (transitive de CacheControl, outil pip-audit, et
+# préinstallée dans la toolcache) — CVE-2026-112940, CVE-2026-112913 et
+# CVE-2026-112907, corrigées en 4.2.1.
+filelock>=4.2.1
+# opentelemetry-api 1.37.0 (préinstallée dans la toolcache du runner,
+# aucune dépendance directe d'ObsiGate) — CVE-2026-114603, corrigée
+# en 1.45.1.
+opentelemetry-api>=1.45.1
+# Coffre Secrets (Phase 1a) : chiffrement par enveloppe AES-256-GCM.
+cryptography>=44.0
+
+# Plancher de securite : msgpack est transitif, version 1.2.1 relevee par le job
+# security (pip-audit, bloquant) — CVE-2026-114613, corrigee en 1.2.3.
+msgpack>=1.2.3

backend/routers/backups.py

@@ -19,7 +19,7 @@ Adaptations strictement équivalentes :
 import logging
 import os
 import time
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -207,7 +207,7 @@ async def api_backups_list(
                 "file": rel_file,
                 "backup_file": fpath.name,
                 "timestamp": ts,
-                "datetime": datetime.fromtimestamp(ts, tz=timezone.utc).isoformat(),
+                "datetime": datetime.fromtimestamp(ts, tz=UTC).isoformat(),
                 "size": fsize,
                 "full_path": str(fpath),
             })

backend/routers/coffres.py

@@ -0,0 +1,731 @@
+"""API du coffre Secrets ObsiGate (Phase 1b, spec §7, §10, §11).
+
+Monté dans ``backend/main.py`` à côté de ``config_router`` — JAMAIS dans
+``backend/routers/vaults.py`` : un coffre n'est pas un vault de notes, il
+ne passe ni par l'indexeur, ni par la recherche, ni par le graphe, et
+aucun outil MCP de secret n'existe.
+
+Règles d'or, appliquées côté serveur à chaque requête :
+- Toutes les lectures renvoient des métadonnées seules (``has_value``,
+  version, dates, octrois actifs) : jamais de valeur, jamais de texte
+  chiffré, jamais de nonce.
+- Seul ``POST /api/coffres/distribuer`` rend une valeur, et uniquement à
+  un consommateur authentifié par jeton (hash + jti, jamais la session
+  utilisateur), avec un octroi actif et un contexte obligatoire.
+- Autorisations (spec §6) : le propriétaire seul sur son coffre
+  personnel ; l'admin gère les coffres d'instance, les consommateurs et
+  la KEK, jamais le coffre personnel d'autrui ; l'ACL « * » des vaults
+  ne donne AUCUN droit sur un coffre (``check_vault_access`` n'est pas
+  utilisé ici, volontairement).
+- Feature flag ``OBSIGATE_SECRETS_ENABLED`` (défaut désactivé) : tant
+  qu'il n'est pas activé, toutes les routes répondent 503.
+- Phase 2 (issues #20) : migration ``api_keys.json`` -> coffre
+  d'instance, en deux temps (import, puis purge confirmée), et
+  enregistrement d'un consommateur avec ses octrois en un appel.
+- Phase 3 (issue #21) : ``/distribuer`` accepte le contexte Spark à
+  plat ou imbriqué (``contexte: {type: "mission", id}``) ; les codes
+  d'erreur restent ceux de la Phase 1b (voir
+  ``docs/COFFRE-contrat-distribution.md`` pour la correspondance avec
+  l'état ``acces_requis`` côté Spark).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Request
+
+from backend.audit import get_recent_entries, log_coffre_event
+from backend.auth.middleware import require_admin, require_auth
+from backend.coffre_crypto import (
+    CryptoIndisponibleError,
+    KEKAbsenteError,
+    generate_kek_b64,
+)
+from backend.coffre_migration import (
+    COFFRE_INTERNE_SLUG,
+    creer_consommateur_avec_octrois,
+    importer_api_keys,
+    lister_candidats,
+    purger_api_keys,
+)
+from backend.coffre_store import (
+    CoffreExisteError,
+    IntrouvableError,
+    SecretExisteError,
+    SecretExpireError,
+    ValidationError,
+    compter_octrois_actifs,
+    compter_secrets,
+    create_coffre,
+    create_consommateur,
+    create_octroi,
+    create_secret,
+    delete_secret,
+    distribuer_valeur,
+    get_coffre,
+    get_coffre_by_id,
+    get_coffre_or_404,
+    get_octroi,
+    get_secret,
+    list_coffres,
+    list_consommateurs,
+    list_octrois,
+    list_secrets,
+    revoquer_consommateur,
+    revoquer_octroi,
+    rotate_dek,
+    rotate_kek,
+    rotate_secret,
+    secret_metadata,
+    secrets_accessibles_utilisateur,
+    statut_octroi_consommateur,
+    toucher_utilisation,
+    verifier_jeton_consommateur,
+)
+
+logger = logging.getLogger("obsigate.coffres")
+
+router = APIRouter(tags=["Coffres Secrets"])
+
+CODES_ERREUR = {
+    "octroi_absent",
+    "octroi_revoque",
+    "octroi_expire",
+    "secret_expire",
+    "kek_absente",
+    "contexte_manquant",
+    "consommateur_invalide",
+    "consommateur_revoque",
+    "crypto_indisponible",
+    "secrets_desactives",
+}
+
+
+def secrets_actives() -> bool:
+    """Feature flag : défaut désactivé, activation explicite par l'opérateur."""
+    return os.environ.get("OBSIGATE_SECRETS_ENABLED", "false").lower() in (
+        "1",
+        "true",
+        "yes",
+        "on",
+    )
+
+
+def _exiger_actives() -> None:
+    if not secrets_actives():
+        raise HTTPException(status_code=503, detail="secrets_desactives")
+
+
+def _username(user: dict) -> str:
+    return str(user.get("username", ""))
+
+
+def _est_admin(user: dict) -> bool:
+    return user.get("role") == "admin"
+
+
+def _peut_voir_coffre(user: dict, coffre: dict) -> bool:
+    """Voir les métadonnées d'un coffre."""
+    if coffre["proprietaire"] == _username(user):
+        return True
+    if _est_admin(user) and coffre["perimetre"] == "instance":
+        return True
+    # Octroi utilisateur (coffre-wide ou par secret) : accès en lecture.
+    accessibles = secrets_accessibles_utilisateur(_username(user), coffre)
+    if accessibles is None:
+        return True
+    return len(accessibles) > 0
+
+
+def _peut_gerer_coffre(user: dict, coffre: dict) -> bool:
+    """Créer / roter / supprimer des secrets et gérer les octrois."""
+    if coffre["proprietaire"] == _username(user):
+        return True
+    return _est_admin(user) and coffre["perimetre"] == "instance"
+
+
+def _exiger_voir(user: dict, coffre: dict) -> None:
+    if not _peut_voir_coffre(user, coffre):
+        raise HTTPException(status_code=403, detail="Accès refusé à ce coffre")
+
+
+def _exiger_gerer(user: dict, coffre: dict) -> None:
+    if not _peut_gerer_coffre(user, coffre):
+        raise HTTPException(status_code=403, detail="Accès refusé à ce coffre")
+
+
+def _coffre_or_404(slug: str) -> dict:
+    try:
+        return get_coffre_or_404(slug)
+    except IntrouvableError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+def _secret_or_404(coffre: dict, nom: str) -> dict:
+    try:
+        secret = get_secret(coffre["id"], nom)
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    if secret is None:
+        raise HTTPException(status_code=404, detail=f"Secret introuvable : {nom}")
+    return secret
+
+
+def _metadata_coffre(coffre: dict) -> dict:
+    return {
+        "slug": coffre["slug"],
+        "nom": coffre["nom"],
+        "description": coffre.get("description", ""),
+        "proprietaire": coffre["proprietaire"],
+        "perimetre": coffre["perimetre"],
+        "statut": coffre["statut"],
+        "kek_configuree": coffre.get("dek_chiffree") is not None,
+        "nb_secrets": compter_secrets(coffre["id"]),
+        "cree_le": coffre["cree_le"],
+    }
+
+
+def _metadata_secret(coffre: dict, secret: dict) -> dict:
+    return secret_metadata(secret, compter_octrois_actifs(secret["id"]))
+
+
+def _secrets_visibles(user: dict, coffre: dict) -> list:
+    """Secrets visibles par l'utilisateur (métadonnées seules)."""
+    if coffre["proprietaire"] == _username(user) or (
+        _est_admin(user) and coffre["perimetre"] == "instance"
+    ):
+        return [_metadata_secret(coffre, s) for s in list_secrets(coffre["id"])]
+    accessibles = secrets_accessibles_utilisateur(_username(user), coffre)
+    if accessibles is None:
+        return [_metadata_secret(coffre, s) for s in list_secrets(coffre["id"])]
+    return [
+        _metadata_secret(coffre, s)
+        for s in list_secrets(coffre["id"])
+        if s["id"] in accessibles
+    ]
+
+
+def _audit(user: str, action: str, **kwargs) -> None:
+    try:
+        log_coffre_event(user, action, **kwargs)
+    except Exception as exc:  # l'audit ne doit jamais casser l'opération
+        logger.warning("Échec audit coffre (%s) : %s", action, exc)
+
+
+# ---------------------------------------------------------------------------
+# Coffres
+# ---------------------------------------------------------------------------
+
+@router.get("/api/coffres")
+async def api_list_coffres(current_user=Depends(require_auth)):
+    _exiger_actives()
+    visibles = [c for c in list_coffres() if _peut_voir_coffre(current_user, c)]
+    return [_metadata_coffre(c) for c in visibles]
+
+
+@router.post("/api/coffres")
+async def api_create_coffre(body: dict = Body(...), current_user=Depends(require_auth)):
+    _exiger_actives()
+    slug = body.get("slug", "")
+    perimetre = body.get("perimetre", "personnel")
+    if perimetre == "instance" and not _est_admin(current_user):
+        raise HTTPException(
+            status_code=403, detail="Seul un admin peut créer un coffre d'instance"
+        )
+    try:
+        coffre = create_coffre(
+            slug=slug,
+            nom=body.get("nom", ""),
+            proprietaire=_username(current_user),
+            perimetre=perimetre,
+            description=body.get("description", ""),
+        )
+    except CoffreExisteError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    _audit(
+        _username(current_user),
+        "coffre_cree",
+        coffre=coffre["slug"],
+        resultat="ok",
+    )
+    return _metadata_coffre(coffre)
+
+
+# ---------------------------------------------------------------------------
+# Consommateurs (admin seulement, jeton rendu une seule fois)
+# ---------------------------------------------------------------------------
+
+@router.get("/api/coffres/consommateurs")
+async def api_list_consommateurs(current_user=Depends(require_admin)):
+    _exiger_actives()
+    return list_consommateurs()
+
+
+@router.post("/api/coffres/consommateurs")
+async def api_create_consommateur(
+    body: dict = Body(...), current_user=Depends(require_admin)
+):
+    _exiger_actives()
+    try:
+        consommateur, jeton = create_consommateur(
+            nom=body.get("nom", ""), cree_par=_username(current_user)
+        )
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    _audit(
+        _username(current_user),
+        "consommateur_cree",
+        consommateur=consommateur["nom"],
+        resultat="ok",
+    )
+    # Le jeton n'est rendu qu'ici, jamais stocké en clair, jamais relisté.
+    return {**consommateur, "jeton": jeton}
+
+
+@router.post("/api/coffres/consommateurs/avec-octrois")
+async def api_create_consommateur_avec_octrois(
+    body: dict = Body(...), current_user=Depends(require_admin)
+):
+    """Phase 4 : enregistrer une app = un consommateur + ses octrois.
+
+    Le coffre n'est jamais modifié par cette opération. Le jeton n'est
+    rendu qu'ici, jamais stocké en clair, jamais relisté. Un octroi en
+    erreur (coffre ou secret introuvable) est signalé dans ``erreurs``
+    sans annuler le consommateur ni les autres octrois.
+    """
+    _exiger_actives()
+    try:
+        consommateur, jeton, octrois, erreurs = creer_consommateur_avec_octrois(
+            nom=body.get("nom", ""),
+            octrois_demandes=body.get("octrois") or [],
+            cree_par=_username(current_user),
+        )
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    _audit(
+        _username(current_user),
+        "consommateur_cree",
+        consommateur=consommateur["nom"],
+        resultat="ok",
+    )
+    for octroi in octrois:
+        coffre_octroi = get_coffre_by_id(octroi["coffre_id"])
+        _audit(
+            _username(current_user),
+            "octroi_cree",
+            coffre=coffre_octroi["slug"] if coffre_octroi else None,
+            resultat="ok",
+        )
+    return {**consommateur, "jeton": jeton, "octrois": octrois, "erreurs": erreurs}
+
+
+@router.delete("/api/coffres/consommateurs/{consommateur_id}")
+async def api_revoke_consommateur(
+    consommateur_id: str, current_user=Depends(require_admin)
+):
+    _exiger_actives()
+    try:
+        consommateur = revoquer_consommateur(consommateur_id)
+    except IntrouvableError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    _audit(
+        _username(current_user),
+        "consommateur_revoque",
+        consommateur=consommateur["nom"],
+        resultat="ok",
+    )
+    return consommateur
+
+
+# ---------------------------------------------------------------------------
+# Migration Phase 2 (admin seulement) : api_keys.json -> coffre d'instance.
+# L'import ne supprime rien ; la purge exige une confirmation explicite
+# et ne supprime que les noms listés. Aucune réponse ne contient jamais
+# une valeur, seulement des noms et des comptes.
+# Ces routes sont déclarées AVANT /api/coffres/{slug} pour ne pas être
+# capturées par le paramètre slug.
+# ---------------------------------------------------------------------------
+
+@router.get("/api/coffres/migration/api-keys")
+async def api_migration_apercu(current_user=Depends(require_admin)):
+    _exiger_actives()
+    return {"coffre": COFFRE_INTERNE_SLUG, "candidats": lister_candidats()}
+
+
+@router.post("/api/coffres/migration/api-keys/import")
+async def api_migration_import(current_user=Depends(require_admin)):
+    _exiger_actives()
+    try:
+        resultat = importer_api_keys(cree_par=_username(current_user))
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except KEKAbsenteError:
+        raise HTTPException(status_code=503, detail="kek_absente") from None
+    except CryptoIndisponibleError:
+        raise HTTPException(status_code=503, detail="crypto_indisponible") from None
+    for nom in resultat["migres"]:
+        _audit(
+            _username(current_user),
+            "migration_api_keys",
+            coffre=COFFRE_INTERNE_SLUG,
+            secret_ref=f"coffre:{COFFRE_INTERNE_SLUG}/{nom}",
+            resultat="ok",
+        )
+    return resultat
+
+
+@router.post("/api/coffres/migration/api-keys/purger")
+async def api_migration_purger(
+    body: dict = Body(...), current_user=Depends(require_admin)
+):
+    _exiger_actives()
+    if body.get("confirmer") is not True:
+        raise HTTPException(status_code=400, detail="confirmation_requise")
+    try:
+        resultat = purger_api_keys(
+            noms=body.get("noms") or [], confirmer=True
+        )
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    for nom in resultat["supprimes"]:
+        _audit(
+            _username(current_user),
+            "migration_api_keys_purge",
+            coffre=COFFRE_INTERNE_SLUG,
+            secret_ref=f"coffre:{COFFRE_INTERNE_SLUG}/{nom}",
+            resultat="ok",
+        )
+    return resultat
+
+
+# ---------------------------------------------------------------------------
+# Distribution (serveur-à-serveur, hors session utilisateur, hors LLM)
+# ---------------------------------------------------------------------------
+
+@router.post("/api/coffres/distribuer")
+async def api_distribuer(request: Request, body: dict = Body(...)):
+    _exiger_actives()
+    reference = (body.get("reference") or "").strip()
+    # Phase 3 (Spark) : le contexte peut arriver à plat
+    # (contexte_type / contexte_id) ou imbriqué (contexte: {type, id},
+    # forme envoyée par le client Spark). Les deux formes sont acceptées.
+    contexte_type = str(body.get("contexte_type") or "").strip()
+    contexte_id_raw = body.get("contexte_id")
+    contexte_id = "" if contexte_id_raw is None else str(contexte_id_raw).strip()
+    if not contexte_type or not contexte_id:
+        contexte = body.get("contexte")
+        if isinstance(contexte, dict):
+            contexte_type = contexte_type or str(contexte.get("type") or "").strip()
+            contexte_id_raw = contexte.get("id")
+            contexte_id = contexte_id or (
+                "" if contexte_id_raw is None else str(contexte_id_raw).strip()
+            )
+    if not contexte_type or not contexte_id:
+        raise HTTPException(status_code=400, detail="contexte_manquant")
+    if not reference.startswith("coffre:") or "/" not in reference[7:]:
+        raise HTTPException(status_code=400, detail="reference_invalide")
+    slug, nom = reference[7:].split("/", 1)
+    # Authentification consommateur : Bearer, hash + statut, jamais un JWT
+    # de session utilisateur.
+    auth = request.headers.get("Authorization", "")
+    jeton = auth[7:] if auth.startswith("Bearer ") else ""
+    consommateur = verifier_jeton_consommateur(jeton)
+    if consommateur is None:
+        _audit("consommateur", "distribution_refusee", secret_ref=reference,
+               resultat="consommateur_invalide", contexte_id=contexte_id)
+        raise HTTPException(status_code=401, detail="consommateur_invalide")
+    if consommateur["statut"] != "actif":
+        _audit("consommateur", "distribution_refusee", secret_ref=reference,
+               consommateur=consommateur["nom"],
+               resultat="consommateur_revoque", contexte_id=contexte_id)
+        raise HTTPException(status_code=403, detail="consommateur_revoque")
+    try:
+        coffre = get_coffre(slug)
+        secret = get_secret(coffre["id"], nom) if coffre else None
+    except ValidationError:
+        raise HTTPException(status_code=400, detail="reference_invalide") from None
+    if coffre is None or secret is None or coffre["statut"] != "actif":
+        # Anti-énumération : un secret inexistant se comporte comme un
+        # octroi absent, il ne révèle pas l'existence du coffre/secret.
+        _audit("consommateur", "distribution_refusee", secret_ref=reference,
+               consommateur=consommateur["nom"],
+               resultat="octroi_absent", contexte_id=contexte_id)
+        raise HTTPException(status_code=403, detail="octroi_absent")
+    statut, _octroi = statut_octroi_consommateur(
+        consommateur["id"], coffre["id"], secret["id"]
+    )
+    if statut != "ok":
+        code = {
+            "revoque": "octroi_revoque",
+            "expire": "octroi_expire",
+            "absent": "octroi_absent",
+        }[statut]
+        _audit("consommateur", "distribution_refusee", coffre=coffre["slug"],
+               secret_ref=reference, consommateur=consommateur["nom"],
+               resultat=code, contexte_id=contexte_id)
+        raise HTTPException(status_code=403, detail=code)
+    try:
+        valeur = distribuer_valeur(coffre, secret)
+    except SecretExpireError:
+        _audit("consommateur", "distribution_refusee", coffre=coffre["slug"],
+               secret_ref=reference, consommateur=consommateur["nom"],
+               resultat="secret_expire", contexte_id=contexte_id)
+        raise HTTPException(status_code=410, detail="secret_expire") from None
+    except KEKAbsenteError:
+        _audit("consommateur", "distribution_refusee", coffre=coffre["slug"],
+               secret_ref=reference, consommateur=consommateur["nom"],
+               resultat="kek_absente", contexte_id=contexte_id)
+        raise HTTPException(status_code=503, detail="kek_absente") from None
+    except CryptoIndisponibleError:
+        raise HTTPException(status_code=503, detail="crypto_indisponible") from None
+    toucher_utilisation(secret["id"])
+    _audit("consommateur", "distribution_ok", coffre=coffre["slug"],
+           secret_ref=reference, consommateur=consommateur["nom"],
+           resultat="ok", contexte_id=contexte_id)
+    return {
+        "reference": reference,
+        "valeur": valeur,
+        "version": secret["version_courante"],
+    }
+
+
+# ---------------------------------------------------------------------------
+# Un coffre, ses secrets, ses octrois, son journal
+# ---------------------------------------------------------------------------
+
+@router.get("/api/coffres/{slug}")
+async def api_get_coffre(slug: str, current_user=Depends(require_auth)):
+    _exiger_actives()
+    coffre = _coffre_or_404(slug)
+    _exiger_voir(current_user, coffre)
+    return _metadata_coffre(coffre)
+
+
+@router.get("/api/coffres/{slug}/secrets")
+async def api_list_secrets(slug: str, current_user=Depends(require_auth)):
+    _exiger_actives()
+    coffre = _coffre_or_404(slug)
+    _exiger_voir(current_user, coffre)
+    return _secrets_visibles(current_user, coffre)
+
+
+@router.post("/api/coffres/{slug}/secrets")
+async def api_create_secret(
+    slug: str, body: dict = Body(...), current_user=Depends(require_auth)
+):
+    _exiger_actives()
+    coffre = _coffre_or_404(slug)
+    _exiger_gerer(current_user, coffre)
+    try:
+        secret = create_secret(
+            coffre=coffre,
+            nom=body.get("nom", ""),
+            type_secret=body.get("type", "autre"),
+            valeur=body.get("valeur", ""),
+            service=body.get("service", ""),
+            expiration=body.get("expiration"),
+            note=body.get("note", ""),
+        )
+    except SecretExisteError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except KEKAbsenteError:
+        raise HTTPException(status_code=503, detail="kek_absente") from None
+    except CryptoIndisponibleError:
+        raise HTTPException(status_code=503, detail="crypto_indisponible") from None
+    _audit(
+        _username(current_user),
+        "secret_cree",
+        coffre=coffre["slug"],
+        secret_ref=f"coffre:{coffre['slug']}/{secret['nom']}",
+        resultat="ok",
+    )
+    return _metadata_secret(coffre, secret)
+
+
+@router.post("/api/coffres/{slug}/secrets/{nom}/rotation")
+async def api_rotate_secret(
+    slug: str, nom: str, body: dict = Body(...), current_user=Depends(require_auth)
+):
+    _exiger_actives()
+    coffre = _coffre_or_404(slug)
+    _exiger_gerer(current_user, coffre)
+    try:
+        secret = rotate_secret(coffre, nom, body.get("valeur", ""))
+    except IntrouvableError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except KEKAbsenteError:
+        raise HTTPException(status_code=503, detail="kek_absente") from None
+    except CryptoIndisponibleError:
+        raise HTTPException(status_code=503, detail="crypto_indisponible") from None
+    _audit(
+        _username(current_user),
+        "secret_rotation",
+        coffre=coffre["slug"],
+        secret_ref=f"coffre:{coffre['slug']}/{secret['nom']}",
+        resultat="ok",
+    )
+    return _metadata_secret(coffre, secret)
+
+
+@router.delete("/api/coffres/{slug}/secrets/{nom}")
+async def api_delete_secret(
+    slug: str, nom: str, current_user=Depends(require_auth)
+):
+    _exiger_actives()
+    coffre = _coffre_or_404(slug)
+    _exiger_gerer(current_user, coffre)
+    try:
+        secret, _octrois = delete_secret(coffre, nom)
+    except IntrouvableError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    _audit(
+        _username(current_user),
+        "secret_supprime",
+        coffre=coffre["slug"],
+        secret_ref=f"coffre:{coffre['slug']}/{secret['nom']}",
+        resultat="ok",
+    )
+    return {"status": "deleted", "nom": secret["nom"]}
+
+
+@router.get("/api/coffres/{slug}/octrois")
+async def api_list_octrois(slug: str, current_user=Depends(require_auth)):
+    _exiger_actives()
+    coffre = _coffre_or_404(slug)
+    _exiger_voir(current_user, coffre)
+    return list_octrois(coffre["id"])
+
+
+@router.post("/api/coffres/{slug}/octrois")
+async def api_create_octroi(
+    slug: str, body: dict = Body(...), current_user=Depends(require_auth)
+):
+    _exiger_actives()
+    coffre = _coffre_or_404(slug)
+    _exiger_gerer(current_user, coffre)
+    secret_id = None
+    if body.get("secret_nom"):
+        secret = _secret_or_404(coffre, body["secret_nom"])
+        secret_id = secret["id"]
+    try:
+        octroi = create_octroi(
+            coffre=coffre,
+            cible_type=body.get("cible_type", ""),
+            cible_id=body.get("cible_id", ""),
+            secret_id=secret_id,
+            cree_par=_username(current_user),
+            expiration=body.get("expiration"),
+        )
+    except IntrouvableError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except ValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    _audit(
+        _username(current_user),
+        "octroi_cree",
+        coffre=coffre["slug"],
+        secret_ref=(
+            f"coffre:{coffre['slug']}/{body.get('secret_nom', '*')}"
+        ),
+        resultat="ok",
+    )
+    return octroi
+
+
+@router.delete("/api/coffres/octrois/{octroi_id}")
+async def api_revoke_octroi(octroi_id: str, current_user=Depends(require_auth)):
+    _exiger_actives()
+    # Le gestionnaire du coffre concerné (ou l'admin d'instance) seul peut
+    # révoquer : on résout le coffre depuis l'octroi avant toute action.
+    octroi = get_octroi(octroi_id)
+    if octroi is None:
+        raise HTTPException(status_code=404, detail="Octroi introuvable")
+    coffre = get_coffre_by_id(octroi["coffre_id"])
+    if coffre is None:
+        raise HTTPException(status_code=404, detail="Coffre introuvable")
+    _exiger_gerer(current_user, coffre)
+    try:
+        octroi = revoquer_octroi(octroi_id)
+    except IntrouvableError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    _audit(
+        _username(current_user),
+        "octroi_revoque",
+        coffre=coffre["slug"],
+        resultat="ok",
+    )
+    return octroi
+
+
+@router.get("/api/coffres/{slug}/journal")
+async def api_journal(slug: str, current_user=Depends(require_auth)):
+    _exiger_actives()
+    coffre = _coffre_or_404(slug)
+    _exiger_voir(current_user, coffre)
+    # Défense en profondeur : même si une entrée contenait un jour un champ
+    # sensible, il ne sort jamais par cette route.
+    nettoyees = []
+    for entry in get_recent_entries(limit=100):
+        if entry.get("coffre") != slug:
+            continue
+        nettoyees.append(
+            {
+                k: v
+                for k, v in entry.items()
+                if k not in ("valeur", "ciphertext", "nonce", "jeton", "dek_chiffree")
+            }
+        )
+    return nettoyees
+
+
+# ---------------------------------------------------------------------------
+# Administration KEK / rotations (admin seulement)
+# ---------------------------------------------------------------------------
+
+@router.post("/api/coffres/admin/generer-kek")
+async def api_generer_kek(current_user=Depends(require_admin)):
+    _exiger_actives()
+    # La KEK générée n'est rendue qu'une fois, ici, et jamais stockée par
+    # ObsiGate : l'opérateur doit la sauvegarder hors dépôt immédiatement.
+    return {"kek": generate_kek_b64()}
+
+
+@router.post("/api/coffres/{slug}/rotation-dek")
+async def api_rotate_dek(slug: str, current_user=Depends(require_auth)):
+    _exiger_actives()
+    coffre = _coffre_or_404(slug)
+    _exiger_gerer(current_user, coffre)
+    try:
+        coffre = rotate_dek(slug)
+    except KEKAbsenteError:
+        raise HTTPException(status_code=503, detail="kek_absente") from None
+    except CryptoIndisponibleError:
+        raise HTTPException(status_code=503, detail="crypto_indisponible") from None
+    _audit(_username(current_user), "dek_rotation", coffre=coffre["slug"],
+           resultat="ok")
+    return _metadata_coffre(coffre)
+
+
+@router.post("/api/coffres/admin/rotation-kek")
+async def api_rotate_kek(
+    body: dict = Body(...), current_user=Depends(require_admin)
+):
+    _exiger_actives()
+    try:
+        count = rotate_kek(body.get("nouvelle_kek", ""))
+    except KEKAbsenteError:
+        raise HTTPException(status_code=503, detail="kek_absente") from None
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    _audit(_username(current_user), "kek_rotation", resultat="ok")
+    return {"status": "ok", "coffres_rechiffres": count}

backend/routers/files_write.py

@@ -15,6 +15,7 @@ from typing import Any
 
 from fastapi import APIRouter, Body, Depends, HTTPException, Query
 
+from backend import agent_journal
 from backend.audit import log_file_delete, log_file_save
 from backend.auth.middleware import check_vault_access, require_auth
 from backend.history import (
@@ -133,6 +134,9 @@ async def api_file_save(
     client_ip = current_user.get("_request_ip", "unknown")
     log_file_save(current_user["username"], vault_name, path, len(content), client_ip)
 
+    # Journal du service d'agents (#220) — émission « au mieux », API seulement.
+    agent_journal.emettre(agent_journal.TYPE_EDITE, vault_name, result["path"])
+
     return {"status": "ok", "vault": result["vault"], "path": result["path"], "size": result["size"]}
 
 
@@ -201,6 +205,7 @@ def api_file_xlsx_save(
         sum(len(str(v)) for v in cells.values()),
         current_user.get("_request_ip", "unknown"),
     )
+    agent_journal.emettre(agent_journal.TYPE_EDITE, vault_name, result["path"])
     return {
         "status": "ok", "vault": result["vault"], "path": result["path"],
         "size": result["size"], "revision": result.get("revision"),
@@ -250,6 +255,7 @@ def api_file_csv_save(
         sum(len(str(v)) for v in cells.values()),
         current_user.get("_request_ip", "unknown"),
     )
+    agent_journal.emettre(agent_journal.TYPE_EDITE, vault_name, result["path"])
     return {
         "status": "ok", "vault": result["vault"], "path": result["path"],
         "size": result["size"], "revision": result.get("revision"),
@@ -313,6 +319,7 @@ def api_file_xlsx_structure(
         len(actions),
         current_user.get("_request_ip", "unknown"),
     )
+    agent_journal.emettre(agent_journal.TYPE_EDITE, vault_name, result["path"])
     return {
         "status": "ok", "vault": result["vault"], "path": result["path"],
         "size": len(result["applied"]), "revision": result.get("revision"),
@@ -381,6 +388,7 @@ def api_file_xlsx_style(
         len(ops),
         current_user.get("_request_ip", "unknown"),
     )
+    agent_journal.emettre(agent_journal.TYPE_EDITE, vault_name, result["path"])
     return {
         "status": "ok", "vault": result["vault"], "path": result["path"],
         "size": len(result["applied"]), "revision": result.get("revision"),
@@ -405,6 +413,9 @@ async def api_file_delete(vault_name: str, path: str = Query(..., description="R
 
     result = service_delete_file(vault_name, path)
 
+    # Journal du service d'agents (#220) — émission « au mieux », API seulement.
+    agent_journal.emettre(agent_journal.TYPE_SUPPRIME, vault_name, result["path"])
+
     # Audit log
     client_ip = current_user.get("_request_ip", "unknown")
     log_file_delete(current_user["username"], vault_name, path, client_ip)
@@ -577,6 +588,9 @@ async def api_file_create(
 
     result = service_create_file(vault_name, body.path, body.content)
 
+    # Journal du service d'agents (#220) — émission « au mieux », API seulement.
+    agent_journal.emettre(agent_journal.TYPE_CREE, vault_name, result["path"])
+
     # Update index
     await update_single_file(vault_name, result["path"])
 
@@ -686,6 +700,9 @@ async def api_file_rename(
     old_path_str = result["old_path"]
     new_path_str = result["new_path"]
 
+    # Journal du service d'agents (#220) — la référence pointe sur le nouveau chemin.
+    agent_journal.emettre(agent_journal.TYPE_DEPLACE, vault_name, new_path_str)
+
     # Update index
     await handle_file_move(vault_name, old_path_str, new_path_str)
 
@@ -731,6 +748,11 @@ async def api_file_move(
     new_path_str = result["new_path"]
     item_type = result["item_type"]
 
+    # Journal du service d'agents (#220) — fichiers seulement (le catalogue
+    # est note.*) ; les déplacements de dossiers ne sont pas émis.
+    if item_type == "file":
+        agent_journal.emettre(agent_journal.TYPE_DEPLACE, vault_name, new_path_str)
+
     # Update index
     if item_type == "directory":
         from backend.indexer import reload_single_vault

backend/routers/realtime.py

@@ -49,7 +49,7 @@ async def api_events(current_user=Depends(require_auth)):
                 try:
                     msg = await asyncio.wait_for(queue.get(), timeout=30.0)
                     yield f"event: {msg['event']}\ndata: {msg['data']}\n\n"
-                except asyncio.TimeoutError:
+                except TimeoutError:
                     # Keepalive comment
                     yield ": keepalive\n\n"
                 except asyncio.CancelledError:

backend/scheduler.py

@@ -26,7 +26,7 @@ import logging
 import os
 import threading
 import uuid
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from typing import Any
 
@@ -118,7 +118,7 @@ def _validate_schedule(schedule: dict[str, Any]) -> dict[str, Any]:
     try:
         parsed = datetime.fromisoformat(at)
         if parsed.tzinfo is None:
-            parsed = parsed.replace(tzinfo=timezone.utc)
+            parsed = parsed.replace(tzinfo=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()}
@@ -138,7 +138,7 @@ def create_task(
     """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)
+    now = datetime.now(UTC)
     with _lock:
         tasks = _read_tasks()
         task = {
@@ -200,9 +200,9 @@ def delete_task(task_id: str) -> bool:
 
 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)
+    now = now or datetime.now(UTC)
     if now.tzinfo is None:
-        now = now.replace(tzinfo=timezone.utc)
+        now = now.replace(tzinfo=UTC)
     schedule = task.get("schedule", {})
     kind = schedule.get("kind")
     last_run_at = task.get("last_run_at")
@@ -211,7 +211,7 @@ def compute_next_run(task: dict[str, Any], now: datetime | None = None) -> datet
         try:
             last = datetime.fromisoformat(str(last_run_at))
             if last.tzinfo is None:
-                last = last.replace(tzinfo=timezone.utc)
+                last = last.replace(tzinfo=UTC)
         except ValueError:
             last = None
     if kind == "interval_hours":
@@ -233,11 +233,11 @@ def compute_next_run(task: dict[str, Any], now: datetime | None = None) -> datet
         try:
             at = datetime.fromisoformat(str(schedule.get("at")))
             if at.tzinfo is None:
-                at = at.replace(tzinfo=timezone.utc)
+                at = at.replace(tzinfo=UTC)
         except ValueError:
             return now
         if task.get("last_run_at"):
-            return datetime.max.replace(tzinfo=timezone.utc)  # déjà exécutée
+            return datetime.max.replace(tzinfo=UTC)  # déjà exécutée
         return at
     return now + timedelta(hours=24)
 
@@ -278,7 +278,7 @@ def run_task(task_id: str, *, manual: bool = False) -> dict[str, Any]:
             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_run_at"] = datetime.now(UTC).isoformat()
             task["last_status"] = "ok"
             task["last_error"] = None
             task["run_count"] = int(task.get("run_count", 0)) + 1
@@ -292,7 +292,7 @@ def run_task(task_id: str, *, manual: bool = False) -> dict[str, Any]:
                 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_run_at"] = datetime.now(UTC).isoformat()
             task["last_status"] = "error"
             task["last_error"] = str(e)
             task["run_count"] = int(task.get("run_count", 0)) + 1
@@ -315,7 +315,7 @@ def run_task(task_id: str, *, manual: bool = False) -> dict[str, Any]:
 
 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)
+    now = now or datetime.now(UTC)
     outcomes: list[dict[str, Any]] = []
     for task in _read_tasks():
         if not task.get("enabled", True):
@@ -323,7 +323,7 @@ def tick(now: datetime | None = None) -> list[dict[str, Any]]:
         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)
+                next_run = next_run.replace(tzinfo=UTC)
         except ValueError:
             next_run = compute_next_run(task, now)
         if next_run <= now:

backend/services/backups.py

@@ -14,7 +14,7 @@ import logging
 import os
 import shutil
 import time
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -145,7 +145,7 @@ def list_backup_files(vault_name: str, relative_path: str) -> list[dict[str, Any
             except (ValueError, TypeError):
                 continue
             try:
-                dt = datetime.fromtimestamp(ts, tz=timezone.utc).isoformat()
+                dt = datetime.fromtimestamp(ts, tz=UTC).isoformat()
             except (OSError, OverflowError, ValueError) as ts_err:
                 logger.warning(f"Skipping backup with invalid timestamp {ts}: {ts_err}")
                 continue
@@ -219,7 +219,7 @@ def diff_backup(
                 status=500,
                 details={"vault": vault_name, "path": path, "version": ts},
             ) from e
-        dt = datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+        dt = datetime.fromtimestamp(ts, tz=UTC).strftime("%Y-%m-%d %H:%M:%S UTC")
         return content, f"{path}@{dt}"
 
     try:

backend/services/recent.py

@@ -117,7 +117,7 @@ def list_recent(
     for v_name, f in recent:
         iso_modified = f.get("modified", "")
         try:
-            mtime_dt = datetime.fromisoformat(iso_modified.replace("Z", "+00:00"))
+            mtime_dt = datetime.fromisoformat(iso_modified)
             mtime_val = mtime_dt.timestamp()
         except Exception:
             mtime_val = time.time()

backend/services/vaults.py

@@ -7,6 +7,7 @@ Single source of truth consumed by both the REST routes (``/api/vaults``,
 
 from __future__ import annotations
 
+from datetime import UTC
 from pathlib import Path
 from typing import Any
 
@@ -49,7 +50,7 @@ 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 datetime import datetime
 
     from backend.indexer import SUPPORTED_EXTENSIONS
     from backend.vault_settings import get_vault_setting
@@ -98,7 +99,7 @@ def browse_directory(vault_name: str, path: str = "") -> dict[str, Any]:
                     "type": "file",
                     "size": stat.st_size,
                     "modified": stat.st_mtime,
-                    "modified_iso": datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat(),
+                    "modified_iso": datetime.fromtimestamp(stat.st_mtime, tz=UTC).isoformat(),
                     "extension": entry.suffix.lower(),
                 })
     except PermissionError:
@@ -156,7 +157,7 @@ def list_all_files(
         ServiceError: ``not_found`` (404) if the directory does not exist,
             ``permission_denied`` (403) if it cannot be read.
     """
-    from datetime import datetime, timezone
+    from datetime import datetime
 
     from backend.indexer import IGNORED_DIRS
 
@@ -215,7 +216,7 @@ def list_all_files(
                 "vault": vault_name,
                 "size": stat.st_size,
                 "modified": stat.st_mtime,
-                "modified_iso": datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat(),
+                "modified_iso": datetime.fromtimestamp(stat.st_mtime, tz=UTC).isoformat(),
                 "extension": ext.lstrip(".") if ext else "",
                 "tags": _indexed_tags(vault_name, rel_path),
             }

backend/share.py

@@ -11,7 +11,7 @@ import json
 import logging
 import secrets
 import threading
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from pathlib import Path
 
 logger = logging.getLogger("obsigate.share")
@@ -58,7 +58,7 @@ def create_share(
 
         expires_at = None
         if expires_in_hours:
-            expires_at = (datetime.now(timezone.utc) + timedelta(hours=expires_in_hours)).isoformat()
+            expires_at = (datetime.now(UTC) + timedelta(hours=expires_in_hours)).isoformat()
 
         share = {
             "id": token,
@@ -66,7 +66,7 @@ def create_share(
             "vault": vault,
             "path": path,
             "created_by": created_by,
-            "created_at": datetime.now(timezone.utc).isoformat(),
+            "created_at": datetime.now(UTC).isoformat(),
             "expires_at": expires_at,
             "access_count": 0,
             "last_accessed": None,
@@ -86,7 +86,7 @@ def get_share_by_token(token: str) -> dict | None:
         return None
     if share.get("expires_at"):
         expires = datetime.fromisoformat(share["expires_at"])
-        if datetime.now(timezone.utc) > expires:
+        if datetime.now(UTC) > expires:
             return None
     return share
 
@@ -98,7 +98,7 @@ def record_access(token: str):
         share = data["shares"].get(token)
         if share:
             share["access_count"] = share.get("access_count", 0) + 1
-            share["last_accessed"] = datetime.now(timezone.utc).isoformat()
+            share["last_accessed"] = datetime.now(UTC).isoformat()
             _write(data)
 
 

backend/tools/audit.py

@@ -7,7 +7,7 @@ Reuses the application audit log (``data/audit.log``, JSON lines) and adds an
 
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import Any
 
 from backend.audit import _write_entry
@@ -41,7 +41,7 @@ def log_tool_call(
 ) -> None:
     """Append an ``ai_tool_call`` entry to the audit log."""
     _write_entry({
-        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "timestamp": datetime.now(UTC).isoformat(),
         "action": "ai_tool_call",
         "username": username,
         "ip": ip or "unknown",

backend/tools/service.py

@@ -14,6 +14,7 @@ import logging
 import os
 from typing import Any
 
+from backend import agent_journal
 from backend.indexer import get_backlinks as _get_backlinks
 from backend.indexer import get_vault_names
 from backend.services.backups import diff_backup as _diff_backup
@@ -58,7 +59,7 @@ from backend.services.search import advanced_search_vaults, search_vaults
 from backend.services.search import list_tags as _list_tags
 from backend.services.search import search_paths as _search_paths
 from backend.services.vaults import browse_directory, list_accessible_vaults, list_all_files
-from backend.tools.context import ToolContext, ToolRisk
+from backend.tools.context import ToolContext, ToolMode, ToolRisk
 from backend.tools.registry import tool
 from backend.tools.schemas import (
     AppendToFileInput,
@@ -360,6 +361,12 @@ def list_recent(ctx: ToolContext, params: ListRecentInput) -> dict[str, Any]:
 # ── D. Mutations ───────────────────────────────────────────────────────────
 
 
+def _acteur_journal(ctx: ToolContext) -> str:
+    """Acteur journal (#220) : ``agent:mcp`` quand l'appel vient du
+    serveur MCP d'ObsiGate, ``user`` pour l'assistant intégré."""
+    return agent_journal.ACTEUR_MCP if ctx.mode == ToolMode.MCP else agent_journal.ACTEUR_USER
+
+
 @tool(
     name="create_file",
     description=(
@@ -374,7 +381,12 @@ def list_recent(ctx: ToolContext, params: ListRecentInput) -> dict[str, Any]:
 )
 def create_file(ctx: ToolContext, params: CreateFileInput) -> dict[str, Any]:
     """Create a vault file (fails if it already exists)."""
-    return _create_file(params.vault, params.path, params.content)
+    result = _create_file(params.vault, params.path, params.content)
+    agent_journal.emettre(
+        agent_journal.TYPE_CREE, params.vault, result.get("path", params.path),
+        actor=_acteur_journal(ctx),
+    )
+    return result
 
 
 @tool(
@@ -402,7 +414,12 @@ def create_directory(ctx: ToolContext, params: CreateDirectoryInput) -> dict[str
 )
 def edit_file(ctx: ToolContext, params: EditFileInput) -> dict[str, Any]:
     """Replace a vault file's content."""
-    return _edit_file(params.vault, params.path, params.content)
+    result = _edit_file(params.vault, params.path, params.content)
+    agent_journal.emettre(
+        agent_journal.TYPE_EDITE, params.vault, result.get("path", params.path),
+        actor=_acteur_journal(ctx),
+    )
+    return result
 
 
 @tool(
@@ -414,7 +431,12 @@ def edit_file(ctx: ToolContext, params: EditFileInput) -> dict[str, Any]:
 )
 def append_to_file(ctx: ToolContext, params: AppendToFileInput) -> dict[str, Any]:
     """Append content to a vault file."""
-    return _append_to_file(params.vault, params.path, params.content)
+    result = _append_to_file(params.vault, params.path, params.content)
+    chemin = result.get("path", params.path) if isinstance(result, dict) else params.path
+    agent_journal.emettre(
+        agent_journal.TYPE_EDITE, params.vault, chemin, actor=_acteur_journal(ctx),
+    )
+    return result
 
 
 @tool(
@@ -426,7 +448,12 @@ def append_to_file(ctx: ToolContext, params: AppendToFileInput) -> dict[str, Any
 )
 def rename_file(ctx: ToolContext, params: RenameFileInput) -> dict[str, Any]:
     """Rename a vault file."""
-    return _rename_file(params.vault, params.path, params.new_name)
+    result = _rename_file(params.vault, params.path, params.new_name)
+    agent_journal.emettre(
+        agent_journal.TYPE_DEPLACE, params.vault,
+        result.get("new_path", params.path), actor=_acteur_journal(ctx),
+    )
+    return result
 
 
 @tool(
@@ -450,7 +477,14 @@ def rename_directory(ctx: ToolContext, params: RenameDirectoryInput) -> dict[str
 )
 def move_path(ctx: ToolContext, params: MovePathInput) -> dict[str, Any]:
     """Move a vault file or directory."""
-    return _move_path(params.vault, params.source_path, params.destination_dir)
+    result = _move_path(params.vault, params.source_path, params.destination_dir)
+    # Journal (#220) : fichiers seulement — les dossiers sont hors catalogue.
+    if result.get("item_type") == "file":
+        agent_journal.emettre(
+            agent_journal.TYPE_DEPLACE, params.vault,
+            result.get("new_path", params.source_path), actor=_acteur_journal(ctx),
+        )
+    return result
 
 
 @tool(
@@ -497,7 +531,12 @@ def replace_in_files(ctx: ToolContext, params: ReplaceInFilesInput) -> dict[str,
 )
 def delete_file(ctx: ToolContext, params: DeleteFileInput) -> dict[str, Any]:
     """Delete a vault file."""
-    return _delete_file(params.vault, params.path)
+    result = _delete_file(params.vault, params.path)
+    chemin = result.get("path", params.path) if isinstance(result, dict) else params.path
+    agent_journal.emettre(
+        agent_journal.TYPE_SUPPRIME, params.vault, chemin, actor=_acteur_journal(ctx),
+    )
+    return result
 
 
 @tool(

backend/watcher.py

@@ -244,7 +244,7 @@ class VaultWatcher:
                 key = event.get('dest') or event['src']
                 pending[key] = event
 
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 if pending:
                     events_to_process = list(pending.values())
                     pending.clear()

backend/webhooks.py

@@ -31,7 +31,7 @@ import os
 import socket
 import threading
 import uuid
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from urllib.parse import urlparse
 
@@ -275,7 +275,7 @@ def create_webhook(
             "url": url,
             "events": [e for e in events if e in VALID_EVENTS],
             "enabled": True,
-            "created_at": datetime.now(timezone.utc).isoformat(),
+            "created_at": datetime.now(UTC).isoformat(),
             "last_fired_at": None,
             # #198 : filtres optionnels (None = pas de filtre, reçoit tout).
             "vault": _normalize_vault_filter(vault),
@@ -344,7 +344,7 @@ async def dispatch_webhooks(event_type: str, data: dict):
 
     payload = {
         "event": event_type,
-        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "timestamp": datetime.now(UTC).isoformat(),
         "data": data,
     }
     body = json.dumps(payload, default=str)
@@ -369,7 +369,7 @@ async def dispatch_webhooks(event_type: str, data: dict):
                     logger.debug(f"Webhook '{wh['name']}' OK ({resp.status})")
                 else:
                     logger.warning(f"Webhook '{wh['name']}' failed ({resp.status})")
-            update_webhook(wh["id"], {"last_fired_at": datetime.now(timezone.utc).isoformat()})
+            update_webhook(wh["id"], {"last_fired_at": datetime.now(UTC).isoformat()})
         except Exception as e:
             logger.warning(f"Webhook '{wh['name']}' error: {e}")
 

desktop/Cargo.lock

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

desktop/Cargo.toml

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

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.73.1",
+  "version": "2.81.0",
   "identifier": "com.obsigate.desktop",
   "build": {
     "frontendDist": "../frontend",

docker-compose.yml

@@ -51,8 +51,6 @@ services:
       - VAULT_4_PATH=/vaults/Obsidian_WORKOUT
       - VAULT_5_NAME=Sessions
       - 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

docs/COFFRE-contrat-distribution.md

@@ -0,0 +1,156 @@
+# Coffre Secrets ObsiGate — Contrat de distribution (Phases 3 et 4)
+
+Référence du contrat pour les clients serveur-à-serveur : Spark
+(issue #21), TikTak, Flowdeck, Kanbante (issue #22). Ce document ne
+duplique aucune logique de chiffrement : le chiffrement reste
+entièrement côté ObsiGate (enveloppe KEK → DEK → secret, AES-256-GCM).
+
+## 1. Endpoint
+
+```
+POST /api/coffres/distribuer
+Authorization: Bearer <jeton-consommateur>
+Content-Type: application/json
+```
+
+Corps (forme à plat, Phase 1b) :
+
+```json
+{
+  "reference": "coffre:<slug>/<nom>",
+  "contexte_type": "mission",
+  "contexte_id": "mission-123"
+}
+```
+
+Forme imbriquée acceptée depuis la Phase 2 (client Spark) :
+
+```json
+{
+  "reference": "coffre:<slug>/<nom>",
+  "contexte": { "type": "mission", "id": "mission-123" }
+}
+```
+
+La forme à plat reste supportée ; si les deux formes sont présentes,
+la forme à plat est prioritaire. Le contexte est **obligatoire** :
+sans `contexte_type`/`contexte_id` (ou sans `contexte.type`/`id`),
+la requête est refusée avant toute authentification utile.
+
+Réponse en succès (200) :
+
+```json
+{ "reference": "coffre:<slug>/<nom>", "valeur": "<valeur>", "version": 1 }
+```
+
+La valeur n'existe qu'en mémoire chez l'appelant : elle ne doit
+jamais être écrite dans un fichier, un journal, un prompt, une étape
+d'activité ou un livrable. Le patron imposé à chaque app est
+**distribuer → utiliser → oublier** ; à la fin de l'opération
+(fin de mission, fin de synchronisation), l'environnement qui la
+contenait est détruit et rien ne persiste.
+
+Prérequis côté ObsiGate : coffres activés
+(`OBSIGATE_SECRETS_ENABLED`, sinon 503 `secrets_desactives`) et KEK
+configurée (sinon 503 `kek_absente`).
+
+## 2. Authentification : consommateur nommé, jeton propre
+
+- Un consommateur est créé par un admin :
+  `POST /api/coffres/consommateurs` (`{"nom": "spark"}`), ou en une
+  seule opération avec ses octrois :
+  `POST /api/coffres/consommateurs/avec-octrois`
+  (`{"nom": "tiktak", "octrois": [{"coffre_slug": "...",
+  "secret_nom": "..."}]}` ; `secret_nom` absent = tout le coffre).
+- Le jeton (`csk_…`) n'est rendu **qu'une seule fois**, à la création.
+  Il n'est jamais stocké en clair (seul son hash SHA-256 est persisté)
+  et jamais relisté (`GET /api/coffres/consommateurs` ne renvoie que
+  `id`, `nom`, `jeton_prefixe`, `statut`, `cree_par`, `cree_le`).
+- L'`id` du consommateur sert de `jti` révocable :
+  `DELETE /api/coffres/consommateurs/{id}` révoque immédiatement
+  toutes ses distributions, sans toucher aux autres consommateurs.
+- Ce jeton est **distinct** du jeton MCP de notes et de la session
+  SSO : une session utilisateur, même admin, ne distribue jamais
+  (401 `consommateur_invalide`). Il n'existe pas d'endpoint de
+  distribution par session (voir §6).
+- Ajouter une app = enregistrer un consommateur + créer des octrois,
+  **sans modification du coffre** et sans toucher à ses secrets.
+
+## 3. Cas Spark (issue #21)
+
+- Consommateur nommé `spark` (convention, non imposée par le code :
+  l'autorisation porte sur le jeton, pas sur le nom).
+- Contexte : `contexte_type = "mission"`, `contexte_id` = identifiant
+  de la mission. La forme imbriquée
+  `contexte: {type: "mission", id: <id-mission>}` est acceptée.
+- Flux côté agent-commun (hors ObsiGate, rappelé ici pour la
+  correspondance des erreurs) : le LLM ne voit que la référence
+  `coffre:<slug>/<nom>` et un accès oui/non, jamais la valeur. Sans
+  octroi, la mission passe en `acces_requis` en nommant l'accès
+  manquant. Avec octroi et mission approuvée (enveloppe budgétaire),
+  le service Spark appelle `/distribuer` et injecte la valeur en
+  variable d'environnement de l'exécuteur, jamais dans le prompt.
+  Fin de mission = environnement détruit.
+- Révocation dans ObsiGate (consommateur ou octroi) : la mission
+  suivante repasse en `acces_requis`. Limite assumée : une mission
+  déjà démarrée conserve son environnement jusqu'à sa fin.
+
+## 4. Erreurs (codes `detail`, stables depuis la Phase 1b)
+
+| HTTP | `detail` | Sens | Correspondance Spark |
+| --- | --- | --- | --- |
+| 400 | `contexte_manquant` | Contexte absent ou vide. | Erreur d'appel, pas un état d'accès. |
+| 400 | `reference_invalide` | Référence mal formée ou nom invalide. | Erreur d'appel. |
+| 401 | `consommateur_invalide` | Jeton inconnu (ni MCP, ni session). | Configurer le jeton consommateur. |
+| 403 | `consommateur_revoque` | Consommateur révoqué. | `acces_requis` (ré-accorder). |
+| 403 | `octroi_absent` | Aucun octroi (ou secret/coffre inexistant — anti-énumération, volontairement indistinct). | `acces_requis` (demander l'octroi). |
+| 403 | `octroi_revoque` | Octroi révoqué. | `acces_requis` (ré-accorder). |
+| 403 | `octroi_expire` | Octroi expiré (défaut 90 jours à la création). | `acces_requis` (renouveler). |
+| 410 | `secret_expire` | Secret expiré, même avec un octroi actif. | Rotation du secret côté ObsiGate. |
+| 503 | `secrets_desactives` / `kek_absente` / `crypto_indisponible` | Coffre désactivé, KEK absente, ou bibliothèque absente. | Panne ObsiGate, pas un refus d'accès. |
+
+Un octroi coffre-wide (`secret_id` nul) couvre tous les secrets du
+coffre ; un octroi par secret ne couvre que ce secret. Un octroi
+révoqué ne doit jamais être masqué par l'absence d'un autre octroi
+(priorité : ok > révoqué > expiré > absent).
+
+## 5. Audit
+
+Chaque distribution est auditée (`distribution_ok` ou
+`distribution_refusee`, avec référence, consommateur, contexte et
+code de résultat). **Aucune entrée d'audit ne contient jamais une
+valeur, un texte chiffré, un nonce ou un jeton.** La route journal
+(`GET /api/coffres/{slug}/journal`) filtre en défense en profondeur
+ces champs même s'ils apparaissaient un jour dans une entrée.
+La copie manuelle à usage unique (admin, via consommateur temporaire
+créé puis révoqué immédiatement, valeur copiée au presse-papiers
+sans affichage) est auditée comme une distribution de contexte
+`copie_manuelle`, avec la trace distincte de ce contexte.
+
+## 6. Limites et restes à faire (Phases 3–4, côté ObsiGate)
+
+- **Isolation workspace Flowdeck** : le type de cible `workspace`
+  existe pour les octrois, mais `/distribuer` n'autorise aujourd'hui
+  que les octrois de type `consommateur`. L'isolation « un workspace
+  ne peut pas utiliser l'octroi d'un autre » repose donc, pour
+  l'instant, sur le serveur Flowdeck lui-même (il ne demande que les
+  références de son workspace, avec son propre jeton consommateur).
+  Un contrôle serveur strict (contexte workspace vérifié côté
+  ObsiGate contre un octroi `workspace`) reste à spécifier et à
+  implémenter si Bruno l'exige — il changerait la sémantique
+  d'autorisation de `/distribuer` et doit être coordonné avec les
+  apps clientes avant tout changement.
+- **Distribution par session** : non implémentée, volontairement.
+  Elle contredirait la règle Phase 1b (distribution réservée aux
+  consommateurs) et exigerait une ré-authentification qui n'existe
+  pas encore dans ObsiGate. La copie manuelle reste le patron
+  supporté (consommateur temporaire, admin seulement).
+- **Clients par app** (TikTak, Flowdeck, Kanbante, agent-commun) :
+  à implémenter dans chaque dépôt, en branche + PR, jamais mergés
+  sans go. Patron commun : le serveur distribue, utilise, oublie ;
+  aucune valeur en cache ; si ObsiGate est indisponible, l'opération
+  échoue proprement, sans repli sur une ancienne valeur.
+- **Lecteurs internes ObsiGate** (`ai.py`, `tools/secrets.py`) :
+  toujours branchés sur `api_keys.json` en clair (voir le document
+  de sauvegarde/restauration, §5) ; leur branchement sur le coffre
+  est un travail séparé de la présente Phase 2.

docs/COFFRE-deploiement-mise-en-service.md

@@ -0,0 +1,390 @@
+# Coffre Secrets ObsiGate — Déploiement et mise en service (Phase 5, issue #23)
+
+Document de déploiement du coffre Secrets, issu des Phases 1a/1b
+(issues #17, #18), 2 (issue #20), 3 (issue #21, côté agent-commun)
+et 4 (issue #22, côté TikTak, Flowdeck, Kanbante).
+
+**Règles de gouvernance (non négociables) :** travail en branche +
+pull request, jamais sur `main`, jamais de merge, de release, de tag,
+de fermeture d'issue ni de changement de label sans le go explicite
+de Bruno. Ce document ne décrit aucune valeur réelle : les exemples
+utilisent des valeurs fictives (`TEST-VALUE-XXXX`) et aucune KEK
+n'est jamais écrite ici, ni dans un journal, ni dans une note, ni
+dans le dépôt.
+
+Documents compagnons (même branche de référence, Phase 2) :
+
+- `docs/COFFRE-contrat-distribution.md` — contrat
+  `POST /api/coffres/distribuer` pour Spark, TikTak, Flowdeck,
+  Kanbante (authentification par consommateur, contextes, codes
+  d'erreur stables).
+- `docs/COFFRE-sauvegarde-restauration.md` — sauvegarde
+  (`data/coffres.json` + `data/coffres_valeurs.json`, 0600) et
+  restauration sur instance vierge, perte de KEK.
+
+## 1. Prérequis et variables d'environnement
+
+### 1.1 Dépendance
+
+- `cryptography>=44.0` dans `backend/requirements.txt` (dépendance
+  Phase 1a). Sans elle, les opérations de chiffrement répondent
+  503 `crypto_indisponible` : c'est un mode dégradé explicite, pas
+  un repli en clair. Il n'y a jamais de stockage ni de distribution
+  de valeur en clair.
+- Chiffrement par enveloppe AES-256-GCM : KEK (256 bits) → DEK par
+  coffre → valeur du secret. Un tag GCM invalide refuse le
+  déchiffrement (testé : `tests/test_coffre_secrets.py`,
+  `test_tag_invalide_refuse`).
+
+### 1.2 Variables
+
+| Variable | Rôle | Défaut |
+| --- | --- | --- |
+| `OBSIGATE_SECRETS_ENABLED` | Activation du coffre. Tant qu'elle n'est pas à `true`, **toutes** les routes coffre répondent 503 `secrets_desactives`. | désactivé |
+| `OBSIGATE_KEK` | KEK, base64 de 32 octets (ou hex 64 caractères). **Prioritaire** sur le fichier si les deux sont définis. | absente |
+| `OBSIGATE_KEK_FILE` | Chemin d'un fichier contenant la KEK, **en 0600, hors dépôt et hors arborescence des vaults**. Un fichier trop permissif (droits groupe/autre) est refusé explicitement (`KEKInvalideError`). | absent |
+| `OBSIGATE_DATA_DIR` | Répertoire des données (`data/` par défaut) : `coffres.json`, `coffres_valeurs.json` et l'historique `api_keys.json`. | `data` |
+
+La KEK est générée une seule fois (admin, coffres activés) via
+`POST /api/coffres/admin/generer-kek` ; ObsiGate **ne la stocke
+jamais**. Au moment de sa génération : la copier immédiatement
+dans un gestionnaire de mots de passe ou sur un support hors ligne,
+hors du serveur ; vérifier la copie en la relisant depuis le
+gestionnaire, jamais depuis l'écran qui ne l'affichera plus.
+Ne jamais la coller dans le dépôt, dans une note ObsiGate, dans le
+même dossier que `data/`, ni dans un journal.
+
+**Recommandation de déploiement : préférer `OBSIGATE_KEK_FILE`**
+(fichier 0600) à `OBSIGATE_KEK` en variable d'environnement, pour
+éviter que la KEK apparaisse dans un historique de processus ou un
+dump d'environnement. Si les deux sont définis, `OBSIGATE_KEK`
+l'emporte — vérifier qu'aucune ancienne valeur ne traîne dans
+l'environnement au moment de basculer sur le fichier.
+
+### 1.3 Ce que la sauvegarde contient (rappel)
+
+Deux fichiers seulement portent le coffre, tous deux en 0600 :
+
+- `data/coffres.json` : métadonnées des coffres, DEK chiffrées,
+  consommateurs (hashes SHA-256 des jetons seulement, jamais le
+  jeton en clair), octrois, métadonnées des secrets ;
+- `data/coffres_valeurs.json` : versions chiffrées des secrets.
+
+Copiés seuls, ils ne donnent accès à aucune valeur. La KEK ne fait
+pas partie de la sauvegarde : elle est copiée à part, hors serveur.
+Sauvegarder les deux fichiers et la KEK au même endroit annulerait
+la protection du chiffrement.
+
+## 2. Décisions ouvertes de la spec — tranchées par défaut
+
+Les décisions ouvertes de la spec (§15, §16), rappelées dans
+l'issue #23, sont confirmées comme tranchées selon les défauts
+recommandés, en attendant une décision contraire explicite de
+Bruno. Aucune d'elles ne nécessite de changement de code pour la
+mise en service décrite ci-dessous :
+
+| Décision | Choix confirmé par défaut |
+| --- | --- |
+| Glyphe du nœud Secrets | Cadenas U+1F510 (🔐), distinct de la maison du Home et du diamant du Partage. Le nœud est un nœud virtuel sous le Home de l'utilisateur courant seulement (voir §4). |
+| Stockage de la KEK | Par fichier 0600, hors dépôt (`OBSIGATE_KEK_FILE`) ; `OBSIGATE_KEK` reste supportée comme solution de secours. |
+| Expiration des octrois | 90 jours par défaut à la création, renouvelable (création d'un nouvel octroi). Un octroi expiré refuse la distribution (`octroi_expire`, 403) ; un octroi révoqué refuse dès l'appel suivant (`octroi_revoque`, 403). |
+| Copie manuelle | Presse-papiers seul, sans affichage de la valeur. Patron supporté : consommateur temporaire créé par un admin puis révoqué immédiatement, auditée comme distribution de contexte `copie_manuelle`. **Aucun endpoint dédié de copie par session n'est ajouté** : il contredirait la règle « distribution réservée aux consommateurs » et exigerait une ré-authentification qui n'existe pas encore — décision volontaire, à trancher avec Bruno avant toute implémentation. |
+| Coffres partagés | Phase 2 ultérieure. En mise en service : coffres personnels d'abord, plus le coffre d'instance « ObsiGate interne » (slug `obsigate-interne`, admin seulement) issu de l'import. |
+
+## 3. Mise en service pas à pas
+
+**Ordre impératif.** Chaque étape est validée avant de passer à la
+suivante. En particulier : **les lecteurs internes sont branchés
+sur le coffre AVANT toute purge du clair** (étape 4 avant étape 7),
+et la purge n'a lieu qu'après validation complète (étape 6).
+
+### Étape 0 — Préparer, coffre encore désactivé
+
+1. Déployer le code coffre (Phases 1–2) sur l'instance, **sans
+   activer le flag** : `OBSIGATE_SECRETS_ENABLED` reste absent ou à
+   `false`. Vérifier que toutes les routes `/api/coffres/*`
+   répondent 503.
+2. Sauvegarder l'état actuel : copie de `data/` (dont
+   `api_keys.json`) et de la configuration, hors serveur.
+3. Générer la KEK (voir §1.2) et la copier hors serveur. Ne pas
+   encore la référencer dans la configuration de l'instance si
+   l'étape 1 n'est pas terminée — une KEK présente sans flag actif
+   ne distribue rien, mais sa présence doit rester traçable.
+
+### Étape 1 — Créer les consommateurs et les octrois
+
+Avant d'activer le flag, préparer les consommateurs nommés, un par
+application cliente (convention de nommage, non imposée par le
+code — l'autorisation porte sur le jeton, pas sur le nom) :
+
+| Consommateur | Usage | Contexte de distribution |
+| --- | --- | --- |
+| `spark` | Agent Spark (agent-commun, Phase 3) | `contexte_type = "mission"`, `contexte_id` = id de mission (forme imbriquée `contexte: {type, id}` acceptée) |
+| `tiktak` | Synchronisation TikTak (Phase 4) | `contexte_type = "tiktak_sync"`, `contexte_id` = id utilisateur |
+| `flowdeck` | Connecteurs Flowdeck (Phase 4) | Contexte workspace, vérifié côté Flowdeck (voir §5) |
+| `kanbante` | Webhooks Kanbante (Phase 4) | Contexte webhook, distribution à chaque appel puis oubli |
+
+Création en une seule opération avec les octrois :
+
+```
+POST /api/coffres/consommateurs/avec-octrois
+{"nom": "tiktak", "octrois": [{"coffre_slug": "...", "secret_nom": "..."}]}
+```
+
+- `secret_nom` absent = tout le coffre (octroi coffre-wide).
+- Le jeton (`csk_…`) n'est rendu **qu'une seule fois**, à la
+  création. Le noter immédiatement dans le coffre de
+  configuration de l'application cliente concernée, jamais dans
+  une note ObsiGate ni dans le dépôt. Il n'est jamais relisté :
+  `GET /api/coffres/consommateurs` ne renvoie que `id`, `nom`,
+  `jeton_prefixe`, `statut`, `cree_par`, `cree_le`.
+- La révocation est immédiate : `DELETE
+  /api/coffres/consommateurs/{id}` révoque toutes les
+  distributions de ce consommateur, sans toucher aux autres.
+  Une mission Spark déjà démarrée conserve son environnement
+  jusqu'à sa fin ; la mission suivante repasse en `acces_requis`.
+
+À ce stade, les consommateurs et octrois peuvent être créés alors
+que les secrets n'existent pas encore : les octrois pointent vers
+des coffres/secrets à créer aux étapes suivantes. Vérifier la
+liste des consommateurs et des octrois avant d'activer le flag.
+
+### Étape 2 — Activer le flag
+
+1. Définir `OBSIGATE_KEK_FILE` (fichier 0600, hors dépôt) puis
+   `OBSIGATE_SECRETS_ENABLED=true`.
+2. Redémarrer l'instance.
+3. Vérifier : la vue Secrets s'ouvre ; `GET /api/coffres` répond
+   200 (liste vide ou coffres existants) ; sans KEK valide, les
+   routes répondent 503 `kek_absente` — dans ce cas, corriger la
+   KEK avant toute création de secret.
+
+### Étape 3 — Importer l'existant (admin seulement)
+
+Bouton « Importer l'existant » de la vue Secrets (admin
+seulement), en deux temps séparés :
+
+1. **Aperçu** : `GET /api/coffres/migration/api-keys` liste les
+   candidats de `data/api_keys.json` (clés IA et clés d'outils).
+2. **Import** : `POST /api/coffres/migration/api-keys/import`
+   copie les entrées avec valeur vers le coffre d'instance
+   « ObsiGate interne » (slug `obsigate-interne`), chiffrées.
+   Un secret déjà présent n'est **jamais écrasé**.
+   `api_keys.json` n'est **pas modifié** par l'import.
+
+Vérifier après import : les secrets importés apparaissent dans la
+vue Secrets avec `has_value = true`, et aucune valeur n'est
+visible (métadonnées seules : nom, type, version, dates, octrois
+actifs — jamais de valeur, jamais de texte chiffré, jamais de
+nonce).
+
+### Étape 4 — Brancher les lecteurs internes AVANT toute purge
+
+**Point de vigilance principal de la mise en service.** Les
+lecteurs actuels d'ObsiGate (`backend/ai.py`,
+`backend/tools/secrets.py`) lisent encore `data/api_keys.json`
+directement ; ils ne sont pas encore branchés sur le coffre
+(reste à faire explicite des Phases 2–5). Tant que ce branchement
+n'est pas livré et validé, **purger le clair priverait l'IA et les
+outils de leurs clés**.
+
+Ordre à respecter :
+
+1. Ne pas purger.
+2. Livrer (en branche + PR, jamais mergé sans go) le branchement
+   des lecteurs internes sur une distribution depuis le coffre
+   d'instance, puis le valider sur l'instance : l'IA et les outils
+   fonctionnent avec `api_keys.json` rendu temporairement
+   inaccessible en lecture (test de coupure contrôlée), ou à
+   défaut avec un secret de test distribué depuis le coffre.
+3. Seulement après cette validation, passer à l'étape 7.
+
+Si Bruno accepte une interruption temporaire de l'IA/outils, le
+documenter explicitement avant la purge ; sinon, la purge attend
+le branchement.
+
+### Étape 5 — Brancher les applications clientes
+
+Pour chaque application (branches dédiées, jamais mergées sans
+go), appliquer le patron commun **distribuer → utiliser →
+oublier** : le serveur distribue à chaque opération, utilise la
+valeur en mémoire, puis l'oublie ; aucune valeur en cache, aucune
+persistance. Si ObsiGate est indisponible, l'opération échoue
+proprement, sans repli sur une ancienne valeur.
+
+- **Spark (agent-commun, Phase 3)** : identités référencées
+  `coffre:<slug>/<nom>` (slug 3–64, nom 3–128, minuscules /
+  chiffres / `-` / `_`), sans colonne valeur ; le LLM ne voit que
+  la référence et un accès oui/non. Sans octroi, la mission passe
+  en `acces_requis` en nommant l'accès manquant ; avec octroi et
+  mission approuvée (enveloppe budgétaire), distribution puis
+  injection en variable d'environnement de l'exécuteur, jamais
+  dans le prompt, jamais dans les étapes d'activité. Fin de
+  mission = environnement détruit.
+- **TikTak (Phase 4)** : référence seule stockée ; distribution
+  serveur à chaque synchro ; masquage côté Android (ni référence
+  complète ni valeur dans les réponses vues par une clé `tck_`).
+  Les configurations existantes sont marquées `a_resaisir = 1`
+  (migration 019 : colonne en clair supprimée, référence vide) :
+  il n'y a **pas de conversion automatique** — chaque
+  configuration doit être re-saisie par référence.
+- **Flowdeck (Phase 4)** : `workspace_id` + référence sur les
+  connecteurs ; distribution en mémoire ; isolation A vs B
+  testée (un workspace ne distribue pas avec l'octroi d'un autre).
+  Les connecteurs natifs Gitea/GitHub et les clés LLM ne sont pas
+  basculés ; pas de sélecteur UI (API seulement).
+- **Kanbante (Phase 4)** : secret webhook migré en référence,
+  distribuée à chaque webhook puis oubliée ; client générique
+  réutilisable. Les jetons forge chiffrés Fernet ne sont **pas**
+  migrés (distribution par appel requise, incompatible avec le
+  cache `ForgeRegistry`) ; les secrets webhook historiques en
+  clair restent acceptés par compatibilité, sans migration
+  automatique.
+
+### Étape 6 — Valider (avant purge)
+
+Exécuter la checklist de validation de l'instance réelle (§4).
+Tant qu'un point échoue, ne pas purger et ne pas considérer la
+mise en service comme terminée.
+
+### Étape 7 — Purger, seulement après validation
+
+`POST /api/coffres/migration/api-keys/purger`, **après
+confirmation explicite** (`confirmer = true`), et uniquement pour
+les noms migrés. Sans confirmation, rien n'est supprimé — jamais
+automatiquement.
+
+Après purge, vérifier :
+
+- `api_keys.json` ne contient plus les noms purgés ;
+- l'IA et les outils fonctionnent toujours (lecteurs branchés,
+  étape 4) ;
+- une distribution de test via un consommateur existant aboutit
+  (succès seul vérifié, valeur ni affichée ni consignée).
+
+### Étape 8 — Sauvegarder et tester la restauration
+
+1. Sauvegarder `data/coffres.json` + `data/coffres_valeurs.json`
+   (0600) par la sauvegarde habituelle du serveur, et la KEK à
+   part, hors serveur (§1.3).
+2. Rejouer la restauration sur une instance vierge (procédure
+   `docs/COFFRE-sauvegarde-restauration.md` §3 : arrêt de la
+   cible, copie des deux fichiers en 0600, même KEK, redémarrage,
+   vérification `has_value = true` + distribution de test +
+   `distribution_ok` dans le journal). La suite automatisée
+   (`tests/test_coffre_secrets.py`, classe
+   `TestRestaurationVierge`) simule cette restauration ; elle ne
+   remplace pas un essai sur instance réelle.
+3. En cas de perte de KEK : perte d'accès assumée, par
+   construction — aucun moyen de récupérer les valeurs. Recréer
+   les coffres avec une nouvelle KEK, régénérer les valeurs côté
+   fournisseur, révoquer les anciennes côté fournisseur, recréer
+   consommateurs et octrois. Ne jamais tenter de « réparer » les
+   anciens fichiers avec une nouvelle KEK (le déchiffrement
+   échouera sur tag GCM invalide, ce qui est attendu).
+
+## 4. Checklist de validation par Bruno sur instance réelle
+
+Validation exigée par l'issue #23 avant tout usage réel. Chaque
+point est validé sur capture, comme pour les autres livraisons :
+
+- [ ] **Sidebar** : le nœud « Secrets » (cadenas U+1F510)
+  apparaît sous le Home de l'utilisateur courant seulement, et
+  pas sous les autres vaults ; cliquer dessus ouvre la vue
+  Secrets sans naviguer dans les fichiers.
+- [ ] **Secret de test** : création d'un secret de test
+  (valeur fictive, ex. `TEST-VALUE-XXXX`) dans un coffre
+  personnel, puis lecture : métadonnées seules, aucune valeur
+  affichée, aucun texte chiffré, aucun nonce.
+- [ ] **Journal d'audit** : après une distribution de test, le
+  journal contient `distribution_ok` pour la référence, et un
+  `grep` du journal sur la valeur de test ne renvoie **rien**
+  (ni valeur, ni texte chiffré, ni nonce, ni jeton).
+- [ ] **Autorisations** : un admin ne voit pas le coffre
+  personnel d'autrui ; une ACL `*` sur un vault ne donne aucun
+  droit sur un coffre ; une session utilisateur, même admin, ne
+  distribue pas (401 `consommateur_invalide`).
+- [ ] **Distribution** : contexte manquant refusé (400
+  `contexte_manquant`) ; octroi révoqué refusé dès l'appel
+  suivant (403 `octroi_revoque`) ; octroi expiré refusé (403
+  `octroi_expire`) ; secret expiré refusé (410 `secret_expire`).
+- [ ] **Import / purge** : l'import ne modifie pas
+  `api_keys.json` et n'écrase pas un secret existant ; la purge
+  sans confirmation explicite ne supprime rien.
+- [ ] **Restauration** : sauvegarde + KEK externe restaurées sur
+  une instance vierge, distributions fonctionnelles.
+- [ ] **Intégrations** : mission Spark en `acces_requis` sans
+  octroi, puis injection exécuteur sans trace dans les étapes ;
+  synchro TikTak sans valeur côté Android ; isolation workspace
+  Flowdeck (A ne distribue pas avec l'octroi de B).
+- [ ] **Modale** : la modale de création de secret n'est plus
+  coupée en haut (`.obsigate-modal` bornée au viewport, corps
+  seul défilant, en-tête et pied toujours visibles).
+
+## 5. Limites connues à la mise en service
+
+À lire avant de déclarer la mise en service terminée :
+
+- **Lecteurs internes non branchés** (`ai.py`,
+  `tools/secrets.py` lisent encore `api_keys.json` en clair) :
+  purger avant de les brancher priverait l'IA/outils de leurs
+  clés (§3, étape 4).
+- **Endpoint dédié de copie manuelle par session non ajouté**
+  (décision volontaire, §2) : la copie manuelle passe par un
+  consommateur temporaire admin, presse-papiers seul.
+- **Isolation workspace Flowdeck non contrôlée côté ObsiGate** :
+  `/distribuer` n'autorise aujourd'hui que les octrois de type
+  `consommateur` ; l'isolation workspace repose sur le serveur
+  Flowdeck lui-même (il ne demande que les références de son
+  workspace, avec son propre jeton). Un contrôle serveur strict
+  reste à spécifier si Bruno l'exige.
+- **Identités agent-commun** : détenteur libre hors coffre
+  conservé (historique) ; révocation Identités non propagée vers
+  ObsiGate (pas d'endpoint) ; exécuteurs CLI synchrones
+  uniquement.
+- **TikTak** : « sélecteur » = saisie validée, pas de liste
+  déroulante (aucune API de listage côté ObsiGate) ;
+  configurations existantes à re-saisir, pas de conversion
+  automatique.
+- **Flowdeck** : natifs Gitea/GitHub et clés LLM non basculés ;
+  pas de sélecteur UI (API seulement) ; `workspace_id` pas encore
+  branché depuis AgentEngine.
+- **Kanbante** : jetons forge chiffrés Fernet non migrés ;
+  pas de migration automatique des secrets webhook historiques.
+- **Recherche / graphe / index** : par construction, un coffre
+  n'est pas un vault de notes — il ne passe ni par l'indexeur, ni
+  par la recherche, ni par le graphe, et aucun outil MCP de secret
+  n'existe. Aucune métadonnée de secret ne doit apparaître dans
+  ces index (vérification par revue de code, pas de suite
+  automatisée dédiée — voir le bilan Phase 5).
+
+## 6. Repli (rollback)
+
+- Désactiver le flag (`OBSIGATE_SECRETS_ENABLED` absent ou
+  `false`) : toutes les routes coffre répondent 503, les fichiers
+  `coffres.json` / `coffres_valeurs.json` restent intacts et
+  re-distribueront dès réactivation avec la même KEK.
+- Révoquer un consommateur (`DELETE
+  /api/coffres/consommateurs/{id}`) coupe immédiatement ses
+  distributions, sans toucher aux autres consommateurs ni aux
+  secrets.
+- Ne jamais « réparer » des fichiers chiffrés avec une nouvelle
+  KEK, ne jamais restaurer `coffres.json` sans
+  `coffres_valeurs.json` (et inversement), ne jamais copier la
+  KEK au même endroit que la sauvegarde.
+
+## 7. Références
+
+- Spec « Coffre de secrets ObsiGate » §6 (autorisations), §7/§10/§11
+  (API), §13/§14 (sauvegarde/restauration), §15/§16 (tests,
+  déploiement).
+- Issues ObsiGate : #17 (Phase 1a), #18 (Phase 1b), #19 (Phase 1c
+  UI), #20 (Phase 2), #21 (Phase 3, Spark), #22 (Phase 4, TikTak /
+  Flowdeck / Kanbante), #23 (Phase 5, ce document).
+- Suites de tests : `tests/test_coffre_secrets.py` (ObsiGate, 35
+  tests), `tests/test_identites_coffre_phase3.py` (agent-commun,
+  16 tests), `tests/test_coffre_reference.py` (TikTak, 17 fonctions
+  / 26 cas), `tests/test_coffre_reference_flowdeck.py` (Flowdeck,
+  16 tests), `tests/test_coffre_client.py` (Kanbante, 11 fonctions
+  / 25 cas). Voir le bilan Phase 5 pour la matrice de couverture
+  complète et les manques.

docs/COFFRE-sauvegarde-restauration.md

@@ -0,0 +1,155 @@
+# Coffre Secrets ObsiGate — Sauvegarde et restauration (Phase 2, issue #20)
+
+Ce document décrit la seule procédure supportée pour sauvegarder et
+restaurer le coffre Secrets, ainsi que le cas de perte de la KEK.
+Il complète la spécification du coffre (§13, §14) ; il ne décrit
+aucune valeur réelle — les exemples utilisent des valeurs fictives.
+
+## 1. Ce qui constitue une sauvegarde
+
+Deux fichiers, et seulement ces deux fichiers, portent le coffre :
+
+| Fichier | Contenu |
+| --- | --- |
+| `data/coffres.json` | Coffres (métadonnées + DEK chiffrées), consommateurs (hashes de jetons seulement), octrois, métadonnées des secrets. |
+| `data/coffres_valeurs.json` | Versions chiffrées des secrets (AES-256-GCM). |
+
+Ces deux fichiers forment une **sauvegarde ordinaire chiffrée** :
+copiés seuls, ils ne donnent accès à aucune valeur — chaque DEK est
+chiffrée par la KEK, chaque valeur est chiffrée par la DEK de son
+coffre. Ils peuvent donc transiter par la sauvegarde habituelle du
+serveur, avec les mêmes permissions restrictives que sur l'instance
+(0600). Ils ne doivent jamais être déposés dans le dépôt Git, ni dans
+une note ObsiGate, ni dans un journal.
+
+La **KEK ne fait pas partie de la sauvegarde** : elle est copiée à
+part, hors serveur (voir §2). Sauvegarder les deux fichiers et la KEK
+au même endroit annulerait la protection du chiffrement.
+
+## 2. Sauvegarder la KEK (copie externe, hors serveur)
+
+La KEK est une clé maître 256 bits (base64 de 32 octets), générée une
+seule fois via `POST /api/coffres/admin/generer-kek` (admin, coffres
+activés) et **jamais stockée par ObsiGate**. Au moment de sa
+génération :
+
+1. Copiez-la immédiatement dans un gestionnaire de mots de passe ou
+   sur un support hors ligne, hors du serveur ObsiGate.
+2. Ne la collez jamais dans le dépôt, jamais dans une note ObsiGate,
+   jamais dans le même dossier que `data/`, jamais dans un journal.
+3. Vérifiez la copie (relisez-la depuis le gestionnaire, pas depuis
+   l'écran qui ne l'affichera plus jamais).
+
+Variables d'environnement (documentées aussi dans `.env.example`,
+sans aucune valeur) :
+
+| Variable | Rôle | Défaut |
+| --- | --- | --- |
+| `OBSIGATE_SECRETS_ENABLED` | Activation du coffre. Toute route répond 503 tant qu'elle n'est pas activée. | désactivé |
+| `OBSIGATE_KEK` | KEK, base64 de 32 octets (ou hex 64 caractères). Prioritaire sur le fichier. | absente |
+| `OBSIGATE_KEK_FILE` | Chemin d'un fichier 0600, hors dépôt et hors arborescence des vaults, contenant la KEK. Un fichier trop permissif est refusé. | absent |
+| `OBSIGATE_DATA_DIR` | Répertoire des données (`data/` par défaut), donc des deux fichiers du coffre et de `api_keys.json`. | `data` |
+
+**Aucune autre variable ne doit contenir une valeur de secret du
+coffre.** En particulier, ne créez jamais de variable du type
+`COFFRE_<nom>` avec une valeur : la seule valeur externe autorisée est
+la KEK, et elle n'est pas une valeur de secret du coffre.
+
+## 3. Restauration sur une instance (y compris vierge)
+
+Prérequis : une instance ObsiGate avec le coffre activé
+(`OBSIGATE_SECRETS_ENABLED`), et la **même KEK** que l'instance
+d'origine.
+
+1. Arrêtez l'instance cible (ou, à défaut, assurez-vous qu'aucune
+   écriture n'a lieu pendant la copie).
+2. Restaurez les deux fichiers `coffres.json` et
+   `coffres_valeurs.json` dans le répertoire de données cible, en
+   permissions 0600.
+3. Re-présentez la même KEK, via `OBSIGATE_KEK` ou via
+   `OBSIGATE_KEK_FILE` (fichier 0600, hors dépôt).
+4. Redémarrez l'instance.
+5. Vérifiez, sans jamais afficher ni journaliser de valeur :
+   - la vue Secrets liste les coffres et les secrets avec
+     `has_value = true` ;
+   - une distribution de test via un consommateur existant (ou un
+     consommateur de test, révoqué ensuite) aboutit — côté serveur,
+     le succès seul est vérifié, la valeur n'est ni affichée ni
+     consignée ;
+   - le journal d'audit contient `distribution_ok` pour cette
+     référence.
+
+**Test de restauration obligatoire avant la mise en service réelle
+(issue #20)** : la procédure ci-dessus a été automatisée dans la
+suite de tests (`tests/test_coffre_secrets.py`, classe
+`TestRestaurationVierge`) — copie des deux fichiers vers un
+répertoire vierge, même KEK, distributions fonctionnelles — et doit
+aussi être rejouée une fois sur une instance réelle par l'opérateur
+avant de considérer la sauvegarde comme valide.
+
+## 4. Perte de la KEK : perte d'accès assumée, par construction
+
+Si la KEK est perdue, **il n'existe aucun moyen de récupérer les
+valeurs** : les DEK ne sont stockées que chiffrées par la KEK, et les
+valeurs ne sont stockées que chiffrées par les DEK (AES-256-GCM,
+authentifié). Il n'y a ni clé de secours, ni dérivation depuis le
+secret d'application, ni porte dérobée.
+
+Procédure en cas de perte :
+
+1. Considérez toutes les valeurs du coffre comme perdues.
+2. Créez de nouveaux coffres avec une nouvelle KEK.
+3. Pour chaque secret perdu, régénérez la valeur **côté fournisseur**
+   (nouvelle clé API, nouveau jeton) et créez un nouveau secret avec
+   cette nouvelle valeur ; révoquez les anciennes valeurs côté
+   fournisseur, car elles restent valides hors d'ObsiGate tant qu'elles
+   ne sont pas révoquées là-bas.
+4. Recréez les consommateurs et les octrois (les anciens octrois
+   pointent vers des secrets qui n'existent plus dans les nouveaux
+   coffres).
+5. Ne tentez pas de « réparer » les anciens fichiers avec une nouvelle
+   KEK : le déchiffrement échouera (tag GCM invalide), ce qui est le
+   comportement attendu, pas un bug.
+
+La rotation KEK (`POST /api/coffres/admin/rotation-kek`) n'est pas
+une récupération : elle exige l'ancienne KEK encore valide pour
+re-chiffrer les DEK, puis le remplacement de la KEK dans
+l'environnement ou le fichier KEK.
+
+## 5. Migration `api_keys.json` (Phase 2) — avertissement important
+
+Le bouton « Importer l'existant » de la vue Secrets (admin seulement)
+copie les clés IA et clés d'outils de `data/api_keys.json` vers le
+coffre d'instance « ObsiGate interne » (slug `obsigate-interne`),
+en deux temps :
+
+1. **Import** : les entrées avec valeur sont chiffrées dans le coffre
+   (un secret déjà présent n'est jamais écrasé) ; `api_keys.json`
+   n'est pas modifié.
+2. **Purge** : après confirmation explicite, et uniquement pour les
+   noms migrés, les entrées sont supprimées du clair. Sans
+   confirmation, rien n'est supprimé — jamais automatiquement.
+
+**Avertissement** : les lecteurs actuels d'ObsiGate
+(`backend/ai.py`, `backend/tools/secrets.py`) lisent encore
+`api_keys.json` directement ; ils ne sont pas encore branchés sur le
+coffre. Purger le clair prive donc ces lecteurs de la clé tant que
+leur lecteur n'est pas branché sur une distribution depuis le coffre.
+Ne purgez que si vous avez vérifié que le consommateur concerné
+distribue depuis le coffre, ou si vous acceptez cette interruption.
+Ce branchement des lecteurs internes est un reste à faire explicite
+(voir §6).
+
+## 6. Restes à faire (après cette Phase 2)
+
+- Brancher les lecteurs internes (`ai.py`, `tools/secrets.py`) sur
+  une distribution depuis le coffre d'instance, pour que la purge du
+  clair ne coupe pas l'IA ni les outils.
+- Rejouer le test de restauration sur une instance réelle (la suite
+  automatisée simule une instance vierge, elle ne remplace pas un
+  essai sur l'instance de production).
+- Endpoint de distribution par session utilisateur (copie manuelle
+  sans consommateur temporaire) : non ajouté ici, car il contredirait
+  la règle Phase 1b (distribution réservée aux consommateurs) et
+  exigerait une ré-authentification qui n'existe pas encore — décision
+  à prendre avec l'opérateur avant toute implémentation.

docs/ISSUES_TODOLIST.md

@@ -225,6 +225,8 @@ Avant de corriger quoi que ce soit, un agent IA doit :
 | *BUG-115* | Éditeur Forge : cases à cocher collées au texte dans l'aperçu, aperçu qui flashe à la frappe, menu « dimensions du tableau » coupé hors écran sur un document court | 🟢 corrigé | P2 | 📱 frontend / éditeur | IA | `frontend/editor-poc.html` (CSS aperçu, `renderPreview`, `showTableForm`, `showLangPicker`) | Ouvrir un `.md` avec `- [ ]`, activer l'aperçu → texte collé au checkbox + flash « Rendering... » ; `/table` sur un document d'une ligne → forme partiellement visible | (1) règle `.task-list-item input[type=checkbox] { margin-right: 6px }` ajoutée au `<style>` de l'aperçu (miroir `style.css:2303`) ; (2) `renderPreview` ne remplace plus le contenu par le spinner (affiché seulement si vide) + flag `_previewDirty` pour rejouer la dernière frappe ; (3) `.inline-form`/`.lang-picker` en `position: fixed` (coordonnées viewport) avec clamp bas/droite comme le menu slash + `stopPropagation` sur les clics qi/slash (le listener document refermait la forme) | Vérifié en Playwright (instance E2E) : marginRight 6 px + `list-style: none`, MutationObserver : aucun « Rendering... » pendant 14 frappes et dernier état rendu, forme table `bottom 193 < vh 900` sur document 1 ligne + insertion OK |
 | *BUG-116* | Éditeur Forge : après insertion d'un tableau (ex. 4 lignes), la textarea reste d'une seule ligne au lieu de s'agrandir | 🟢 corrigé | P2 | 📱 frontend / éditeur | IA | `frontend/editor-poc.html` (`insertAtCursor`, `wrapSelection`) | Insérer un tableau via le menu : le contenu contient bien les nouvelles lignes mais la hauteur de la textarea ne change pas | Les mutations programmatiques de `ta.value` ne déclenchent pas l'événement `input` — seul handler qui rappelait `autoHeight()`/`updateLineNumbers()` (les handlers clavier, eux, les appelaient à la main). Ajout des deux appels dans `insertAtCursor` et `wrapSelection`, les deux points de passage de toutes les insertions (tableau, code, mermaid, checklist, gras multi-ligne) | Vérifié en Playwright sur l'instance E2E (qi → Table, 4 lignes, sur doc d'une ligne) : hauteur 51 → 189 px, 8 lignes rendues, gutter aligné | ### TODOs techniques (améliorations / nouvelles tâches)
 | *BUG-117* | Drag & drop des fichiers dans la sidebar : le déplacement d'un répertoire à un autre ne fait plus rien, sans message | 🟢 corrigé | P1 | 📱 frontend / sidebar | IA | `frontend/js/dragdrop.js` (`onDrop`) | Glisser un fichier sur un dossier : aucune requête `/api/move`, aucun toast | La détection `isExternalFiles` dans `onDrop` (`items.length > 0`, ajoutée par #89) comptait aussi les formats string du drag interne (`tree:vault/path/type` posés par `setData` au `dragstart`) : tout déplacement partait dans la branche upload où rien ne passe le filtre `kind === 'file'` → drop avalé silencieusement. Corrigé à la racine : `dragState` (interne) prioritaire + items réellement fichiers. Livré avec #201 : menu contextuel Déplacer/Dupliquer réutilisant `promptTargetFolder`, emplacement actuel pré-sélectionné | Vérifié Playwright instance E2E : glisser `note1.md` → `d1` = toast « Moved file to d1 » + chemin déplacé ; 4 tests `TestDuplicateApi` |
+| *BUG-119* | Panneau Spark : le « mode console » (surimpression iframe de la console du service d'agents) est bloqué par le navigateur (« This content is blocked ») | 🟢 corrigé | P1 | ⚙️ backend | IA | `backend/main.py` (`SecurityHeadersMiddleware`) | Panneau Spark → « Console ⤢ » : l'iframe reste sur la page d'erreur du navigateur | `frame-src 'self' blob: https://agent.dracodev.net` dans la CSP servie ; test `tests/test_security_headers.py::test_csp_frame_src_allows_agent_console` | Cause : `frame-src` n'autorisait pas l'origine du service d'agents, pourtant déjà présente dans `connect-src` (le panneau texte fonctionnait). Aucune autre directive modifiée. Redéploiement Docker requis |
+| *BUG-120* | Menu inter-apps : sur l'environnement dev, les URL sœurs servies (`window.DRACO_URLS` : ObsiGate, Flowdeck, TikTak, Kanbante) restent en noms **prod** alors que l'URL de l'agent est bien en `-dev` | 🟢 corrigé | P1 | ⚙️ backend | IA | `backend/draco_config.py` (`app_url`, `_suffixe_environnement`) | Sur og-dev : `window.DRACO_URLS` donne `agent: https://agent-dev.dracodev.net` mais `tiktak: https://tiktak.dracodev.net` (prod) — le `.env` dev ne déclare pas les quatre `DRACO_<APP>_URL` | `backend/draco_config.py` : résolution sœur en 3 temps — explicite, puis **dérivation d'environnement** depuis l'hôte de `agent_url()` (`agent<SUFFIXE>.dracodev.net` → `https://<slug><SUFFIXE>.dracodev.net`, slugs `og`/`flowdeck`/`tiktak`/`kanbante` ; hors motif → rien), puis défaut officiel ; Gitea exclue. Tests `tests/test_draco_config.py` (+9 : dérivation `-dev` via `AGENT_EVENEMENTS_URL` et via `DRACO_AGENT_URL`, priorité de l'explicite, 5 hôtes hors motif, suffixe vide, injection) | Suite de #223 : seule l'URL de l'agent avait une dérivation de repli (`AGENT_EVENEMENTS_URL`) ; les sœurs retombaient sur les défauts officiels. Correctif de code demandé par Bruno : l'environnement se déduit de l'agent déjà configuré, sans variable supplémentaire. Redéploiement Docker requis |
 
 | # | Titre | Statut | Priorité | Scope | Assigné | Zone (fichier) | Cmd de repro | Correctif / Commit | Notes |
 |---|---|---|---|---|---|---|---|---|---|
@@ -357,6 +359,8 @@ Avant de corriger quoi que ce soit, un agent IA doit :
 | 2026-10-21 | BUG-118 | Correction | `frontend/index.html`, `frontend/draco-barre.css`, `tests/test_draco_barre.py`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md` | **BUG-118 — la barre d'apps Fusion était inutilisable en mobile** (retours de Bruno sur captures téléphone). Deux causes : (1) le palier ≤ 700 px de la CSS commune gardait onglets entiers et pastilles domaines — la barre débordait ; la source dracodev-commons passe en **v0.1.2** (spec des barres, § Mobile : marque, onglet de l'app courante, alertes, Spark, avatar ; rail/recherche/domaines/menu masqués au profit des contrôles natifs). (2) Le bouton ☰ de la barre cliquait `sidebar-toggle-btn` (bureau) au lieu de `hamburger-btn` (tiroir mobile) : sur téléphone il ne faisait rien, doublé du vrai hamburger d'ObsiGate juste en dessous. Rail devenu contextuel (`matchMedia` ≤ 768 px, point de bascule d'ObsiGate). Test de non-régression `tests/test_draco_barre.py` (2 tests) | 🟢 corrigé (en attente vérif utilisateur) |
 | 2026-10-15 | BUG-117 + #201 | Correction + feature | `frontend/js/dragdrop.js`, `frontend/js/ui.js`, `frontend/js/upload.js`, `frontend/locales/fr.json`, `frontend/locales/en.json`, `backend/services/mutations.py`, `backend/routers/files_write.py`, `backend/schemas.py`, `tests/test_api_main.py`, `CHANGELOG.md`, `docs/ROADMAP.md`, `docs/ISSUES_TODOLIST.md` | **BUG-117 — le drag & drop interne de la sidebar était mort en silence.** `onDrop` classait tout dépôt « externe » dès que `dataTransfer.items` était non vide — or un glisser interne dépose 4 formats string (`tree:*`) : chaque déplacement partait dans la branche upload où le filtre `kind === 'file'` ne trouvait rien — aucun appel API, aucun toast. Détection corrigée (vrais fichiers seulement, `dragState` prioritaire). Livré avec **#201 : menu contextuel Déplacer/Dupliquer** (fichiers et dossiers), modal `promptTargetFolder` réutilisé (+ `opts`, emplacement actuel pré-sélectionné), endpoint `POST /api/duplicate/{vault}` (`duplicate_path`, index incrémental, SSE/webhooks, refus inside-self), i18n FR/EN, 4 tests `TestDuplicateApi` + validation Playwright E2E complète | 🟢 corrigé/livré (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) |
+| 2026-10-23 | BUG-119 | Correction | `backend/main.py`, `tests/test_security_headers.py`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md`, `docs/ROADMAP.md` | **BUG-119 — le « mode console » du panneau Spark V3 (#222) était bloqué par le navigateur** (« This content is blocked ») : la console du service d'agents s'affiche dans une iframe `https://agent.dracodev.net`, mais la CSP servie par `SecurityHeadersMiddleware` limitait `frame-src` à `'self' blob:` — seul le panneau texte passait (`connect-src` autorisait déjà l'origine). Correctif strict : `frame-src 'self' blob: https://agent.dracodev.net`, toutes les autres directives inchangées à l'identique. Test de non-régression `test_csp_frame_src_allows_agent_console` (la CSP servie est analysée et la liste exacte des sources `frame-src` verrouillée). Vérifié : 100 passed (security_headers + csp_nonce + security_hardening + draco_barre + version), ruff propre sur les fichiers touchés (51 erreurs préexistantes ailleurs, inchangées), mypy 0 (120 fichiers) | 🟢 corrigé (en attente vérif utilisateur) |
+| 2026-10-25 | BUG-120 (suite #223) | Correction | `backend/draco_config.py`, `tests/test_draco_config.py`, `.env.example`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md`, `docs/ROADMAP.md`, `docs/features/devprod-urls-config-223.md` | **BUG-120 — le menu inter-apps de la dev pointait la prod** : `window.DRACO_URLS` servait l'agent en `-dev` mais les quatre sœurs en noms officiels, le `.env` dev ne déclarant pas les `DRACO_<APP>_URL`. Correctif dans `draco_config.app_url()` : après l'explicite, **dérivation d'environnement** — hôte de `agent_url()` de la forme `agent<SUFFIXE>.dracodev.net` sans port → sœur en `<slug><SUFFIXE>.dracodev.net` ; hors motif (autre domaine, LAN, IP, port) aucune dérivation ; Gitea jamais dérivée. Vérifié : `test_draco_config.py` 16 passed, suite complète **1668 passed / 9 skipped**, ruff 0 et mypy 0 sur les fichiers touchés (51 erreurs ruff préexistantes ailleurs, inchangées) | 🟢 corrigé (en attente vérif utilisateur) |
 
 ---
 

docs/ROADMAP.md

@@ -1,6 +1,6 @@
 # ObsiGate — Roadmap
 
-> **Version :** 2.73.1 | **Dernière mise à jour :** 2026-10-21
+> **Version :** 2.81.0 | **Dernière mise à jour :** 2026-10-28
 > **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,160 @@
 
 ## 🔵 En cours
 
+### 225. Fusion — panneau Spark : version du service d'agents visible en mode sidebar
+
+- **Effort :** ~0,1 jour | **Impact :** 🟢 | **Ouvert :** 2026-10-26 | **Statut :** ✅ livré le 2026-10-26 (version du hook — voir CHANGELOG ; redéploiement Docker requis)
+- **Fiche :** [features/fusion-panneau-version-agent-225.md](./features/fusion-panneau-version-agent-225.md)
+- **Description :** demande de Bruno (2026-10-26, carte fusion #64) : la
+  version « Service d'agents vX », déjà visible dans la console pleine
+  page, doit se lire aussi dans le **panneau natif des apps** (mode
+  sidebar). Le pied du panneau Spark affiche désormais cette ligne,
+  discrète et permanente, lue **en direct** dans la santé du service
+  (`GET /healthz` de l'origine injectée par l'hôte) à l'ouverture du
+  panneau, avec cache de session — jamais une valeur codée en dur ;
+  service injoignable = rien d'affiché. Même livraison : TikTak
+  0.61.3, Flowdeck 7.83.1, Kanbante 0.37.1.
+- **Sous-tâches :**
+  - [x] Ligne de version dans le pied du panneau (canonique TikTak, propagée aux 4 apps)
+  - [x] Test `tests/test_draco_barre.py::test_panneau_version_service_affichee_225` + épreuve comportementale jsdom sur les 4 copies
+  - [x] Release publiée — CI verte à constater, redéploiement Docker (geste de Bruno)
+
+### 224. Sécurité des dépendances — pip-audit vierge (brotli, filelock, opentelemetry-api, pypdf)
+
+- **Effort :** ~0,1 jour | **Impact :** 🔴 | **Ouvert :** 2026-10-25 | **Statut :** ✅ livré le 2026-10-25 (version du hook — voir CHANGELOG ; redéploiement Docker requis)
+- **Fiche :** [features/securite-dependances-pip-audit-224.md](./features/securite-dependances-pip-audit-224.md)
+- **Description :** le job `security` du run CI 2303 (2.78.0) échoue
+  sur `pip-audit` : 17 vulnérabilités dans 4 paquets hérités de
+  l'environnement du runner (toolcache « already satisfied », même
+  piège que BUG-093). Planchers explicites dans
+  `backend/requirements.txt` : pypdf relevé à `>=6.21.2`, nouveaux
+  planchers `brotli>=1.2.1`, `filelock>=4.2.1`,
+  `opentelemetry-api>=1.45.1` ; garde-fou `TestDependencySecurityFloors`
+  étendu. Aucun code applicatif, aucun nouvel ignore pip-audit.
+- **Sous-tâches :**
+  - [x] Planchers de sécurité dans `backend/requirements.txt` + commentaires
+  - [x] Garde-fou `tests/test_ci_workflow.py::TestDependencySecurityFloors` étendu (pypdf 6.21.2, brotli, filelock, opentelemetry-api)
+  - [x] `pip-audit` local : 0 vulnérabilité non ignorée (mêmes ignores que la CI)
+  - [x] Release publiée — CI verte à constater, redéploiement Docker (geste de Bruno)
+
+### 223. Dev/prod sans noms publics en dur — URLs de l'écosystème par configuration
+
+- **Effort :** ~0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-10-25 | **Statut :** ✅ livré le 2026-10-25 (version du hook — voir CHANGELOG ; redéploiement Docker requis, et en dev déclarer les noms en `-dev` dans le `.env` du poste)
+- **Fiche :** [features/devprod-urls-config-223.md](./features/devprod-urls-config-223.md)
+- **Description :** aucun nom public de l'écosystème dracodev ne doit être
+  figé dans le code vivant : les URL publiques (service d'agents, autres
+  apps) viennent de la configuration (défauts = noms **officiels** sans
+  suffixe ; l'environnement dev déclare ses noms en `-dev` dans son
+  `.env`). CSP dérivée de l'origine de l'agent configurée, panneau Spark
+  et liens inter-apps alimentés par l'hôte (injection `window.DRACO_URLS`
+  au service de `index.html`), références croisées reconstruites depuis
+  la config à l'affichage (aucune donnée migrée).
+- **Sous-tâches :**
+  - [x] Module `backend/draco_config.py` + `.env.example`
+  - [x] CSP `connect-src`/`frame-src` dérivée de la config (tests via config)
+  - [x] `external_refs` : hôtes reconnus + URL d'affichage construites par config
+  - [x] Frontend : panneau Spark, liens TikTak, onglets des apps via `DRACO_URLS`
+  - [x] WebAuthn : confirmation rp_id/origines dérivés de la requête / `OBSIGATE_WEBAUTHN_*`
+
+### 222. Fusion — panneau Spark V3 : la console en surimpression pleine page
+
+- **Effort :** ~0,1 jour | **Impact :** 🟢 | **Ouvert :** 2026-10-23 | **Statut :** ✅ livré le 2026-10-23 (2.77.0, redéploiement Docker en attente)
+- **Fiche :** [features/fusion-panneau-console-surimpression-222.md](./features/fusion-panneau-console-surimpression-222.md)
+- **Description :** le panneau Spark (asset vendangé `frontend/draco-panneau.js`,
+  octet-identique dans les 4 apps) passe en V3 (demande de Bruno,
+  2026-10-22) : le bouton « Console ⤢ » n'ouvre plus la console du
+  service d'agents en nouvel onglet (#221) mais en **surimpression
+  pleine page dans la même page** — montée à la largeur du panneau,
+  étendue à toute la fenêtre par transition, iframe gardant le lien
+  profond (`?disc=` / `?app=`), et deux sorties dans sa barre :
+  « Mode sidebar » (rétraction vers le panneau) et « Fermer l'agent ».
+  Styles injectés par le panneau ; côté service, la console autorise
+  l'encadrement par les 4 apps (0.20.0). Même livraison : TikTak
+  0.60.0, Flowdeck 7.81.0, Kanbante 0.29.0.
+- **Sous-tâches :**
+  - [x] Surimpression + barre « Mode sidebar » / « Fermer l'agent »
+        dans le panneau canonique (TikTak), recopié octet-identique
+        dans les 4 apps
+  - [x] Test `tests/test_draco_barre.py::test_panneau_console_surimpression_222`
+        (et révision du test #221 : le nouvel onglet disparaît)
+  - [x] Release v2.77.0 publiée — CI à constater, redéploiement Docker (geste de Bruno)
+
+### 221. Fusion — panneau Spark : bouton « Console ↗ » vers la console du service
+
+- **Effort :** ~0,1 jour | **Impact :** 🟢 | **Ouvert :** 2026-10-22 | **Statut :** ✅ livré le 2026-10-22 (2.76.1, redéploiement Docker en attente)
+- **Fiche :** [features/fusion-panneau-console-221.md](./features/fusion-panneau-console-221.md)
+- **Description :** le panneau Spark (asset vendangé `frontend/draco-panneau.js`,
+  octet-identique dans les 4 apps) gagne un bouton « Console ↗ » dans sa barre
+  des discussions (demande de Bruno, 2026-10-22) : il ouvre la console web du
+  service d'agents (https://agent.dracodev.net/) dans un nouvel onglet, sur la
+  discussion actuellement affichée (`?disc=<id>`, URL construite au clic) et
+  avec l'app d'origine (`?app=obsigate`, déduite du sous-domaine `og`). La
+  console consomme déjà ces deux paramètres (lien profond de discussion +
+  puce « Ouvert depuis »). Même livraison : TikTak 0.59.1, Flowdeck 7.80.1,
+  Kanbante 0.28.1.
+- **Sous-tâches :**
+  - [x] Bouton + `ouvrirConsole()` / `appHote()` dans le panneau canonique
+        (TikTak), recopié octet-identique dans les 4 apps
+  - [x] Test `tests/test_draco_barre.py::test_panneau_bouton_console_221`
+  - [x] Release v2.76.1 publiée — CI à constater, redéploiement Docker (geste de Bruno)
+
+### 220. Fusion — émission d'événements vers le journal du service d'agents (Lot 2, vague 5)
+
+- **Effort :** ~0,5 jour | **Impact :** 🟢 | **Ouvert :** 2026-10-22 | **Statut :** ✅ livré le 2026-10-22 (2.76.0, redéploiement Docker en attente)
+- **Fiche :** [features/fusion-journal-evenements-220.md](./features/fusion-journal-evenements-220.md)
+- **Description :** ObsiGate émet ses mutations de notes **explicites**
+  vers le journal d'activité du service d'agents (contrat ACC-0.2,
+  carte fusion-trois-apps #18) : `obsigate.note.created / edited /
+  moved / deleted`, signées HMAC, en arrière-plan, inactives sans la
+  clé `AGENT_EVENEMENTS_CLE`. Points d'accroche : les endpoints
+  d'écriture de l'API web (acteur `user`) et la couche outils /
+  serveur MCP (acteur `agent:mcp`). **Garde-fou : jamais le
+  watcher** — seules les opérations explicites via l'API émettent.
+- **Sous-tâches :**
+  - [x] Module `backend/agent_journal.py` (enveloppe ACC-0.2,
+        signature HMAC-SHA256, envoi « au mieux »)
+  - [x] Branchements `backend/routers/files_write.py` (créer,
+        sauvegarder, renommer, déplacer, supprimer)
+  - [x] Branchements `backend/tools/service.py` (create/edit/
+        append/rename/move/delete, acteur selon le mode)
+  - [x] Tests `tests/test_agent_journal.py` — dont la preuve du
+        garde-fou watcher (écriture disque + indexation = silence)
+
+### 218. Fusion — panneau Spark intégré (agent commun)
+
+- **Effort :** ~0,5 jour | **Impact :** 🟢 | **Ouvert :** 2026-10-21 | **Statut :** ✅ livré le 2026-10-21 (2.74.0, redéploiement Docker en attente)
+- **Fiche :** [features/fusion-panneau-spark-218.md](./features/fusion-panneau-spark-218.md)
+- **Description :** le bouton Spark de la barre commune (#215) ouvre le
+  panneau de l'agent commun (service d'agents dracodev : conversation,
+  Aujourd'hui, approbations, missions longues), comme dans TikTak,
+  Flowdeck et Kanbante. Assets partagés vendangés à l'identique ;
+  la CSP nomme le service en `connect-src`.
+- **Sous-tâches :**
+  - [x] Assets `frontend/draco-panneau.js` / `frontend/draco-panneau.css`
+        vendangés depuis le panneau partagé du programme
+  - [x] `frontend/index.html` : link CSS + script, action `spark` →
+        `DRACO_PANNEAU.toggle()` (repli honnête si le panneau ne charge pas)
+  - [x] CSP `connect-src` : `https://agent.dracodev.net` ajouté
+        (`backend/main.py`, seul hôte ajouté)
+  - [x] Tests `test_draco_barre.py` (intégration + CSP verrouillées)
+
+### 219. Fusion — panneau Spark v2 (Lot 1)
+
+- **Effort :** ~0,5 jour | **Impact :** 🟢 | **Ouvert :** 2026-10-22 | **Statut :** ✅ livré le 2026-10-22 (2.75.0, redéploiement Docker en attente)
+- **Fiche :** [features/fusion-panneau-spark-v2-219.md](./features/fusion-panneau-spark-v2-219.md)
+- **Description :** le panneau Spark (#218) passe en v2, à l'identique
+  dans les quatre applications (carte fusion-trois-apps #17) :
+  réponses de l'agent en **Markdown rendu** (HTML produit par le
+  service d'agents 0.10.0, sanitizé côté serveur), **largeur
+  réglable** persistée, **thème clair/sombre aligné** sur
+  l'application hôte, **discussions façon Muse** (principale
+  perpétuelle + parallèles créées/archivées/supprimées). Côté
+  ObsiGate : assets vendangés uniquement, aucun code propre touché.
+- **Sous-tâches :**
+  - [x] Assets `frontend/draco-panneau.js` / `frontend/draco-panneau.css`
+        remplacés par la v2 partagée du programme
+  - [x] Fiche de conception `features/fusion-panneau-spark-v2-219.md`
+
 ### 215. Fusion bloc 1 — barre d'apps commune et références croisées des notes
 
 - **Effort :** ~1 jour | **Impact :** 🟢 | **Ouvert :** 2026-10-20 | **Statut :** ✅ livré le 2026-10-20 (2.70.0)
@@ -1012,6 +1166,9 @@
 | 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) |
+| BUG-119 | Panneau Spark — « mode console » bloqué par la CSP (`frame-src` sans l'origine du service d'agents) | 2.77.1 | [ISSUES_TODOLIST.md](./ISSUES_TODOLIST.md) |
+| BUG-120 | Menu inter-apps — les URL sœurs (`window.DRACO_URLS`) dérivent l'environnement de l'hôte de l'agent (`-dev` en dev), explicite prioritaire, Gitea inchangée (suite de #223) | 2.78.2 | [ISSUES_TODOLIST.md](./ISSUES_TODOLIST.md) |
+| 225 | Panneau Spark — version du service d'agents visible en mode sidebar (pied du panneau, lue en direct via `GET /healthz`) | 2.79.0 | [features/fusion-panneau-version-agent-225.md](./features/fusion-panneau-version-agent-225.md) |
 
 ---
 

docs/features/devprod-urls-config-223.md

@@ -0,0 +1,97 @@
+# #223 — Dev/prod sans noms publics en dur : URLs de l'écosystème par configuration
+
+> Ouvert le 2026-10-25 (chantier dev/prod de Bruno). Contexte : l'installation
+> actuelle (`deepin.lab.home`) devient l'environnement **dev** (noms en `-dev`),
+> la future installation (`jump.point.mint.home`) sera la **prod** (noms
+> officiels sans suffixe), identique sauf noms et clés. Règle : aucun nom
+> public de l'écosystème codé en dur dans le code vivant ; défauts = noms
+> officiels ; le dev déclare ses `-dev` dans son seul `.env`.
+
+## Configuration (nouveau module `backend/draco_config.py`)
+
+Lecture à l'appel, jamais à l'import. Défauts officiels :
+
+| Variable | Défaut officiel | Rôle |
+|---|---|---|
+| `DRACO_AGENT_URL` | `https://agent.dracodev.net` | Base du service d'agents. À défaut : origine dérivée d'`AGENT_EVENEMENTS_URL`, puis défaut. |
+| `DRACO_OBSIGATE_URL` | `https://og.dracodev.net` | Liens profonds ObsiGate |
+| `DRACO_FLOWDECK_URL` | `https://flowdeck.dracodev.net` | Liens profonds Flowdeck |
+| `DRACO_TIKTAK_URL` | `https://tiktak.dracodev.net` | Liens profonds TikTak |
+| `DRACO_KANBANTE_URL` | `https://kanbante.dracodev.net` | Onglet Kanbante de la barre |
+| `DRACO_GITEA_URL` | `https://git.dracodev.net` | Cartes Kanbante (= issues Gitea). Distincte d'`OBSIGATE_GITEA_URL` (source connectée de l'assistant). |
+
+`AGENT_EVENEMENTS_URL` (existant, #220) reste la configuration première du
+journal d'événements ; `agent_journal._url()` retombe sur
+`DRACO_AGENT_URL + /api/v1/evenements` quand elle est absente.
+
+## Backend
+
+- **CSP** (`backend/main.py`, `SecurityHeadersMiddleware`) : `connect-src` et
+  `frame-src` utilisent `draco_config.agent_origine()` — dérivée de la config
+  à chaque réponse, plus aucun littéral. Tests dans
+  `tests/test_security_headers.py` **via la config** (défaut officiel neutralisé,
+  dérivation depuis `AGENT_EVENEMENTS_URL`, priorité `DRACO_AGENT_URL`).
+- **Références croisées** (`backend/external_refs.py`) :
+  - `parse_deep_link` reconnaît les hôtes officiels **et** configurés
+    (`draco_config.hotes_reconnus()`) — un lien collé depuis le dev comme
+    depuis la prod est reconnu.
+  - `build_deep_link(app, type, id)` construit l'URL d'affichage depuis la
+    config ; `list_refs` / `get_ref` / `delete_ref` servent des copies dont
+    `target_url` est **reconstruite à la lecture**. ⚠️ Les références
+    **stockées** (`data/external_refs/*.json`) gardent l'URL absolue collée
+    par l'utilisateur : aucune migration, la valeur stockée n'est simplement
+    plus jamais servie telle quelle.
+- **WebAuthn — confirmé, aucun changement** : `resolve_relying_party()`
+  (`backend/auth/webauthn_mfa.py`, BUG-070) dérive `rp_id`/origines de la
+  requête (hôte exact, `X-Forwarded-Host`/`X-Forwarded-Proto` honorés si
+  `OBSIGATE_TRUST_PROXY=true`), et `OBSIGATE_WEBAUTHN_RP_ID` /
+  `OBSIGATE_WEBAUTHN_ORIGINS` priment quand ils sont posés. Aucun nom figé.
+
+## Frontend (contrat d'injection de dracodev-commons)
+
+L'hôte fournit les URL : `backend/main.py::_index_html()` injecte
+`window.DRACO_URLS = {…}` (JSON issu de `draco_config.urls_publiques()`,
+nonce CSP par le mécanisme existant) dans `index.html` au service.
+
+- `frontend/draco-panneau.js` : `API = window.DRACO_URLS.agent || défaut officiel` ;
+  `appHote()` retire un suffixe `-dev` éventuel du premier label d'hôte
+  (`og-dev` → `obsigate` pour le lien profond `?app=`).
+- `frontend/draco-liens.js` : « Ouvrir dans TikTak » =
+  `window.DRACO_URLS.tiktak || défaut officiel`.
+- `frontend/index.html` : les `href` des onglets portent les défauts officiels ;
+  le script de configuration de la barre les réécrit depuis `DRACO_URLS`.
+  Le menu des apps (`draco-barre.js`) est construit depuis ces onglets : il
+  suit donc sans changement.
+- Chemin réellement servi : `/static/draco-*.js` via le montage `StaticFiles`,
+  `Cache-Control: no-cache` posé par `SecurityHeadersMiddleware` sur
+  `/static/*`, et service worker **network-first** pour le code — aucun
+  cache-busting par empreinte n'existe (revalidation systématique).
+
+## Correctif BUG-120 (2026-10-25) — dérivation d'environnement des sœurs
+
+Constat sur la dev : le `.env` du poste ne déclare que l'agent (via
+`AGENT_EVENEMENTS_URL`) ; les quatre `DRACO_<APP>_URL` absentes
+retombaient sur les défauts prod dans `window.DRACO_URLS` — le menu
+inter-apps pointait la prod depuis la dev. La résolution d'une URL
+sœur (`backend/draco_config.py::app_url`) gagne une étape
+intermédiaire, entre l'explicite et le défaut officiel :
+**dérivation depuis l'hôte de l'agent** (`agent_url()`) — hôte de la
+forme `agent<SUFFIXE>.dracodev.net` sans port → sœur =
+`https://<slug><SUFFIXE>.dracodev.net` (slugs : `og`, `flowdeck`,
+`tiktak`, `kanbante`). Hôte hors motif (autre domaine, LAN, IP,
+port) → aucune dérivation. Gitea exclue. Le dev n'a plus quatre
+variables à déclarer ; un `.env` qui les déclare déjà est inchangé
+(l'explicite prime).
+
+## Restes assumés
+
+- Suffixe SSO `dracodev.net` (`draco_session.validate_return_to`,
+  `frontend/js/auth.js`) : ce n'est pas un nom d'hôte mais le domaine parent
+  commun aux deux environnements (les noms `-dev` restent des sous-domaines) ;
+  le domaine du cookie est déjà configurable (`DRACO_SESSION_COOKIE_DOMAIN`).
+- Mentions textuelles (titres/messages du panneau, contact OpenAPI et lien
+  « À propos » vers le dépôt Git) : infra Git hors périmètre, ou libellés.
+- `OBSIGATE_SEARXNG_URL` : déjà configurable, défaut officiel conservé.
+- Le panneau reste un asset partagé : la même ligne d'injection doit être
+  recopiée dans les 3 autres apps par leurs chantiers respectifs pour
+  retrouver l'octet-identique.

docs/features/fusion-journal-evenements-220.md

@@ -0,0 +1,98 @@
+# #220 — Fusion : émission d'événements vers le journal du service d'agents
+
+**Contexte.** Le Lot 2 du programme Fusion (carte fusion-trois-apps
+#18) dote le service d'agents d'un **journal d'activité** cross-apps :
+chaque application y émet ses mutations significatives au contrat
+**ACC-0.2** — enveloppe `{id, type, occurred_at, actor, domain,
+source_app, object{ref, label, url}}` signée **HMAC-SHA256** du corps
+brut (en-tête `X-Draco-Signature`, clé propre à chaque application),
+que le service expose dans la vue Journal de sa console (agent-commun
+0.11.0). TikTak (0.59.0) et Kanbante (0.28.0) émettent déjà ; ObsiGate
+est la troisième source, après Flowdeck.
+
+**Principe directeur : référence, jamais contenu.** L'enveloppe ne
+contient que la référence de la note (`fichier:<vault>/<chemin>`),
+son nom (libellé) et un lien profond (`/#file=<vault>:<chemin>`) —
+jamais son contenu.
+
+## Garde-fou central : jamais le watcher
+
+ObsiGate surveille les vaults par un **watcher** de système de
+fichiers (`backend/watcher.py`) qui réindexe chaque changement
+disque — le vault principal compte **222 393 fichiers**. Brancher
+l'émission sur le watcher inonderait le journal (et confondrait les
+gestes d'Obsidian, de la synchro de fichiers ou d'un éditeur externe
+avec des opérations faites *dans* ObsiGate).
+
+L'émission n'a donc lieu que pour les **opérations explicites via
+l'API web**, à deux points d'accroche, et nulle part ailleurs :
+
+| Source | Point d'accroche | Acteur |
+|---|---|---|
+| Interface web / clients REST | `backend/routers/files_write.py` | `user` |
+| Serveur MCP d'ObsiGate (outils) | `backend/tools/service.py`, mode `mcp` | `agent:mcp` |
+| Assistant intégré (outils, mode `in_app`) | `backend/tools/service.py` | `user` |
+
+Conséquences assumées :
+
+- une note créée/modifiée **hors API** (Obsidian, éditeur externe,
+  copie de fichiers) n'apparaît **pas** au journal — c'est voulu ;
+- les écritures internes qui passent par la couche mutations sans
+  passer par ces points (planificateur, crawler, fusion de doublons,
+  restauration de sauvegarde) n'émettent pas non plus ;
+- le test `test_watcher_et_indexation_sans_evenement` verrouille le
+  garde-fou : écriture disque directe + gestionnaires du watcher +
+  `update_single_file` de l'indexeur → **zéro émission**.
+
+## Catalogue d'événements émis
+
+| Type | Déclencheur |
+|---|---|
+| `obsigate.note.created` | `POST /api/file/{vault}` ; outil `create_file` |
+| `obsigate.note.edited` | `PUT /api/file/{vault}/save` (+ variantes xlsx/csv : cellules, structure, style) ; outils `edit_file`, `append_to_file` |
+| `obsigate.note.moved` | `PATCH /api/file/{vault}` (renommage), `POST /api/move/{vault}` (**fichiers seulement**) ; outils `rename_file`, `move_path` (fichiers seulement) — la référence pointe sur le **nouveau** chemin |
+| `obsigate.note.deleted` | `DELETE /api/file/{vault}` ; outil `delete_file` |
+
+Hors catalogue (non émis, volontairement) : dossiers (création,
+renommage, déplacement, suppression — le catalogue est `note.*`),
+téléversement par lots (`batch-upload`), duplication, restauration
+de sauvegarde, `replace_in_files` (multi-fichiers).
+
+## Module `backend/agent_journal.py`
+
+- **Activation** : `AGENT_EVENEMENTS_CLE` (clé propre à ObsiGate,
+  jamais en dur). Sans clé, le module est **inactif** : aucun appel,
+  aucun bruit. URL surchargée par `AGENT_EVENEMENTS_URL` (défaut
+  `https://agent.dracodev.net/api/v1/evenements`).
+- **Discipline « au mieux »** (identique à TikTak/Kanbante) : envoi
+  dans un fil d'arrière-plan démon via httpx, délai maximal 2 s,
+  exceptions avalées avec une ligne de journal local — une panne du
+  service d'agents ne casse ni ne ralentit jamais le métier (prouvé
+  par `test_recepteur_en_panne_ne_casse_rien`).
+- **Domaine** : ObsiGate ne modélise pas encore le domaine d'un
+  vault (la question Q-A du programme — les domaines sont-ils des
+  vaults distincts ? — est toujours ouverte). La correspondance peut
+  être déclarée par `AGENT_EVENEMENTS_DOMAINES` (JSON
+  `{"NomDuVault": "famille"}`) ; repli `pro`, qui est aussi le
+  défaut du journal du service.
+
+## Activation en production (gestes de Bruno)
+
+1. Générer une clé propre à ObsiGate (`openssl rand -hex 32`).
+2. Service d'agents : ajouter l'entrée `obsigate` à
+   `AGENT_EVENEMENTS_CLES` (JSON des clés par application), recréer
+   le conteneur.
+3. ObsiGate : poser `AGENT_EVENEMENTS_CLE=<même valeur>` dans son
+   environnement et **redéployer** (Docker).
+
+Tant que la clé n'est pas posée des deux côtés, ObsiGate n'émet
+rien — c'est le comportement voulu.
+
+## Tests
+
+`tests/test_agent_journal.py` (7 tests) : enveloppe et signature
+revérifiées comme le fait le service ; cycle de vie complet en REST
+(créer → éditer → renommer → déplacer → supprimer, acteur `user`) ;
+chemin outils/MCP (`create/edit/rename/delete`, acteur
+`agent:mcp`) ; inactivité sans clé ; garde-fou watcher/indexation ;
+panne du récepteur sans effet métier ; correspondance de domaines.

docs/features/fusion-panneau-console-221.md

@@ -0,0 +1,42 @@
+# #221 — Fusion : bouton « Console ↗ » dans le panneau Spark
+
+**Contexte.** Le panneau Spark (#218) et la console web du service
+d'agents (Lot 2, https://agent.dracodev.net/) sont deux faces du même
+service : mêmes discussions, mêmes approbations, mêmes missions. Il
+manquait le lien de navigation entre les deux. Demande de Bruno
+(2026-10-22) : un bouton dans le panneau qui ouvre la console.
+
+**Changement.** Dans `frontend/draco-panneau.js` — asset **vendangé**,
+maintenu en canonique dans TikTak et recopié **octet-identique** dans
+les 4 applications (TikTak, Flowdeck, Kanbante, ObsiGate) :
+
+- un bouton fantôme « Console ↗ » dans la barre des discussions, à
+  côté de « ☰ Discussions » et « ＋ Nouvelle » (même classe `d-btn`,
+  donc visible en thème clair comme sombre, le panneau suivant le
+  thème de l'app hôte) ;
+- au clic, `ouvrirConsole()` construit l'URL **à ce moment-là** (la
+  discussion peut avoir changé sans recharger le panneau) :
+  `https://agent.dracodev.net/?disc=<id de la discussion affichée>&app=<app hôte>` ;
+- la discussion vient de l'état du panneau (`convId`, repli
+  `sessionStorage draco_panneau_conv`) ; l'app hôte est déduite du
+  sous-domaine par `appHote()` (`og` → `obsigate`, `tiktak`,
+  `flowdeck`, `kanbante` ; hôte inconnu → pas de paramètre) ;
+- ouverture en **nouvel onglet** (`window.open(..., "_blank",
+  "noopener")`). Sans discussion connue : lien simple vers la
+  racine de la console.
+
+La console consomme déjà les deux paramètres : `?disc=` ouvre la
+discussion demandée (lien profond), `?app=` s'affiche en puce
+« Ouvert depuis : … » dans « Ce que Spark voit ».
+
+**Vérifications.** Syntaxe JS (`node --check`), test fonctionnel de
+la construction d'URL (4 cas : app connue/inconnue × discussion
+présente/absente), test de non-régression
+`tests/test_draco_barre.py::test_panneau_bouton_console_221`
+(marqueurs du bouton et de la logique dans l'asset servi), somme
+md5 commune des 4 copies : `c67cc2ab8e657b4e545fa93b28c3a0c4`.
+
+**Versions.** ObsiGate 2.76.1 (cette livraison) ; TikTak 0.59.1 et
+Flowdeck 7.80.1 déployées automatiquement sur release ; Kanbante
+0.28.1 publiée. **Activation côté ObsiGate : redéploiement Docker
+par Bruno.**

docs/features/fusion-panneau-console-surimpression-222.md

@@ -0,0 +1,52 @@
+# #222 — Fusion : panneau Spark V3, la console en surimpression pleine page
+
+**Contexte.** Le bouton « Console ↗ » du panneau Spark (#221) ouvrait
+la console web du service d'agents (https://agent.dracodev.net/)
+dans un nouvel onglet : on quittait l'application en cours pour un
+autre onglet. Demande de Bruno (2026-10-22) : rester dans la même
+page — la console s'ouvre par-dessus l'application, avec une
+animation comme celle de la barre latérale mais qui recouvre la
+page au complet, et deux sorties explicites : revenir en mode
+sidebar, ou fermer l'agent.
+
+**Changement.** Dans `frontend/draco-panneau.js` — asset **vendangé**,
+maintenu en canonique dans TikTak et recopié **octet-identique** dans
+les 4 applications (TikTak, Flowdeck, Kanbante, ObsiGate) :
+
+- le bouton devient « Console ⤢ » (même emplacement, barre des
+  discussions) et `ouvrirConsole()` n'ouvre plus d'onglet : il
+  monte une **surimpression** `.draco-console-sur` ancrée à droite,
+  née à la largeur du panneau, qui **s'étend à 100 % de la fenêtre**
+  par transition CSS (double `requestAnimationFrame` pour laisser
+  peindre la géométrie de départ) ;
+- la console est chargée dans une **iframe** dont l'URL reste
+  construite au premier clic par `urlConsole()` : discussion
+  affichée (`?disc=<id>`) et app d'origine (`?app=obsigate`, déduite
+  du sous-domaine `og`) — le lien profond de #221 est conservé ;
+- la barre de la surimpression (« ✦ Console Spark ») porte les deux
+  sorties demandées : **« ◧ Mode sidebar »** (`retrecirConsole()` :
+  l'overlay se rétracte à la largeur du panneau puis se masque,
+  l'iframe reste chargée) et **« ✕ Fermer l'agent »** (`fermer()` +
+  rétraction : panneau et console fermés) ;
+- les styles de la surimpression sont **injectés par le panneau
+  lui-même** (`<style id="draco-console-styles">`, variables du
+  thème du panneau) : aucun fichier CSS à toucher côté hôte, et la
+  surimpression suit le thème de l'app comme le panneau.
+
+Côté service d'agents (0.20.0) : la console autorise désormais
+l'encadrement par les 4 applications (`frame-ancestors` restreint
+aux sous-domaines `dracodev.net` des apps) — sans quoi l'iframe
+resterait blanche.
+
+**Vérifications.** Syntaxe JS (`node --check`) ; test
+`tests/test_draco_barre.py::test_panneau_console_surimpression_222`
+(marqueurs de la surimpression, des deux sorties et de l'animation
+dans l'asset) ; le test #221 est révisé en conséquence (le lien
+profond `?disc=` / `?app=` subsiste, l'ouverture en nouvel onglet
+disparaît) ; somme md5 commune des copies :
+`93026ffa14bc8ee896349e3858e12edf`.
+
+**Versions.** ObsiGate 2.77.0 (cette livraison) ; TikTak 0.60.0 et
+Flowdeck 7.81.0 déployées automatiquement sur release ; Kanbante
+0.29.0 publiée. **Activation côté ObsiGate : redéploiement Docker
+par Bruno.**

docs/features/fusion-panneau-spark-218.md

@@ -0,0 +1,38 @@
+# #218 — Fusion : panneau Spark intégré (agent commun)
+
+**Contexte.** Le programme Fusion a livré le service d'agents commun
+(agent-commun : conversation LLM, lectures/écritures des quatre
+applications via approbations, sous-agents, missions longues). Trois
+applications affichaient déjà son panneau partagé (TikTak, Flowdeck,
+Kanbante) ; ObsiGate, pourtant émettrice de l'identité `draco_session`,
+gardait le message d'attente « arrive en phase 4 » sur le bouton Spark
+de sa barre commune (#215).
+
+**Livraison.**
+
+- Assets vendangés à l'identique des autres applications :
+  `frontend/draco-panneau.js` et `frontend/draco-panneau.css`, à la
+  racine de `frontend/` comme les autres assets draco (servis par le
+  montage `/static`, `Cache-Control: no-cache` déjà en place — aucun
+  mécanisme de versionnage à ajouter, `index.html` n'est pas un
+  gabarit Jinja).
+- `frontend/index.html` : lien CSS après celui de la barre, script
+  différé après `draco-liens.js`, action `spark` de
+  `DRACO_BAR_CONFIG.onAction` branchée sur
+  `window.DRACO_PANNEAU.toggle()` avec repli explicite si l'asset ne
+  charge pas.
+- CSP (`backend/main.py`, `SecurityHeadersMiddleware`) :
+  `https://agent.dracodev.net` ajouté à `connect-src` — le panneau
+  appelle le service en `fetch` avec le cookie de session ; aucun
+  autre hôte n'est ouvert (précédent : Flowdeck, même exception).
+
+**Vérifications.** Tests `tests/test_draco_barre.py` étendus
+(présence et références des assets, branche spark, hôte CSP) ;
+vérification visuelle et E2E à confirmer après redéploiement Docker
+(le panneau, `z-index: 400`, cohabite avec des surfaces ObsiGate à
+z-index plus élevé — à observer en réel).
+
+**Hors périmètre.** Les textes du panneau vivent dans l'asset partagé
+du programme (français, identique dans les quatre applications) ; ils
+ne passent pas par les locales FR/EN d'ObsiGate — écart assumé au
+niveau du programme, pas de cette fiche.

docs/features/fusion-panneau-spark-v2-219.md

@@ -0,0 +1,29 @@
+# #219 — Fusion : panneau Spark v2 (Lot 1)
+
+**Contexte.** Le panneau Spark livré en 2.74.0 (#218) affichait les
+réponses de l'agent en texte brut (les `##` et `**` du Markdown
+restaient visibles), avait une largeur fixe, un thème clair codé en
+dur déconnecté de l'application hôte, et une seule conversation sans
+gestion. Le Lot 1 du « Panneau v2 » (carte fusion-trois-apps #17,
+arbitrage de Bruno du 2026-10-22) corrige ces quatre points, à
+l'identique dans les quatre applications du programme.
+
+**Livraison (côté ObsiGate : assets vendangés uniquement).**
+
+- `frontend/draco-panneau.js` / `frontend/draco-panneau.css`
+  remplacés par la v2 partagée (octet pour octet avec TikTak,
+  Flowdeck et Kanbante) :
+  - **Markdown rendu** : les réponses et les rapports de missions
+    affichent le HTML produit par le service d'agents (0.10.0 :
+    mistune + sanitizer côté serveur) ;
+  - **largeur réglable** à la souris (poignée, persistée,
+    double-clic = largeur par défaut) ;
+  - **thème clair/sombre aligné** sur l'application hôte
+    (`html[data-theme]`, ici celui d'ObsiGate, suivi en direct) ;
+  - **discussions façon Muse** : discussion principale
+    perpétuelle + discussions parallèles créées, archivées et
+    supprimées depuis le tiroir du panneau.
+- Le travail de fond est dans le service d'agents (agent-commun
+  0.10.0) ; ObsiGate ne change aucun code propre. Le `/static` est
+  déjà servi en `Cache-Control: no-cache` : aucun versionnage
+  d'asset à ajouter. Redéploiement Docker requis.

docs/features/fusion-panneau-version-agent-225.md

@@ -0,0 +1,40 @@
+# #225 — Fusion : panneau Spark, version du service d'agents visible en mode sidebar
+
+**Contexte.** La version « Service d'agents vX » du service d'agents
+est visible dans la console pleine page (pilule d'en-tête, rendue par
+le service lui-même), mais pas dans le **panneau natif des
+applications** (mode sidebar) — or c'est là que Bruno vit au
+quotidien. Demande de Bruno (2026-10-26), carte fusion #64 : la
+version doit se lire dans le panneau ouvert, sans ouvrir la console.
+
+**Changement.** Dans `frontend/draco-panneau.js` — asset **vendangé**,
+maintenu en canonique dans TikTak et recopié dans les 4 applications
+(TikTak, Flowdeck, Kanbante, ObsiGate ; chaque copie garde son bloc
+d'injection d'origine propre à l'hôte, le corps est commun) :
+
+- le pied du panneau gagne une ligne dédiée
+  `.draco-panneau-version`, discrète (11,5 px, opacité 0,6,
+  monochrome, aucun emoji), **masquée tant qu'aucune version n'est
+  connue** ;
+- à l'ouverture du panneau, `chargerVersion()` interroge la santé
+  du service — `GET /healthz` de l'origine que le panneau connaît
+  déjà (celle injectée par l'hôte, ici `window.DRACO_URLS.agent`) —
+  et affiche « Service d'agents vX » depuis le champ `version` de
+  la réponse (la même source que la pilule de la console) ;
+- cache de session de 5 minutes, rafraîchissement au rythme des
+  ouvertures du panneau (comme la vérification d'identité) ;
+- **jamais de valeur codée en dur** : réponse illisible ou service
+  injoignable = la ligne reste masquée — pas de fausse version, pas
+  d'erreur visible.
+
+**Preuve.** Épreuve comportementale (jsdom) exécutée sur les 4
+copies avec le contrat d'injection de chaque hôte : santé joignable
+→ la ligne affiche « Service d'agents v0.38.0 » (version lue sur
+l'origine de l'agent) ; santé injoignable → rien d'affiché ; hôte
+sans injection → aucun appel. Test de garde :
+`tests/test_draco_barre.py::test_panneau_version_service_affichee_225`.
+
+**Même livraison** (carte fusion #64) : TikTak 0.61.3, Flowdeck
+7.83.1, Kanbante 0.37.1. Côté ObsiGate, la prise d'effet attend le
+**redéploiement Docker** (geste de Bruno), comme les items panneau
+précédents.

docs/features/securite-dependances-pip-audit-224.md

@@ -0,0 +1,94 @@
+# #224 — Sécurité des dépendances : pip-audit vierge (brotli, filelock, opentelemetry-api, pypdf)
+
+> Ouvert le 2026-10-25. Déclencheur : le job `security` du run CI 2303
+> (commit `f29a228`, version 2.78.0) échoue sur `pip-audit` (bloquant,
+> #87) — **17 vulnérabilités connues dans 4 paquets**. Le job `lint`
+> du même run est vert ; `security` est le seul job terminé en échec
+> au moment du constat (`test` en file, `build`/`e2e` en attente).
+
+## Constat (journal du job `security`, run 2303)
+
+| Paquet | Version auditée | Vulnérabilités | Corrigée en |
+|---|---|---|---|
+| brotli | 1.2.0 | PYSEC-2026-4322, GHSA-9v8h-qqgm-4m35 | 1.2.1 |
+| filelock | 3.32.3 | CVE-2026-112940, CVE-2026-112913, CVE-2026-112907 | 4.2.1 |
+| opentelemetry-api | 1.37.0 | CVE-2026-114603 | 1.45.1 |
+| pypdf | 6.19.0 | CVE-2026-113792, CVE-2026-113795, CVE-2026-113793, CVE-2026-113794, CVE-2026-113786, CVE-2026-113791, CVE-2026-113790, CVE-2026-113789, CVE-2026-115572, CVE-2026-115585, CVE-2026-115580 | 6.20.0 → 6.21.2 selon l'advisory (max 6.21.2) |
+
+Total : 2 + 3 + 1 + 11 = **17 vulnérabilités**.
+
+Audit local de confirmation, en deux temps : (1) un venv épinglé sur
+les versions du runner (brotli 1.2.0, filelock 3.32.3,
+opentelemetry-api 1.37.0, pypdf 6.19.0) reproduit **exactement** les
+17 vulnérabilités et les versions corrigées du tableau ci-dessus ;
+(2) dans le venv du dépôt, `pip-audit` (avec les deux ignores déjà en
+place dans la CI) ne ressortait avant correctif que brotli 1.2.0
+(2 advisories, fix 1.2.1) et pypdf 6.21.1 (3 advisories restants,
+fix 6.21.2) — ce venv a déjà filelock 4.2.4 (corrigée) et ne contient
+pas opentelemetry-api. L'écart avec la CI vient de l'environnement
+audité, pas des dépendances déclarées (voir cause).
+
+## Cause racine
+
+Même piège que BUG-093 / BUG-095, déjà documenté dans
+`backend/requirements.txt` et `.gitea/workflows/ci.yml` : `pip-audit`
+audite **tout l'environnement Python du runner**, dont les paquets
+préinstallés dans la toolcache de l'image `catthehacker/ubuntu:act-latest`.
+`pip install -r backend/requirements.txt` répond « already satisfied »
+pour toute exigence transitive déjà satisfaite par la toolcache et
+n'aligne jamais la version vulnérable :
+
+- **pypdf 6.19.0** : préinstallée ; le plancher `>=6.16.1` (BUG-093)
+  est satisfait, pip ne monte pas vers 6.21.2.
+- **brotli 1.2.0** : transitive de `fonttools[woff]` (via weasyprint),
+  exigée en `>=1.0.1` seulement.
+- **filelock 3.32.3** : transitive de CacheControl (outil `pip-audit`
+  lui-même) et préinstallée ; exigée en `>=3.8.0` seulement.
+- **opentelemetry-api 1.37.0** : préinstallée dans la toolcache,
+  aucune dépendance d'ObsiGate ne la demande.
+
+## Correctif
+
+Planchers de sécurité explicites dans `backend/requirements.txt`,
+selon le patron déjà en place (pyjwt, urllib3, multidict, certifi) —
+aucune autre dépendance touchée, aucun code applicatif modifié :
+
+- `pypdf>=6.16.1` → **`pypdf>=6.21.2`** (plancher existant relevé) ;
+- **`brotli>=1.2.1`** (nouveau plancher) ;
+- **`filelock>=4.2.1`** (nouveau plancher) ;
+- **`opentelemetry-api>=1.45.1`** (nouveau plancher).
+
+Garde-fou : `tests/test_ci_workflow.py::TestDependencySecurityFloors`
+couvre désormais aussi brotli, filelock et opentelemetry-api, et le
+plancher verrouillé de pypdf passe à (6, 21, 2). Le commentaire de
+l'étape Pip-audit de `.gitea/workflows/ci.yml` est mis à jour en
+conséquence (aucune commande CI modifiée).
+
+## Exceptions (ignores)
+
+**Aucun nouvel ignore.** Les deux exceptions déjà en place dans la
+CI restent inchangées et ne concernent pas ces paquets :
+`PYSEC-2026-1325` (ecdsa, aucun correctif upstream, chemins ECDSA
+jamais exécutés — HS256 uniquement) et `CVE-2026-85394`
+(python-jose, aucun correctif upstream, non atteignable — voir le
+commentaire de l'étape dans `ci.yml`).
+
+## Vérification
+
+- `pip-audit` local (mêmes ignores que la CI) après alignement de
+  l'environnement sur les nouveaux planchers : **0 vulnérabilité
+  non ignorée**.
+- Portes locales du workflow : `pytest tests/`, `ruff check backend/`,
+  `mypy backend/ --ignore-missing-imports`, tests frontend
+  (`validate-imports` + `unit`) — voir le commit #224.
+- CI Gitea complète verte exigée (lint, test, security, build, e2e)
+  avant de considérer #224 livré.
+
+## Livraison
+
+- Commit conventionnel `fix: … #224` ; le hook de version porte
+  2.78.0 → **2.78.1** (correctif) et crée le tag `v2.78.1`, publié
+  au push ; release Gitea créée sur ce tag après vérification de sa
+  cible.
+- **Redéploiement Docker requis** pour que l'image embarque les
+  dépendances alignées (l'hôte actuel est l'environnement dev).

frontend/admin.html

@@ -19,8 +19,8 @@
                 var mode = localStorage.getItem("obsigate-theme-mode") || "dark";
                 root.setAttribute("data-theme", mode);
                 var light = mode === "light" || mode === "sepia";
-                root.style.setProperty("--bg-primary", light ? "#ffffff" : "#0f1117");
-                root.style.setProperty("--text-primary", light ? "#1a1a1a" : "#e6edf3");
+                root.style.setProperty("--bg-primary", light ? "#fbfbfa" : "#17181a");
+                root.style.setProperty("--text-primary", light ? "#242624" : "#eceeeb");
             } catch (e) { root.setAttribute("data-theme", "dark"); }
         })();
     </script>
@@ -41,8 +41,8 @@
             min-height: 100vh;
             overflow: auto;       /* override SPA style.css: body{overflow:hidden} */
             height: auto;         /* override SPA style.css: body{height:100vh}  */
-            background: var(--bg-primary, #0f1117);
-            color: var(--text-primary, #e6edf3);
+            background: var(--bg-primary, #17181a);
+            color: var(--text-primary, #eceeeb);
             font-family: "Segoe UI", system-ui, -apple-system, sans-serif;
         }
 

frontend/draco-liens.js

@@ -23,6 +23,12 @@
     kanbante: "#0d9488",
   };
 
+  /* Base TikTak fournie par l'hôte via window.DRACO_URLS (contrat
+   * d'injection dracodev-commons, #223) ; repli = défaut officiel. */
+  function baseTikTak() {
+    return (window.DRACO_URLS && window.DRACO_URLS.tiktak) || "https://tiktak.dracodev.net";
+  }
+
   function t(key, fallback) {
     try {
       var v = window.t && window.t(key);
@@ -92,7 +98,7 @@
             t("draco.links.projected", "Tâche TikTak projetée")));
           var ouvrir = el("a", "btn-action draco-liens-ouvrir",
             t("draco.links.openInTikTak", "Ouvrir dans TikTak"));
-          ouvrir.href = "https://tiktak.dracodev.net/?task=" + tid[1];
+          ouvrir.href = baseTikTak() + "/?task=" + tid[1];
           ouvrir.target = "_blank";
           ouvrir.rel = "noopener";
           bandeau.appendChild(ouvrir);

frontend/draco-panneau.css

@@ -0,0 +1,189 @@
+/* Panneau Spark — service d'agents (Fusion, J1 → Panneau v2 Lot 1).
+   Thème clair/sombre piloté par [data-draco-theme] sur le panneau :
+   le JS le cale sur le thème de l'app hôte (html[data-theme], repli
+   prefers-color-scheme) et suit les bascules en direct. Toutes les
+   couleurs passent par les variables ci-dessous — en-tête et fenêtre
+   partagent donc toujours le même mode. */
+.draco-panneau {
+  --p-fond: #fbfbfa; --p-surface: #ffffff; --p-bord: #e4e5e0;
+  --p-texte: #242624; --p-doux: #6c7268; --p-faint: #8a8f84;
+  --p-chip: #f4f5f1; --p-chip-bord: #d6d8d1; --p-chip-survol: #e9ebe4;
+  --p-agent: #eef0ea; --p-champ: #ffffff; --p-code: #e8eae3;
+  --p-appro-fond: #fdf6ec; --p-danger-fond: #f6e3de; --p-danger: #a03a28;
+  --p-accent: #7c5cd6; --p-lien: #5b3df0;
+  position: fixed; top: 0; right: 0; height: 100dvh; width: 388px; max-width: 96vw;
+  background: var(--p-fond); color: var(--p-texte); z-index: 400;
+  box-shadow: -12px 0 36px rgb(0 0 0 / .22);
+  display: flex; flex-direction: column;
+  transform: translateX(105%); transition: transform .28s ease;
+  font: 14px/1.5 system-ui, "Segoe UI", sans-serif;
+}
+.draco-panneau[data-draco-theme="dark"] {
+  --p-fond: #17181a; --p-surface: #1f2023; --p-bord: #33353a;
+  --p-texte: #eceeeb; --p-doux: #a6aba0; --p-faint: #83887e;
+  --p-chip: #26272b; --p-chip-bord: #3a3c41; --p-chip-survol: #2e3036;
+  --p-agent: #26272b; --p-champ: #1f2023; --p-code: #2c2e33;
+  --p-appro-fond: #2a2118; --p-danger-fond: #40241f; --p-danger: #e8a08d;
+  --p-lien: #b39df5;
+}
+.draco-panneau.open { transform: translateX(0); }
+.draco-poignee {
+  position: absolute; left: 0; top: 0; bottom: 0; width: 8px;
+  cursor: ew-resize; z-index: 5; touch-action: none;
+}
+.draco-poignee:hover { background: color-mix(in srgb, var(--p-accent) 35%, transparent); }
+@media (max-width: 700px) { .draco-poignee { display: none; } }
+.draco-panneau-hd {
+  display: flex; align-items: center; gap: 9px;
+  padding: 13px 15px; border-bottom: 1px solid var(--p-bord); background: var(--p-surface);
+}
+.draco-panneau-hd .titre { font-weight: 700; font-size: 15px; }
+.draco-panneau-hd .soustitre { font-size: 12px; color: var(--p-doux); }
+.draco-panneau-hd .fermer {
+  margin-left: auto; border: 0; background: var(--p-agent); color: var(--p-texte);
+  border-radius: 8px; width: 30px; height: 30px; cursor: pointer; font-size: 14px;
+}
+.draco-panneau-etat { display: flex; align-items: center; gap: 7px; font-size: 12.5px; }
+.draco-panneau-etat .point { width: 9px; height: 9px; border-radius: 50%; background: #b9bdb2; flex: none; }
+.draco-panneau-etat.ok .point { background: #2ea36b; }
+.draco-panneau-etat.err .point { background: #cf4b32; }
+/* Barre des discussions (façon Muse) */
+.draco-disc-bar {
+  display: flex; align-items: center; gap: 7px;
+  padding: 8px 15px; border-bottom: 1px solid var(--p-bord); background: var(--p-surface);
+}
+.draco-disc-bar .d-titre {
+  flex: 1; font-weight: 600; font-size: 13px; min-width: 0;
+  white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+}
+.draco-disc-bar .d-btn {
+  border: 1px solid var(--p-chip-bord); background: var(--p-chip); color: var(--p-texte);
+  border-radius: 999px; padding: 4px 10px; font: 600 12px system-ui; cursor: pointer; flex: none;
+}
+.draco-disc-bar .d-btn:hover { background: var(--p-chip-survol); }
+.draco-discussions {
+  border-bottom: 1px solid var(--p-bord); background: var(--p-surface);
+  max-height: 46%; overflow-y: auto; padding: 8px 12px;
+}
+.draco-discussions .d-section {
+  font-size: 11px; font-weight: 700; text-transform: uppercase;
+  letter-spacing: .5px; color: var(--p-doux); margin: 8px 2px 4px;
+}
+.draco-discussions .d-section:first-child { margin-top: 0; }
+.draco-discussions .d-item {
+  border: 1px solid transparent; border-radius: 9px; padding: 6px 8px; cursor: pointer;
+}
+.draco-discussions .d-item:hover { background: var(--p-chip); }
+.draco-discussions .d-item.actif { border-color: var(--p-accent); background: var(--p-chip); }
+.draco-discussions .d-meta { font-weight: 600; font-size: 13px; }
+.draco-discussions .d-sous { font-size: 12px; color: var(--p-doux); }
+.draco-discussions .d-actions { display: flex; gap: 6px; margin-top: 5px; }
+.draco-discussions .d-actions button {
+  border: 1px solid var(--p-chip-bord); background: var(--p-surface); color: var(--p-texte);
+  border-radius: 7px; padding: 3px 9px; font: 600 11.5px system-ui; cursor: pointer;
+}
+.draco-discussions .d-actions button.danger { color: var(--p-danger); border-color: var(--p-danger-fond); }
+.draco-discussions .d-vide, .draco-discussions .d-chargement {
+  font-size: 12.5px; color: var(--p-doux); padding: 2px 8px 6px;
+}
+.draco-panneau-outils { display: flex; gap: 8px; padding: 9px 15px; border-bottom: 1px solid var(--p-bord); background: var(--p-surface); }
+.draco-panneau-outils button {
+  border: 1px solid var(--p-chip-bord); background: var(--p-chip); color: var(--p-texte);
+  border-radius: 999px; padding: 5px 12px; font: 600 12.5px system-ui; cursor: pointer;
+}
+.draco-panneau-outils button:hover { background: var(--p-chip-survol); }
+.draco-appro {
+  align-self: stretch; background: var(--p-appro-fond); border: 1.6px solid #e8a13c;
+  border-radius: 12px; padding: 10px 12px;
+}
+.draco-appro .titre { font-weight: 700; font-size: 12px; color: #9a6a1c; text-transform: uppercase; letter-spacing: .4px; }
+.draco-panneau[data-draco-theme="dark"] .draco-appro .titre { color: #e8bc7a; }
+.draco-appro .resume { margin: 5px 0 8px; }
+.draco-appro .btns { display: flex; gap: 7px; }
+.draco-appro .btns button { border: 0; border-radius: 8px; padding: 6px 11px; font: 600 12.5px system-ui; cursor: pointer; background: var(--p-agent); color: var(--p-texte); }
+.draco-appro .btns button.go { background: #2ea36b; color: #fff; }
+.draco-auj { align-self: stretch; background: var(--p-surface); border: 1px solid var(--p-bord); border-radius: 12px; padding: 10px 12px; }
+.draco-auj h5 { font-size: 12px; text-transform: uppercase; letter-spacing: .4px; color: var(--p-doux); margin: 6px 0 4px; }
+.draco-auj h5:first-child { margin-top: 0; }
+.draco-auj ul { margin: 0; padding-left: 17px; }
+.draco-auj .etat-source { color: var(--p-doux); font-size: 12.5px; }
+.draco-panneau-msgs { flex: 1; overflow-y: auto; padding: 14px 15px; display: flex; flex-direction: column; gap: 9px; }
+.draco-msg { max-width: 88%; padding: 9px 12px; border-radius: 13px; white-space: pre-wrap; word-wrap: break-word; }
+.draco-msg.user { align-self: flex-end; background: #2f6fed; color: #fff; border-bottom-right-radius: 4px; }
+.draco-msg.agent { align-self: flex-start; background: var(--p-agent); border-bottom-left-radius: 4px; }
+.draco-msg.sys { align-self: center; background: none; color: var(--p-doux); font-size: 12.5px; text-align: center; max-width: 96%; }
+.draco-panneau-ft { border-top: 1px solid var(--p-bord); padding: 11px 12px; background: var(--p-surface); }
+.draco-panneau-form { display: flex; gap: 8px; }
+.draco-panneau-form input {
+  flex: 1; border: 1px solid var(--p-chip-bord); border-radius: 10px; padding: 9px 11px;
+  font: inherit; background: var(--p-champ); color: var(--p-texte);
+}
+.draco-panneau-form button {
+  border: 0; border-radius: 10px; background: var(--p-accent); color: #fff;
+  padding: 9px 14px; font: inherit; font-weight: 600; cursor: pointer;
+}
+.draco-panneau-form button:disabled { opacity: .5; cursor: default; }
+.draco-panneau-note { font-size: 11.5px; color: var(--p-faint); margin-top: 8px; text-align: center; }
+.draco-missions { align-self: stretch; background: var(--p-surface); border: 1px solid var(--p-bord); border-radius: 12px; padding: 10px 12px; }
+.draco-missions h5 { font-size: 12px; text-transform: uppercase; letter-spacing: .4px; color: var(--p-doux); margin: 0 0 6px; }
+.draco-missions label { display: block; font-size: 12px; font-weight: 600; color: var(--p-doux); margin: 8px 0 3px; }
+.draco-missions select, .draco-missions input, .draco-missions textarea {
+  width: 100%; box-sizing: border-box; border: 1px solid var(--p-chip-bord); border-radius: 8px;
+  padding: 7px 9px; font: inherit; font-size: 13px; background: var(--p-champ); color: var(--p-texte);
+}
+.draco-missions .btns { display: flex; gap: 7px; margin-top: 10px; }
+.draco-missions .btns button { border: 0; border-radius: 8px; padding: 6px 11px; font: 600 12.5px system-ui; cursor: pointer; background: var(--p-agent); color: var(--p-texte); }
+.draco-missions .btns button.go { background: var(--p-accent); color: #fff; }
+.draco-missions .m-liste { margin-top: 12px; display: flex; flex-direction: column; gap: 8px; }
+.draco-missions .etat-source { color: var(--p-doux); font-size: 12.5px; }
+.draco-missions .m-item { border: 1px solid var(--p-bord); border-radius: 10px; padding: 8px 10px; }
+.draco-missions .m-entete { display: flex; justify-content: space-between; gap: 8px; align-items: baseline; }
+.draco-missions .m-statut { font-size: 11.5px; font-weight: 700; color: var(--p-doux); white-space: nowrap; }
+.draco-missions .m-statut.st-succeeded { color: #2ea36b; }
+.draco-missions .m-statut.st-failed { color: #cf4b32; }
+.draco-missions .m-statut.st-running, .draco-missions .m-statut.st-paused_question { color: #9a6a1c; }
+.draco-missions .m-meta { font-size: 12px; color: var(--p-doux); }
+.draco-missions .m-rapport { font-size: 12.5px; margin-top: 5px; white-space: pre-wrap; word-wrap: break-word; }
+.draco-missions .m-annuler { margin-top: 6px; border: 0; border-radius: 7px; padding: 4px 9px; font: 600 12px system-ui; cursor: pointer; background: var(--p-danger-fond); color: var(--p-danger); }
+/* ── Rendu Markdown (HTML produit par le service) ──────────── */
+.draco-msg.md, .draco-missions .m-rapport.md { white-space: normal; }
+.draco-msg.md > *:first-child, .m-rapport.md > *:first-child { margin-top: 0; }
+.draco-msg.md > *:last-child, .m-rapport.md > *:last-child { margin-bottom: 0; }
+.draco-msg.md p, .m-rapport.md p { margin: 6px 0; }
+.draco-msg.md h1, .draco-msg.md h2, .draco-msg.md h3,
+.draco-msg.md h4, .draco-msg.md h5, .draco-msg.md h6 { margin: 10px 0 4px; line-height: 1.3; }
+.draco-msg.md h1 { font-size: 16.5px; } .draco-msg.md h2 { font-size: 15.5px; }
+.draco-msg.md h3 { font-size: 14.5px; } .draco-msg.md h4,
+.draco-msg.md h5, .draco-msg.md h6 { font-size: 13.5px; }
+.draco-msg.md ul, .draco-msg.md ol, .m-rapport.md ul, .m-rapport.md ol { margin: 6px 0; padding-left: 20px; }
+.draco-msg.md li, .m-rapport.md li { margin: 2px 0; }
+.draco-msg.md code, .m-rapport.md code {
+  background: var(--p-code); border-radius: 5px; padding: 1px 5px;
+  font: 12.5px ui-monospace, "Cascadia Mono", Consolas, monospace;
+}
+.draco-msg.md pre, .m-rapport.md pre {
+  background: var(--p-code); border-radius: 9px; padding: 9px 11px;
+  overflow-x: auto; margin: 7px 0;
+}
+.draco-msg.md pre code, .m-rapport.md pre code { background: none; padding: 0; }
+.draco-msg.md blockquote, .m-rapport.md blockquote {
+  border-left: 3px solid var(--p-accent); margin: 7px 0; padding: 2px 0 2px 11px;
+  color: var(--p-doux);
+}
+.draco-msg.md blockquote.callout, .m-rapport.md blockquote.callout {
+  border-radius: 0 8px 8px 0; padding: 6px 11px; color: var(--p-texte);
+  background: var(--p-chip);
+}
+.draco-msg.md blockquote.callout-warning { border-left-color: #e8a13c; }
+.draco-msg.md blockquote.callout-danger { border-left-color: #cf4b32; }
+.draco-msg.md blockquote.callout-tip { border-left-color: #2ea36b; }
+.draco-msg.md a, .m-rapport.md a { color: var(--p-lien); }
+.draco-msg.md table, .m-rapport.md table {
+  border-collapse: collapse; margin: 7px 0; font-size: 12.5px;
+  display: block; overflow-x: auto; max-width: 100%;
+}
+.draco-msg.md th, .draco-msg.md td, .m-rapport.md th, .m-rapport.md td {
+  border: 1px solid var(--p-bord); padding: 4px 8px; text-align: left;
+}
+.draco-msg.md hr, .m-rapport.md hr { border: 0; border-top: 1px solid var(--p-bord); margin: 9px 0; }
+.draco-msg.md input[type="checkbox"], .m-rapport.md input[type="checkbox"] { margin-right: 5px; }

frontend/draco-panneau.js

@@ -0,0 +1,854 @@
+/* Panneau Spark — branchement au service d'agents (Fusion, J1 → Panneau v2).
+ *
+ * Parle à l'API du service d'agents (contrat de dracodev-commons) :
+ *   GET  /api/v1/me               — identité (cookie draco_session)
+ *   POST /api/v1/chat             — conversation réelle du noyau (J2) :
+ *                                   LLM DeepSeek + outils MCP des apps ;
+ *                                   la réponse arrive avec son HTML
+ *                                   Markdown rendu côté service (v2)
+ *   GET  /api/v1/conversations    — discussions façon Muse (v2) : une
+ *                                   principale perpétuelle + des
+ *                                   parallèles créées/archivées/
+ *                                   supprimées par l'utilisateur
+ *   GET  /api/v1/conversations/…  — historique d'une discussion (les
+ *                                   messages agent portent leur html)
+ *   GET  /api/v1/executors        — registre (noyau, sous-agents J3,
+ *                                   externes J4 : état de configuration)
+ *   POST /api/v1/missions         — missions longues (J5)
+ * Panneau v2 (Lot 1) : rendu Markdown, largeur réglable à la souris
+ * (persistée), thème clair/sombre aligné sur l'app hôte
+ * (html[data-theme], repli prefers-color-scheme, suivi en direct).
+ * Bouton « Console » (barre des discussions) : ouvre la console web
+ * du même service (agent.dracodev.net) DANS la page, en surimpression
+ * pleine page (iframe) qui naît à la géométrie du panneau puis
+ * s'étend à toute la fenêtre ; l'URL profonde (?disc= discussion
+ * courante, ?app= app d'origine déduite du sous-domaine) est celle
+ * du premier chargement — l'iframe est créé paresseusement et
+ * conservé, la console garde son état entre ouvertures. La barre
+ * d'outils de la surimpression offre « Mode sidebar » (retour au
+ * panneau seul, animation inverse) et « Fermer l'agent » (referme
+ * surimpression et panneau).
+ * États honnêtes : service injoignable / session non reconnue / LLM non
+ * configuré / exécuteur non configuré sont affichés tels quels. */
+(function () {
+  "use strict";
+  /* URL du service : fournie par l'hôte via window.DRACO_URLS
+   * (contrat d'injection dracodev-commons, #223) — le repli est le
+   * défaut officiel ; aucun nom d'environnement n'est figé ici. */
+  var API = (window.DRACO_URLS && window.DRACO_URLS.agent) || "https://agent.dracodev.net";
+  var convId = null;
+  var convKind = null;      // 'principale' | 'parallele'
+  var convTitre = "";
+  var etatConnu = false;
+  var root = null, msgsEl = null, etatEl = null, inputEl = null, sendBtn = null;
+  var titreEl = null, tiroirEl = null;
+  var versionEl = null, versionConnue = "", versionMaj = 0;
+
+  function domaine() {
+    try { return localStorage.getItem("draco_domain") || "pro"; } catch (e) { return "pro"; }
+  }
+  function stockerConv() {
+    try {
+      if (convId) sessionStorage.setItem("draco_panneau_conv", convId);
+      else sessionStorage.removeItem("draco_panneau_conv");
+    } catch (e) { /* stockage indisponible */ }
+  }
+  function convStockee() {
+    try { return sessionStorage.getItem("draco_panneau_conv") || null; }
+    catch (e) { return null; }
+  }
+
+  /* ── Console web (même service, surimpression pleine page) ─── */
+  function appHote() {
+    /* Premier label de l'hôte, suffixe d'environnement éventuel
+     * retiré (ex. « og-dev » → « og » en dev, #223). */
+    var h = (window.location.hostname || "").split(".")[0].replace(/-dev$/, "");
+    var correspondance = { tiktak: "tiktak", flowdeck: "flowdeck",
+                           kanbante: "kanbante", og: "obsigate" };
+    return correspondance[h] || null;
+  }
+  function urlConsole() {
+    var params = [];
+    var id = convId || convStockee();
+    if (id) params.push("disc=" + encodeURIComponent(id));
+    var app = appHote();
+    if (app) params.push("app=" + encodeURIComponent(app));
+    return API + "/" + (params.length ? "?" + params.join("&") : "");
+  }
+
+  /* La surimpression vit entièrement dans ce fichier (DOM + styles
+   * injectés) : les apps hôtes n'ont que ce fichier à recopier. Son
+   * thème suit celui du panneau (data-draco-theme synchronisé par
+   * appliquerTheme) et sa palette reprend les mêmes valeurs que
+   * draco-panneau.css. L'iframe est créé au premier clic puis
+   * conservé : rouvrir la console ne le recharge pas. */
+  var surEl = null, surCadre = null, surOuverte = false;
+  var STYLES_CONSOLE =
+    ".draco-console-sur{" +
+    "--p-fond:#fbfbfa;--p-surface:#ffffff;--p-bord:#e4e5e0;--p-texte:#242624;" +
+    "--p-chip:#f4f5f1;--p-chip-bord:#d6d8d1;--p-chip-survol:#e9ebe4;--p-accent:#7c5cd6;" +
+    "position:fixed;top:0;right:0;height:100dvh;width:388px;max-width:100vw;z-index:1000;" +
+    "background:var(--p-fond);color:var(--p-texte);" +
+    "box-shadow:-12px 0 36px rgb(0 0 0 / .22);" +
+    "display:flex;flex-direction:column;transition:width .3s ease;" +
+    "font:14px/1.5 system-ui,\"Segoe UI\",sans-serif}" +
+    ".draco-console-sur[data-draco-theme=\"dark\"]{" +
+    "--p-fond:#17181a;--p-surface:#1f2023;--p-bord:#33353a;--p-texte:#eceeeb;" +
+    "--p-chip:#26272b;--p-chip-bord:#3a3c41;--p-chip-survol:#2e3036}" +
+    ".draco-console-sur[hidden]{display:none}" +
+    ".draco-console-barre{display:flex;align-items:center;gap:9px;flex:none;" +
+    "padding:9px 12px;border-bottom:1px solid var(--p-bord);background:var(--p-surface)}" +
+    ".draco-console-barre .dc-titre{font-weight:700;font-size:14px;" +
+    "display:flex;align-items:center;gap:8px;white-space:nowrap}" +
+    ".draco-console-barre .dc-etoile{color:var(--p-accent);font-size:17px}" +
+    ".draco-console-barre .dc-actions{margin-left:auto;display:flex;gap:7px}" +
+    ".draco-console-barre button{border:1px solid var(--p-chip-bord);" +
+    "background:var(--p-chip);color:var(--p-texte);border-radius:999px;" +
+    "padding:5px 12px;font:600 12.5px system-ui;cursor:pointer;white-space:nowrap}" +
+    ".draco-console-barre button:hover{background:var(--p-chip-survol)}" +
+    ".draco-console-cadre{flex:1;width:100%;border:0;display:block;background:var(--p-fond)}";
+
+  function assurerSurimpression() {
+    if (surEl) return;
+    if (!document.getElementById("draco-console-styles")) {
+      var st = document.createElement("style");
+      st.id = "draco-console-styles";
+      st.textContent = STYLES_CONSOLE;
+      document.head.appendChild(st);
+    }
+    surEl = document.createElement("div");
+    surEl.className = "draco-console-sur";
+    surEl.setAttribute("aria-label", "Console Spark");
+    surEl.hidden = true;
+    surEl.innerHTML =
+      '<div class="draco-console-barre">' +
+      '  <span class="dc-titre"><span class="dc-etoile">✦</span> Console Spark</span>' +
+      '  <span class="dc-actions">' +
+      '    <button type="button" data-dc="sidebar" title="Réduire la console et revenir au panneau latéral">◧ Mode sidebar</button>' +
+      '    <button type="button" data-dc="fermer" title="Fermer la console et le panneau Spark">✕ Fermer l\'agent</button>' +
+      '  </span></div>' +
+      '<iframe class="draco-console-cadre" title="Console Spark" allow="microphone"></iframe>';
+    document.body.appendChild(surEl);
+    surCadre = surEl.querySelector("iframe");
+    surEl.querySelector('[data-dc="sidebar"]')
+      .addEventListener("click", modeSidebarConsole);
+    surEl.querySelector('[data-dc="fermer"]')
+      .addEventListener("click", fermerAgentConsole);
+    appliquerTheme();
+  }
+
+  function largeurPanneau() {
+    if (root) {
+      var w = root.getBoundingClientRect().width;
+      if (w > 0) return Math.round(w);
+    }
+    return 388;
+  }
+
+  function ouvrirConsole() {
+    assurerSurimpression();
+    if (!surCadre.getAttribute("src")) surCadre.src = urlConsole();
+    if (surOuverte) return;
+    surOuverte = true;
+    /* Naissance à la géométrie du panneau (ancrée à droite), puis
+     * extension à toute la page ; le double rAF laisse le temps de
+     * peindre la largeur de départ, sinon la transition ne joue pas. */
+    surEl.style.width = largeurPanneau() + "px";
+    surEl.hidden = false;
+    requestAnimationFrame(function () {
+      requestAnimationFrame(function () { surEl.style.width = "100%"; });
+    });
+  }
+
+  function retrecirConsole() {
+    if (!surEl || !surOuverte) return;
+    surOuverte = false;
+    var fini = false;
+    function terminer() {
+      if (fini) return;
+      fini = true;
+      surEl.removeEventListener("transitionend", surFin);
+      surEl.hidden = true;  // l'iframe reste chargé, juste masqué
+    }
+    function surFin(ev) { if (ev.propertyName === "width") terminer(); }
+    surEl.addEventListener("transitionend", surFin);
+    setTimeout(terminer, 380);  // filet si transitionend ne vient pas
+    surEl.style.width = largeurPanneau() + "px";
+  }
+  function modeSidebarConsole() { retrecirConsole(); }
+  function fermerAgentConsole() { fermer(); retrecirConsole(); }
+
+  /* ── Thème : suivre l'app hôte ─────────────────────────────── */
+  function themeHote() {
+    var t = document.documentElement.getAttribute("data-theme");
+    if (t === "dark" || t === "light") return t;
+    if (document.documentElement.classList.contains("dark") ||
+        document.body.classList.contains("dark")) return "dark";
+    try {
+      if (window.matchMedia("(prefers-color-scheme: dark)").matches) return "dark";
+    } catch (e) { /* pas de matchMedia */ }
+    return "light";
+  }
+  function appliquerTheme() {
+    if (root) root.setAttribute("data-draco-theme", themeHote());
+    if (surEl) surEl.setAttribute("data-draco-theme", themeHote());
+  }
+  function surveillerTheme() {
+    try {
+      new MutationObserver(appliquerTheme).observe(document.documentElement,
+        { attributes: true, attributeFilter: ["data-theme", "class"] });
+      window.matchMedia("(prefers-color-scheme: dark)")
+        .addEventListener("change", appliquerTheme);
+    } catch (e) { /* surveillance facultative */ }
+  }
+
+  /* ── Largeur réglable ──────────────────────────────────────── */
+  function largeurStockee() {
+    try {
+      var v = parseInt(localStorage.getItem("draco_panneau_largeur") || "", 10);
+      return isNaN(v) ? null : v;
+    } catch (e) { return null; }
+  }
+  function appliquerLargeur() {
+    if (!root) return;
+    var v = largeurStockee();
+    root.style.width = v ? Math.min(v, Math.round(window.innerWidth * 0.96)) + "px" : "";
+  }
+  function brancherPoignee(poignee) {
+    poignee.addEventListener("pointerdown", function (ev) {
+      if (window.innerWidth <= 700) return;  // mobile : pleine largeur
+      ev.preventDefault();
+      var x0 = ev.clientX, w0 = root.getBoundingClientRect().width;
+      function bouger(e2) {
+        var w = Math.max(300, Math.min(760, w0 + (x0 - e2.clientX)));
+        root.style.width = w + "px";
+      }
+      function lacher(e2) {
+        document.removeEventListener("pointermove", bouger);
+        document.removeEventListener("pointerup", lacher);
+        var w = Math.round(root.getBoundingClientRect().width);
+        try { localStorage.setItem("draco_panneau_largeur", String(w)); } catch (e) { /* ok */ }
+      }
+      document.addEventListener("pointermove", bouger);
+      document.addEventListener("pointerup", lacher);
+    });
+    poignee.addEventListener("dblclick", function () {
+      try { localStorage.removeItem("draco_panneau_largeur"); } catch (e) { /* ok */ }
+      appliquerLargeur();
+    });
+  }
+
+  function construire() {
+    root = document.createElement("aside");
+    root.className = "draco-panneau";
+    root.setAttribute("aria-label", "Spark, l'agent commun");
+    root.innerHTML =
+      '<div class="draco-poignee" title="Glisser pour régler la largeur — double-clic : largeur par défaut"></div>' +
+      '<div class="draco-panneau-hd">' +
+      '  <span style="font-size:19px;color:#7c5cd6">✦</span>' +
+      '  <div><div class="titre">Spark — agent commun</div>' +
+      '  <div class="soustitre">Service d\'agents dracodev</div></div>' +
+      '  <button type="button" class="fermer" aria-label="Fermer le panneau">✕</button>' +
+      '</div>' +
+      '<div class="draco-panneau-hd draco-panneau-etat" style="padding-top:8px;padding-bottom:8px">' +
+      '  <span class="point"></span><span class="txt">Connexion au service…</span>' +
+      '</div>' +
+      '<div class="draco-disc-bar">' +
+      '  <span class="d-titre">Discussion principale</span>' +
+      '  <button type="button" class="d-btn" data-disc="liste">☰ Discussions</button>' +
+      '  <button type="button" class="d-btn" data-disc="nouvelle">＋ Nouvelle</button>' +
+      '  <button type="button" class="d-btn" data-disc="console" title="Ouvrir la console Spark (agent.dracodev.net) en pleine page par-dessus l\'application, sur cette discussion">Console ⤢</button>' +
+      '</div>' +
+      '<div class="draco-discussions" hidden></div>' +
+      '<div class="draco-panneau-outils">' +
+      '  <button type="button" data-outil="aujourdhui">☀ Aujourd\'hui</button>' +
+      '  <button type="button" data-outil="approbations">Approbations</button>' +
+      '  <button type="button" data-outil="missions">🚀 Missions</button>' +
+      '</div>' +
+      '<div class="draco-panneau-msgs"></div>' +
+      '<div class="draco-panneau-ft"><form class="draco-panneau-form">' +
+      '  <input type="text" placeholder="Écrire à Spark…" autocomplete="off" aria-label="Message à Spark">' +
+      '  <button type="submit">Envoyer</button></form>' +
+      '  <div class="draco-panneau-note">Conversation réelle, sous-agents (J3) et missions longues (J5) vers les exécuteurs configurés ; toute écriture dans les apps passe par une approbation.</div>' +
+      '  <div class="draco-panneau-version" style="margin-top:6px;font-size:11.5px;opacity:.6" hidden></div>' +
+      '</div>';
+    document.body.appendChild(root);
+    msgsEl = root.querySelector(".draco-panneau-msgs");
+    etatEl = root.querySelector(".draco-panneau-etat");
+    inputEl = root.querySelector("input");
+    sendBtn = root.querySelector("button[type=submit]");
+    titreEl = root.querySelector(".d-titre");
+    tiroirEl = root.querySelector(".draco-discussions");
+    versionEl = root.querySelector(".draco-panneau-version");
+    root.querySelector(".fermer").addEventListener("click", fermer);
+    root.querySelector('[data-disc="liste"]').addEventListener("click", basculerTiroir);
+    root.querySelector('[data-disc="nouvelle"]').addEventListener("click", nouvelleDiscussion);
+    root.querySelector('[data-disc="console"]').addEventListener("click", ouvrirConsole);
+    root.querySelector('[data-outil="aujourdhui"]').addEventListener("click", chargerAujourdhui);
+    root.querySelector('[data-outil="approbations"]').addEventListener("click", chargerApprobations);
+    root.querySelector('[data-outil="missions"]').addEventListener("click", ouvrirMissions);
+    root.querySelector("form").addEventListener("submit", envoyer);
+    brancherPoignee(root.querySelector(".draco-poignee"));
+    appliquerTheme();
+    surveillerTheme();
+    appliquerLargeur();
+    window.addEventListener("resize", appliquerLargeur);
+    document.addEventListener("keydown", function (ev) {
+      if (ev.key !== "Escape") return;
+      /* Surimpression ouverte : Échap = retour au panneau seul
+       * (« Mode sidebar »). Quand le focus est dans l'iframe de la
+       * console (autre origine), l'événement ne remonte pas
+       * jusqu'ici : il ne peut donc pas fermer par surprise. */
+      if (surOuverte) { modeSidebarConsole(); return; }
+      if (root.classList.contains("open")) fermer();
+    });
+  }
+
+  function ajouterMsg(kind, texte) {
+    var d = document.createElement("div");
+    d.className = "draco-msg " + kind;
+    d.textContent = texte;
+    msgsEl.appendChild(d);
+    msgsEl.scrollTop = msgsEl.scrollHeight;
+    return d;
+  }
+
+  /* Message agent rendu en Markdown : le HTML vient du service
+   * (rendu + sanitizer côté serveur) ; repli texte si absent. */
+  function ajouterMsgMd(texte, html) {
+    var d = document.createElement("div");
+    d.className = "draco-msg agent md";
+    if (html) d.innerHTML = html;
+    else d.textContent = texte;
+    msgsEl.appendChild(d);
+    msgsEl.scrollTop = msgsEl.scrollHeight;
+    return d;
+  }
+
+  function majEtat(cls, texte) {
+    etatEl.className = "draco-panneau-hd draco-panneau-etat " + cls;
+    etatEl.querySelector(".txt").textContent = texte;
+  }
+  function majTitre() {
+    titreEl.textContent = convTitre || "Discussion principale";
+    titreEl.title = titreEl.textContent;
+  }
+
+  /* ── Version du service : lue en direct dans la santé de
+   * l'agent (GET /healthz → champ « version », la même source que
+   * la console) à l'origine que le panneau connaît déjà. Cache de
+   * session (5 min), rafraîchie à l'ouverture du panneau, au même
+   * rythme que la vérification d'identité. Jamais de valeur codée
+   * en dur : source injoignable ou réponse illisible = la ligne
+   * reste masquée — pas de fausse version, pas d'erreur visible. */
+  function afficherVersion() {
+    if (!versionEl) return;
+    if (versionConnue) {
+      versionEl.textContent = "Service d'agents v" + versionConnue;
+      versionEl.hidden = false;
+    }
+  }
+  function chargerVersion() {
+    if (!API || !versionEl) return;
+    if (versionConnue && Date.now() - versionMaj < 300000) { afficherVersion(); return; }
+    fetch(API + "/healthz")
+      .then(function (r) { if (!r.ok) throw new Error("HTTP " + r.status); return r.json(); })
+      .then(function (d) {
+        if (d && typeof d.version === "string" && /^[0-9]+\.[0-9]+\.[0-9]+/.test(d.version)) {
+          versionConnue = d.version;
+          versionMaj = Date.now();
+          afficherVersion();
+        }
+      })
+      .catch(function () { /* service injoignable : rien d'affiché */ });
+  }
+
+  function verifierIdentite() {
+    if (etatConnu) return;
+    fetch(API + "/api/v1/me", { credentials: "include" })
+      .then(function (r) {
+        if (r.status === 401) {
+          majEtat("err", "Session partagée non reconnue");
+          ajouterMsg("sys", "Le service ne reconnaît pas ta session. Connecte-toi à ObsiGate (session unique draco_session), puis rouvre le panneau. Si le SSO n'est pas encore activé, c'est l'étape d'activation du programme.");
+          etatConnu = true;
+          return null;
+        }
+        if (!r.ok) throw new Error("HTTP " + r.status);
+        return r.json();
+      })
+      .then(function (me) {
+        if (!me) return;
+        etatConnu = true;
+        majEtat("ok", "Connecté au service — " + (me.name || ("utilisateur " + me.sub)));
+      })
+      .catch(function () {
+        majEtat("err", "Service d'agents injoignable");
+        ajouterMsg("sys", "Le service d'agents (agent.dracodev.net) ne répond pas. Vérifie que le conteneur dracodev-agent est démarré.");
+      });
+  }
+
+  function esc(s) {
+    return String(s == null ? "" : s).replace(/[&<>"]/g, function (c) {
+      return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c];
+    });
+  }
+
+  /* ── Discussions (façon Muse) ────────────────────────────── */
+  function chargerListeDiscussions() {
+    return fetch(API + "/api/v1/conversations?domain=" + encodeURIComponent(domaine()),
+                 { credentials: "include" })
+      .then(function (r) { if (!r.ok) throw new Error("HTTP " + r.status); return r.json(); });
+  }
+
+  function demarrerDiscussions() {
+    chargerListeDiscussions()
+      .then(function (d) {
+        var precedente = convStockee();
+        var candidates = (d.paralleles || []).concat(d.principale ? [d.principale] : []);
+        var trouvee = candidates.filter(function (c) { return c.id === precedente; })[0];
+        var active = trouvee || d.principale;
+        if (!active) return;
+        convId = active.id; convKind = active.kind; convTitre = active.title;
+        stockerConv(); majTitre();
+        chargerHistorique();
+      })
+      .catch(function () {
+        ajouterMsg("sys", "Discussions : service injoignable pour le moment.");
+      });
+  }
+
+  function basculerDiscussion(c) {
+    convId = c.id; convKind = c.kind; convTitre = c.title;
+    stockerConv(); majTitre();
+    tiroirEl.hidden = true;
+    msgsEl.innerHTML = "";
+    ajouterMsg("sys", (c.kind === "principale"
+      ? "Discussion principale — le fil sans fin."
+      : "Discussion parallèle : " + c.title) + " · domaine : " + domaine() + ".");
+    chargerHistorique();
+    inputEl.focus();
+  }
+
+  function nouvelleDiscussion() {
+    fetch(API + "/api/v1/conversations", {
+      method: "POST", credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ domain: domaine() })
+    })
+      .then(function (r) { if (!r.ok) throw new Error("HTTP " + r.status); return r.json(); })
+      .then(function (c) {
+        basculerDiscussion(c);
+        ajouterMsg("sys", "Nouvelle discussion parallèle créée — elle prendra le titre de ton premier message.");
+      })
+      .catch(function () { ajouterMsg("sys", "Création impossible (service injoignable ?)."); });
+  }
+
+  function actionDiscussion(id, action) {
+    var methode = action === "supprimer" ? "DELETE" : "POST";
+    var url = API + "/api/v1/conversations/" + id + (action === "supprimer" ? "" : "/" + action);
+    return fetch(url, { method: methode, credentials: "include" })
+      .then(function (r) {
+        if (!r.ok) return r.json().catch(function () { return null; }).then(function (e) {
+          throw new Error(e && e.detail ? e.detail : "HTTP " + r.status);
+        });
+        return r.json();
+      });
+  }
+
+  function ligneDiscussion(c, actions) {
+    var ligne = document.createElement("div");
+    ligne.className = "d-item" + (c.id === convId ? " actif" : "");
+    var meta = document.createElement("div");
+    meta.className = "d-meta";
+    var quand = "";
+    try {
+      quand = new Date(c.updated_at * 1000).toLocaleDateString("fr-CA",
+        { day: "numeric", month: "short" });
+    } catch (e) { /* date illisible */ }
+    meta.textContent = (c.kind === "principale" ? "📌 " : "") + c.title;
+    ligne.appendChild(meta);
+    var sous = document.createElement("div");
+    sous.className = "d-sous";
+    sous.textContent = c.nb_messages + " message(s)" + (quand ? " · " + quand : "") +
+      (c.kind === "principale" ? " · perpétuelle" : "");
+    ligne.appendChild(sous);
+    meta.addEventListener("click", function () { basculerDiscussion(c); });
+    sous.addEventListener("click", function () { basculerDiscussion(c); });
+    if (actions && actions.length) {
+      var btns = document.createElement("div");
+      btns.className = "d-actions";
+      actions.forEach(function (a) {
+        var b = document.createElement("button");
+        b.type = "button"; b.textContent = a.label;
+        if (a.danger) b.className = "danger";
+        b.addEventListener("click", function (ev) {
+          ev.stopPropagation();
+          if (a.confirmer && !window.confirm(a.confirmer)) return;
+          actionDiscussion(c.id, a.action)
+            .then(function () {
+              if (c.id === convId && a.action !== "desarchiver") {
+                chargerListeDiscussions().then(function (d) {
+                  if (d.principale) {
+                    basculerDiscussion(d.principale);
+                    ajouterMsg("sys", a.action === "supprimer"
+                      ? "Discussion supprimée — retour à la discussion principale."
+                      : "Discussion archivée — retour à la discussion principale.");
+                  }
+                });
+              }
+              remplirTiroir();
+            })
+            .catch(function (e) { ajouterMsg("sys", "Action refusée : " + e.message); });
+        });
+        btns.appendChild(b);
+      });
+      ligne.appendChild(btns);
+    }
+    return ligne;
+  }
+
+  function remplirTiroir() {
+    tiroirEl.innerHTML = "<div class='d-chargement'>Chargement des discussions…</div>";
+    chargerListeDiscussions()
+      .then(function (d) {
+        tiroirEl.innerHTML = "";
+        var h = document.createElement("div");
+        h.className = "d-section";
+        h.textContent = "Discussion principale";
+        tiroirEl.appendChild(h);
+        if (d.principale) tiroirEl.appendChild(ligneDiscussion(d.principale, []));
+        h = document.createElement("div");
+        h.className = "d-section";
+        h.textContent = "Discussions parallèles";
+        tiroirEl.appendChild(h);
+        if (!d.paralleles.length) {
+          var vide = document.createElement("div");
+          vide.className = "d-vide";
+          vide.textContent = "Aucune pour le moment — bouton « ＋ Nouvelle ».";
+          tiroirEl.appendChild(vide);
+        }
+        d.paralleles.forEach(function (c) {
+          tiroirEl.appendChild(ligneDiscussion(c, [
+            { label: "Archiver", action: "archive" },
+            { label: "Supprimer", action: "supprimer", danger: true,
+              confirmer: "Supprimer définitivement la discussion « " + c.title + " » ?" }
+          ]));
+        });
+        if (d.archivees && d.archivees.length) {
+          h = document.createElement("div");
+          h.className = "d-section";
+          h.textContent = "Archivées";
+          tiroirEl.appendChild(h);
+          d.archivees.forEach(function (c) {
+            tiroirEl.appendChild(ligneDiscussion(c, [
+              { label: "Désarchiver", action: "desarchiver" },
+              { label: "Supprimer", action: "supprimer", danger: true,
+                confirmer: "Supprimer définitivement la discussion « " + c.title + " » ?" }
+            ]));
+          });
+        }
+      })
+      .catch(function () {
+        tiroirEl.innerHTML = "<div class='d-chargement'>Discussions : service injoignable.</div>";
+      });
+  }
+
+  function basculerTiroir() {
+    tiroirEl.hidden = !tiroirEl.hidden;
+    if (!tiroirEl.hidden) remplirTiroir();
+  }
+
+  function chargerHistorique() {
+    if (!convId) return;
+    fetch(API + "/api/v1/conversations/" + convId, { credentials: "include" })
+      .then(function (r) {
+        if (r.status === 404) { convId = null; stockerConv(); return null; }
+        if (!r.ok) return null;
+        return r.json();
+      })
+      .then(function (d) {
+        if (!d) return;
+        convKind = d.kind; convTitre = d.title || convTitre;
+        majTitre();
+        if (!msgsEl.querySelector(".draco-msg")) {
+          ajouterMsg("sys", (d.kind === "principale"
+            ? "Discussion principale — le fil sans fin."
+            : "Discussion parallèle : " + (d.title || "")) + " · domaine : " + domaine() + ".");
+        }
+        var sys = msgsEl.querySelector(".draco-msg.sys");
+        (d.messages || []).forEach(function (m) {
+          var el = m.role === "user"
+            ? ajouterMsg("user", m.content)
+            : ajouterMsgMd(m.content, m.html);
+          if (sys) { msgsEl.insertBefore(el, sys.nextSibling); sys = el; }
+        });
+        msgsEl.scrollTop = msgsEl.scrollHeight;
+      })
+      .catch(function () { /* historique indisponible : on repart à neuf */ });
+  }
+
+  function chargerAujourdhui() {
+    var bloc = document.createElement("div");
+    bloc.className = "draco-auj";
+    bloc.innerHTML = "<h5>Aujourd'hui — vu du service d'agents</h5><div class='etat-source'>Chargement…</div>";
+    msgsEl.appendChild(bloc); msgsEl.scrollTop = msgsEl.scrollHeight;
+    fetch(API + "/api/v1/aujourdhui", { credentials: "include" })
+      .then(function (r) { if (!r.ok) throw new Error("HTTP " + r.status); return r.json(); })
+      .then(function (d) {
+        var h = "<h5>Aujourd'hui — " + esc(d.date) + " · domaine " + esc(d.domain) + "</h5>";
+        var t = d.sources.tiktak;
+        h += "<h5>Tâches du jour — TikTak</h5>";
+        if (t.status === "ok") {
+          if (!t.tasks.length) h += "<div class='etat-source'>Aucune tâche échue aujourd'hui. 🎉</div>";
+          else h += "<ul>" + t.tasks.map(function (x) { return "<li>" + esc(x.title) + "</li>"; }).join("") + "</ul>";
+        } else if (t.status === "non_configure") {
+          h += "<div class='etat-source'>Source non configurée : il manque la clé tck_ du service (voir le .env du conteneur agent).</div>";
+        } else if (t.status === "non_autorise") {
+          h += "<div class='etat-source'>Source non autorisée : la clé du service est refusée par TikTak (clé révoquée ?).</div>";
+        } else {
+          h += "<div class='etat-source'>Source TikTak " + esc(t.status) + ".</div>";
+        }
+        var k = d.sources.kanbante;
+        h += "<h5>Cartes en Révision — Kanbante</h5>";
+        if (k.status === "ok") {
+          if (!k.review.length) h += "<div class='etat-source'>Rien à valider. 🎉</div>";
+          else h += "<ul>" + k.review.map(function (x) { return "<li>#" + esc(x.number) + " — " + esc(x.title) + "</li>"; }).join("") + "</ul>";
+        } else if (k.status === "non_autorise") {
+          h += "<div class='etat-source'>Source non autorisée : Kanbante exige un jeton d'API pour le service — il arrive avec Kanbante 0.25.0, puis AGENT_MCP_KANBANTE_KEY dans le .env de l'agent.</div>";
+        } else {
+          h += "<div class='etat-source'>Source Kanbante " + esc(k.status) + ".</div>";
+        }
+        bloc.innerHTML = h;
+        msgsEl.scrollTop = msgsEl.scrollHeight;
+      })
+      .catch(function () {
+        bloc.innerHTML = "<h5>Aujourd'hui</h5><div class='etat-source'>Service injoignable.</div>";
+      });
+  }
+
+  function chargerApprobations() {
+    fetch(API + "/api/v1/approvals?status=pending", { credentials: "include" })
+      .then(function (r) { if (!r.ok) throw new Error("HTTP " + r.status); return r.json(); })
+      .then(function (d) {
+        if (!d.approvals.length) { ajouterMsg("sys", "Aucune approbation en attente."); return; }
+        d.approvals.forEach(function (a) {
+          var bloc = document.createElement("div");
+          bloc.className = "draco-appro";
+          bloc.innerHTML = "<div class='titre'>Approbation demandée — " + esc(a.action) + "</div>" +
+            "<div class='resume'>" + esc(a.summary) + "</div>" +
+            "<div class='btns'><button type='button' class='go'>Approuver</button>" +
+            "<button type='button' class='non'>Rejeter</button></div>";
+          bloc.querySelector(".go").addEventListener("click", function () { decider(a.id, "approved", bloc); });
+          bloc.querySelector(".non").addEventListener("click", function () { decider(a.id, "rejected", bloc); });
+          msgsEl.appendChild(bloc);
+        });
+        msgsEl.scrollTop = msgsEl.scrollHeight;
+      })
+      .catch(function () { ajouterMsg("sys", "Approbations : service injoignable."); });
+  }
+
+  function decider(id, decision, bloc) {
+    fetch(API + "/api/v1/approvals/" + id + "/decide", {
+      method: "POST", credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ decision: decision })
+    })
+      .then(function (r) { if (!r.ok) throw new Error("HTTP " + r.status); return r.json(); })
+      .then(function (d) {
+        bloc.style.opacity = ".55";
+        bloc.querySelector(".btns").innerHTML = "<span style='font-size:12.5px'>Décision enregistrée : " + esc(d.status) + "</span>";
+      })
+      .catch(function () { ajouterMsg("sys", "La décision n'a pas pu être envoyée (service injoignable ?)."); });
+  }
+
+  /* ── Missions longues (J5) ───────────────────────────────────
+   * Sélecteur d'exécuteur alimenté par le registre du service :
+   * les externes non configurés sont montrés mais désactivés —
+   * jamais un lancement qui simule. La liste se rafraîchit à
+   * l'ouverture et après chaque lancement/annulation. */
+  var STATUTS_MISSION = {
+    queued: "En file", running: "En cours…", paused_question: "Question en attente",
+    succeeded: "Terminée", failed: "Échouée", cancelled: "Annulée"
+  };
+
+  function ouvrirMissions() {
+    var bloc = document.createElement("div");
+    bloc.className = "draco-missions";
+    bloc.innerHTML =
+      "<h5>Missions longues</h5>" +
+      "<label>Exécuteur</label><select class='m-exec'><option>Chargement…</option></select>" +
+      "<label>Titre</label><input type='text' class='m-titre' placeholder='Ex. Veille des projets du matin'>" +
+      "<label>Consigne</label><textarea class='m-prompt' rows='3' placeholder='Ce que l\u2019exécuteur doit faire…'></textarea>" +
+      "<label>Carte Kanbante liée (n°, optionnel)</label><input type='number' class='m-carte' min='1' placeholder='—'>" +
+      "<div class='btns'><button type='button' class='go'>Lancer la mission</button>" +
+      "<button type='button' class='rafraichir'>Rafraîchir la liste</button></div>" +
+      "<div class='m-liste'><div class='etat-source'>Chargement des missions…</div></div>";
+    msgsEl.appendChild(bloc);
+    msgsEl.scrollTop = msgsEl.scrollHeight;
+    fetch(API + "/api/v1/executors", { credentials: "include" })
+      .then(function (r) { if (!r.ok) throw new Error("HTTP " + r.status); return r.json(); })
+      .then(function (d) {
+        var sel = bloc.querySelector(".m-exec");
+        sel.innerHTML = "";
+        d.executors.forEach(function (e) {
+          if (e.family !== "sous-agent" && e.family !== "externe") return;
+          var opt = document.createElement("option");
+          opt.value = e.id;
+          opt.textContent = e.name + (e.family === "sous-agent" ? " (sous-agent)" : "") +
+            (e.status === "non_configure" ? " — non configuré" : "");
+          if (e.status === "non_configure") opt.disabled = true;
+          sel.appendChild(opt);
+        });
+        if (!sel.options.length) sel.innerHTML = "<option value=''>Aucun exécuteur lançable</option>";
+      })
+      .catch(function () { bloc.querySelector(".m-exec").innerHTML = "<option value=''>Registre injoignable</option>"; });
+    bloc.querySelector(".go").addEventListener("click", function () { lancerMission(bloc); });
+    bloc.querySelector(".rafraichir").addEventListener("click", function () { chargerMissions(bloc); });
+    chargerMissions(bloc);
+  }
+
+  function chargerMissions(bloc) {
+    var zone = bloc.querySelector(".m-liste");
+    fetch(API + "/api/v1/missions", { credentials: "include" })
+      .then(function (r) { if (!r.ok) throw new Error("HTTP " + r.status); return r.json(); })
+      .then(function (d) {
+        if (!d.missions.length) { zone.innerHTML = "<div class='etat-source'>Aucune mission pour le moment.</div>"; return; }
+        zone.innerHTML = "";
+        d.missions.slice(0, 10).forEach(function (m) {
+          var ligne = document.createElement("div");
+          ligne.className = "m-item";
+          var entete = document.createElement("div");
+          entete.className = "m-entete";
+          entete.innerHTML = "<b>" + esc(m.title) + "</b>" +
+            "<span class='m-statut st-" + esc(m.status) + "'>" + esc(STATUTS_MISSION[m.status] || m.status) + "</span>";
+          ligne.appendChild(entete);
+          var meta = document.createElement("div");
+          meta.className = "m-meta";
+          meta.textContent = m.executor +
+            (m.meta && m.meta.duree_s ? " · " + m.meta.duree_s + " s" : "") +
+            (m.meta && m.meta.cout ? " · coût : " + m.meta.cout : "");
+          ligne.appendChild(meta);
+          if (m.result) {
+            var rapport = document.createElement("div");
+            rapport.className = "m-rapport md";
+            if (m.result_html) rapport.innerHTML = m.result_html;
+            else rapport.textContent = String(m.result).slice(0, 1200);
+            ligne.appendChild(rapport);
+          }
+          if (m.status === "queued" || m.status === "running" || m.status === "paused_question") {
+            var btn = document.createElement("button");
+            btn.type = "button"; btn.className = "m-annuler"; btn.textContent = "Annuler";
+            btn.addEventListener("click", function () {
+              fetch(API + "/api/v1/missions/" + m.id + "/cancel", {
+                method: "POST", credentials: "include",
+                headers: { "Content-Type": "application/json" }, body: "{}"
+              }).then(function () { chargerMissions(bloc); })
+                .catch(function () { ajouterMsg("sys", "Annulation non envoyée (service injoignable ?)."); });
+            });
+            ligne.appendChild(btn);
+          }
+          zone.appendChild(ligne);
+        });
+      })
+      .catch(function () { zone.innerHTML = "<div class='etat-source'>Missions : service injoignable.</div>"; });
+  }
+
+  function lancerMission(bloc) {
+    var executor = bloc.querySelector(".m-exec").value;
+    var titre = bloc.querySelector(".m-titre").value.trim();
+    var prompt = bloc.querySelector(".m-prompt").value.trim();
+    var carte = bloc.querySelector(".m-carte").value;
+    if (!executor) { ajouterMsg("sys", "Choisis un exécuteur configuré pour lancer une mission."); return; }
+    if (!titre || !prompt) { ajouterMsg("sys", "Mission : il faut un titre et une consigne."); return; }
+    var corps = { executor: executor, title: titre, prompt: prompt, domain: domaine() };
+    if (carte) corps.kanbante_number = parseInt(carte, 10);
+    fetch(API + "/api/v1/missions", {
+      method: "POST", credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(corps)
+    })
+      .then(function (r) {
+        if (!r.ok) return r.json().catch(function () { return null; }).then(function (e) {
+          throw new Error(e && e.detail ? e.detail : "HTTP " + r.status);
+        });
+        return r.json();
+      })
+      .then(function () {
+        ajouterMsg("sys", "Mission « " + titre + " » lancée — suis-la dans la liste des missions.");
+        chargerMissions(bloc);
+      })
+      .catch(function (e) { ajouterMsg("sys", "Lancement refusé : " + e.message); });
+  }
+
+  function envoyer(ev) {
+    ev.preventDefault();
+    var texte = inputEl.value.trim();
+    if (!texte) return;
+    inputEl.value = "";
+    ajouterMsg("user", texte);
+    sendBtn.disabled = true;
+    var attente = ajouterMsg("agent", "Spark réfléchit…");
+    fetch(API + "/api/v1/chat", {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ message: texte, domain: domaine(), conversation_id: convId })
+    })
+      .then(function (r) {
+        if (r.status === 401) {
+          attente.textContent = "Le service ne reconnaît pas ta session partagée (401). Connecte-toi à ObsiGate puis réessaie.";
+          majEtat("err", "Session partagée non reconnue");
+          return null;
+        }
+        if (!r.ok) {
+          return r.json().catch(function () { return null; }).then(function (e) {
+            attente.textContent = (e && e.detail) ? e.detail :
+              "Le service a répondu HTTP " + r.status + " — réessaie dans un instant.";
+            return null;
+          });
+        }
+        return r.json();
+      })
+      .then(function (d) {
+        if (!d) return;
+        convId = d.conversation_id;
+        convKind = d.kind || convKind;
+        if (d.title) convTitre = d.title;
+        stockerConv(); majTitre();
+        if (d.html) {
+          attente.className = "draco-msg agent md";
+          attente.innerHTML = d.html;
+        } else {
+          attente.textContent = d.reply;
+        }
+        msgsEl.scrollTop = msgsEl.scrollHeight;
+        if (d.tools_used && d.tools_used.length) {
+          ajouterMsg("sys", "Outils utilisés : " + d.tools_used.join(", ") + " · modèle : " + (d.model || "?"));
+        }
+        majEtat("ok", "Connecté au service — domaine " + d.domain);
+      })
+      .catch(function () {
+        attente.textContent = "Service injoignable. Vérifie que le conteneur dracodev-agent est démarré, puis réessaie.";
+        majEtat("err", "Service d'agents injoignable");
+      })
+      .finally(function () { sendBtn.disabled = false; inputEl.focus(); });
+  }
+
+  function ouvrir() {
+    if (!root) { construire(); demarrerDiscussions(); }
+    root.classList.add("open");
+    appliquerTheme();
+    verifierIdentite();
+    chargerVersion();
+    setTimeout(function () { inputEl.focus(); }, 300);
+  }
+  function fermer() { if (root) root.classList.remove("open"); }
+
+  window.DRACO_PANNEAU = {
+    open: ouvrir,
+    close: fermer,
+    toggle: function () {
+      if (root && root.classList.contains("open")) fermer(); else ouvrir();
+    }
+  };
+})();

frontend/index.html

@@ -10,7 +10,7 @@
             name="description"
             content="Porte d'entrée web pour vos vaults Obsidian - Accédez, naviguez et recherchez dans toutes vos notes"
         />
-        <meta name="theme-color" content="#2563eb" />
+        <meta name="theme-color" content="#7c5cd6" />
         <meta name="mobile-web-app-capable" content="yes" />
         <meta name="apple-mobile-web-app-capable" content="yes" />
         <meta
@@ -54,14 +54,14 @@
             #boot-splash {
                 position: fixed; inset: 0; z-index: 2147483647;
                 display: flex; align-items: center; justify-content: center;
-                background: radial-gradient(1200px 600px at 50% -10%, #1b2030 0%, #0e1117 60%);
-                color: #e6e8ee; font-family: "Segoe UI", system-ui, -apple-system, sans-serif;
+                background: radial-gradient(1200px 600px at 50% -10%, #26272b 0%, #17181a 60%);
+                color: #eceeeb; font-family: "Segoe UI", system-ui, -apple-system, sans-serif;
             }
             body.app-booted #boot-splash { display: none; }
             .bs-card { display: flex; flex-direction: column; align-items: center; gap: 14px; }
             .bs-logo {
                 width: 72px; height: 72px; display: flex; align-items: center; justify-content: center;
-                font-size: 38px; background: #171c26; border: 1px solid #2a3242; border-radius: 18px;
+                font-size: 38px; background: #1f2023; border: 1px solid #33353a; border-radius: 18px;
                 box-shadow: 0 8px 30px rgba(0, 0, 0, 0.45);
             }
             .bs-title { font-size: 22px; font-weight: 600; letter-spacing: 0.3px; }
@@ -76,6 +76,7 @@
         </style>
         <link rel="stylesheet" href="/static/style.css" />
         <link rel="stylesheet" href="/static/draco-barre.css" />
+        <link rel="stylesheet" href="/static/draco-panneau.css" />
         <link
             rel="stylesheet"
             href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/github-dark.min.css"
@@ -396,6 +397,16 @@
                localement ; la recherche focus la recherche native
                d'ObsiGate ; Alertes unifiées et Spark arrivent avec la
                fédération / l'agent commun (phases suivantes). */
+            /* #223 : les href des onglets portent les défauts officiels ;
+               l'hôte les réécrit depuis window.DRACO_URLS (injecté par le
+               backend depuis sa configuration) quand il est présent. */
+            (function () {
+                if (!window.DRACO_URLS) return;
+                document.querySelectorAll(".draco-apptab").forEach(function (a) {
+                    var u = window.DRACO_URLS[a.dataset.app];
+                    if (u) a.href = u.replace(/\/$/, "") + "/";
+                });
+            })();
             window.DRACO_BAR_CONFIG = {
                 current: "obsigate",
                 domain: (function () { try { return localStorage.getItem("draco_domain") || "pro"; } catch (e) { return "pro"; } })(),
@@ -423,7 +434,11 @@
                     if (act === "palette") { var s = document.getElementById("search-input"); if (s) { s.focus(); s.scrollIntoView({ block: "center" }); } return; }
                     if (act === "menu") { var m = document.getElementById("header-menu-btn"); if (m) m.click(); return; }
                     if (act === "alertes") { dire("Alertes unifiées : arrive avec la fédération (programme Fusion)."); return; }
-                    if (act === "spark") { dire("Spark, l'agent commun : arrive en phase 4 du programme Fusion."); return; }
+                    if (act === "spark") {
+                        if (window.DRACO_PANNEAU) { window.DRACO_PANNEAU.toggle(); }
+                        else { dire("Spark : le panneau n'a pas pu se charger."); }
+                        return;
+                    }
                     if (act === "rappel-entete") {
                         var bar = document.querySelector(".draco-bar");
                         if (bar) bar.style.display = "";
@@ -6052,5 +6067,6 @@ curl -X POST https://votre-serveur.com/webhook \
         </div>
         <script defer src="/static/draco-barre.js"></script>
         <script defer src="/static/draco-liens.js"></script>
+        <script defer src="/static/draco-panneau.js"></script>
     </body>
 </html>

frontend/js/sidebar.js

@@ -4,6 +4,7 @@ import { api, AuthManager } from './auth.js';
 import { populateCustomDropdown, TabManager, closeMobileSidebar, ContextMenuManager } from './ui.js';
 import { _populateRecentVaultFilter, switchSidebarTab, filterAIHistory, filterRecentFiles } from './config.js';
 import { el, icon, getVaultIcon, smallBadge, attachTreeItemActionButton, attachTreeItemLongPress, showWelcome, appendHighlightedText, filterSavedSearches } from './viewer.js';
+import { openCoffresView, openCoffresNewSecret, openCoffresAcces, openCoffresJournal, getCoffresForSidebar, invalidateCoffresCache } from './coffres.js';
 import { performAdvancedSearch } from './search.js';
 import { t } from './i18n.js';
 import { filterChatMessages as _filterChat } from './filechat.js';
@@ -46,6 +47,168 @@ function _sharedIcon(size = 16) {
   return i;
 }
 
+// ---------------------------------------------------------------------------
+// Coffre Secrets — nœud virtuel « Secrets » sous le Home (Phase 1c, #19).
+// Patron exact du dossier virtuel « Partage » (#196) : inséré à la racine
+// du Home de l'utilisateur courant seulement, sans dossier sur disque, sans
+// passer par l'indexeur. Contrairement à « Partage », le nœud est permanent
+// (même sans coffre) : cliquer dessus ouvre la vue Secrets, qui crée le
+// coffre personnel à la première ouverture si besoin.
+// AUCUNE action de fichier n'est attachée à ce nœud ni à ses enfants :
+// ni attachTreeItemActionButton, ni ContextMenuManager (qui proposerait
+// renommer/déplacer/supprimer). Le menu ⋮ est un menu propre ci-dessous.
+// ---------------------------------------------------------------------------
+
+/** Icône cadenas (U+1F510) du nœud Secrets, distincte de la maison et du diamant. */
+function _secretsIcon() {
+  const s = document.createElement("span");
+  s.className = "coffres-icon-lock";
+  s.textContent = "\u{1F510}";
+  return s;
+}
+
+function _isOwnHome(vaultName) {
+  const me = (AuthManager.getUser() || {}).username;
+  return !!me && vaultName === `home-${me}`;
+}
+
+/** Construit le nœud Secrets + son conteneur d'enfants (coffres). */
+async function _buildSecretsNode(vaultName) {
+  const pair = document.createDocumentFragment();
+  const item = el("div", { class: "tree-item", "data-vault": vaultName, "data-path": "Secrets", "data-type": "virtual-secrets" }, [icon("chevron-right", 14), _secretsIcon(), el("span", { class: "tree-item-text" }, [document.createTextNode(t("coffres.secrets"))])]);
+  const sub = el("div", { class: "tree-children collapsed", id: `dir-${vaultName}-Secrets` });
+  item.addEventListener("click", async () => {
+    scrollTreeItemIntoView(item, false);
+    if (sub.classList.contains("collapsed")) {
+      if (sub.children.length === 0) await _fillSecretsNode(item, sub, vaultName);
+      sub.classList.remove("collapsed");
+      const chev = item.querySelector("[data-lucide]");
+      if (chev) chev.setAttribute("data-lucide", "chevron-down");
+      safeCreateIcons();
+    } else {
+      sub.classList.add("collapsed");
+      const chev = item.querySelector("[data-lucide]");
+      if (chev) chev.setAttribute("data-lucide", "chevron-right");
+      safeCreateIcons();
+    }
+    await openCoffresView();
+    closeMobileSidebar();
+  });
+  item.addEventListener("contextmenu", (e) => {
+    e.preventDefault();
+    _openSecretsMenu(e.clientX, e.clientY);
+  });
+  const actionBtn = el("button", { class: "tree-item-action-btn", type: "button", title: t("coffres.secrets") }, [document.createTextNode("\u22EE")]);
+  actionBtn.addEventListener("click", (e) => {
+    e.stopPropagation();
+    const r = actionBtn.getBoundingClientRect();
+    _openSecretsMenu(Math.min(r.right, window.innerWidth - 16), r.bottom);
+  });
+  item.appendChild(actionBtn);
+  pair.appendChild(item);
+  pair.appendChild(sub);
+  // Compteur et enfants, en arrière-plan : le nœud existe même si l'API échoue.
+  _fillSecretsNode(item, sub, vaultName).catch(() => {});
+  return pair;
+}
+
+/** Remplit le compteur et les enfants (coffres) d'un nœud Secrets existant. */
+async function _fillSecretsNode(item, sub, vaultName) {
+  const data = await getCoffresForSidebar();
+  item.querySelectorAll(".badge-small, .coffres-alert-dot").forEach((n) => n.remove());
+  if (!data.disabled && data.personnel) {
+    if (!data.personnel.kek_configuree) {
+      const dot = document.createElement("span");
+      dot.className = "coffres-alert-dot";
+      dot.textContent = "\u26A0";
+      dot.title = t("coffres.kek_absente");
+      item.appendChild(dot);
+    } else {
+      item.appendChild(smallBadge(data.personnel.nb_secrets));
+    }
+  }
+  sub.innerHTML = "";
+  const coffres = (data.coffres || []).slice().sort((a, b) => {
+    const aPers = a.proprietaire === (AuthManager.getUser() || {}).username && a.perimetre === "personnel" ? 0 : 1;
+    const bPers = b.proprietaire === (AuthManager.getUser() || {}).username && b.perimetre === "personnel" ? 0 : 1;
+    return aPers - bPers || String(a.nom).localeCompare(String(b.nom));
+  });
+  coffres.forEach((c) => {
+    const me = (AuthManager.getUser() || {}).username;
+    const label = c.proprietaire === me ? c.nom : `${c.nom} (${c.proprietaire})`;
+    const child = el("div", { class: "tree-item", "data-vault": vaultName, "data-path": `Secrets/${c.slug}`, "data-type": "virtual-coffre", "data-coffre-slug": c.slug }, [icon("lock", 16), el("span", { class: "tree-item-text" }, [document.createTextNode(label)]), smallBadge(c.nb_secrets)]);
+    child.addEventListener("click", async () => {
+      scrollTreeItemIntoView(child, false);
+      await openCoffresView(c.slug);
+      closeMobileSidebar();
+    });
+    child.addEventListener("contextmenu", (e) => {
+      e.preventDefault();
+      _openSecretsMenu(e.clientX, e.clientY);
+    });
+    sub.appendChild(child);
+  });
+  safeCreateIcons();
+}
+
+/** Rafraîchit tous les nœuds Secrets affichés (après création, rotation, révocation…). */
+async function _refreshSecretsNodes() {
+  const items = Array.from(document.querySelectorAll('[data-type="virtual-secrets"]'));
+  for (const item of items) {
+    const vaultName = item.dataset.vault;
+    const sub = item.nextElementSibling;
+    if (sub && sub.classList.contains("tree-children")) {
+      await _fillSecretsNode(item, sub, vaultName);
+    }
+  }
+}
+
+if (!window.__obsigateSecretsListener) {
+  window.__obsigateSecretsListener = true;
+  document.addEventListener("obsigate:coffres-changed", () => {
+    invalidateCoffresCache();
+    _refreshSecretsNodes().catch(() => {});
+  });
+}
+
+/** Menu ⋮ du nœud Secrets : Ouvrir, Nouveau secret, Gérer les accès, Journal.
+ *  Menu propre, jamais ContextMenuManager (pas d'action de fichier). */
+function _openSecretsMenu(x, y) {
+  document.querySelectorAll(".coffres-context-menu").forEach((n) => n.remove());
+  const menu = el("div", { class: "coffres-context-menu" }, []);
+  const entries = [
+    [t("coffres.detail"), () => openCoffresView()],
+    [t("coffres.new_secret"), () => openCoffresNewSecret()],
+    [t("coffres.acces"), () => openCoffresAcces()],
+    [t("coffres.journal"), () => openCoffresJournal()],
+  ];
+  entries.forEach(([label, run]) => {
+    const b = el("button", { class: "coffres-context-item", type: "button" }, [document.createTextNode(label)]);
+    b.addEventListener("click", async () => {
+      menu.remove();
+      await run();
+      closeMobileSidebar();
+    });
+    menu.appendChild(b);
+  });
+  document.body.appendChild(menu);
+  const rect = menu.getBoundingClientRect();
+  menu.style.left = Math.max(8, Math.min(x, window.innerWidth - rect.width - 8)) + "px";
+  menu.style.top = Math.max(8, Math.min(y, window.innerHeight - rect.height - 8)) + "px";
+  const closer = (e) => {
+    if (!menu.contains(e.target)) {
+      menu.remove();
+      document.removeEventListener("click", closer, true);
+      document.removeEventListener("keydown", onKey);
+    }
+  };
+  const onKey = (e) => { if (e.key === "Escape") { menu.remove(); document.removeEventListener("click", closer, true); document.removeEventListener("keydown", onKey); } };
+  setTimeout(() => {
+    document.addEventListener("click", closer, true);
+    document.addEventListener("keydown", onKey);
+  }, 0);
+}
+
 /** Fichier partagé (créé ou reçu) → icône share-2 bleue, sinon icône usuelle. */
 function sharedFileIconSync(sharedPaths, itemName, vaultName, itemPath) {
   if (sharedPaths && sharedPaths.has(`${vaultName}::${itemPath}`)) return _sharedIcon();
@@ -494,6 +657,12 @@ async function incrementalLoadDirectory(vaultName, dirPath, container) {
     }
   });
 
+  // Coffre Secrets (Phase 1c) : même nœud virtuel que dans loadDirectory.
+  if (me && vaultName === `home-${me}` && !dirPath) {
+    const pair = await _buildSecretsNode(vaultName);
+    if (pair) fragment.insertBefore(pair, fragment.firstChild);
+  }
+
   // Replace container content in a single batch operation to avoid flash
   container.textContent = "";
   container.appendChild(fragment);
@@ -838,6 +1007,14 @@ async function loadDirectory(vaultName, dirPath, container) {
     }
   });
 
+  // Coffre Secrets (Phase 1c) : nœud virtuel permanent en tête, à la racine
+  // du Home de l'utilisateur courant seulement, jamais sous un autre Home
+  // ni sous un vault de notes, et jamais comme un dossier physique.
+  if (me && vaultName === `home-${me}` && !dirPath) {
+    const pair = await _buildSecretsNode(vaultName);
+    if (pair) fragment.insertBefore(pair, fragment.firstChild);
+  }
+
   container.appendChild(fragment);
   safeCreateIcons();
 }

frontend/js/themes.js

@@ -1,5 +1,5 @@
 /* ObsiGate — Theme System
- * 15 themes x 2 modes (dark/light)
+ * 16 themes x 2 modes (dark/light)
  * Persisted in localStorage as 'obsigate-theme'
  * Usage: import { initThemes, applyTheme, getCurrentTheme, THEMES } from './themes.js'
  */
@@ -45,6 +45,71 @@ var THEMES = {
     }
   },
 
+  // ── Thème Spark ──────────────────────────────────────────────────────
+  // Palette source : console Spark (agent.dracodev.net), app/console/console.css
+  // (variables --p-*). Mapping Spark -> ObsiGate, identique en structure pour
+  // dark et light ; seules les valeurs changent (sauf accent/ok/warn/err).
+  //  Fidèle (valeur Spark directe) :
+  //    fond -> --bg-primary, --surface2 ; surface -> --surface ;
+  //    chip -> --bg-secondary, --tag-bg ; chip-survol -> --bg-hover ;
+  //    bord -> --border ; chip-bord -> --border-md, --scrollbar, --resize-handle ;
+  //    texte -> --text-primary, --text ; doux -> --text-secondary, --text-2 ;
+  //    faint -> --text-muted, --text-3 ; champ -> --search-bg ;
+  //    code -> --code-bg ; accent -> --accent, --accent-card, --purple, --ai ;
+  //    lien -> --accent-text (variante lisible de l'accent sur fond teinté) ;
+  //    ok -> --accent-green, --success, --green ;
+  //    danger -> --danger ; danger-fond -> --danger-bg ;
+  //    pastilles ok (fond) -> --success-bg, --green-bg ;
+  //    pastilles ok (texte) -> --ok ; ambre -> --warn ; rouge -> --err.
+  //  Approximations documentées (ObsiGate a plus de variables que Spark,
+  //  ce ne sont PAS des valeurs Spark) :
+  //    --bg-sidebar <- fond (Spark n'a pas de token sidebar dédié) ;
+  //    --accent-bg <- agent (surface teintée de Spark, pas de teinte lavande) ;
+  //    --surface3 <- agent ; --purple-bg <- appro-fond (fond teinté le plus
+  //      proche, la palette Spark n'a pas de teinte lavande) ;
+  //    --overlay-bg <- convention ObsiGate (rgba noir 0.3 clair / 0.5 sombre,
+  //      aucun token voile dans la palette Spark).
+  //  Non reportés (aucune variable ObsiGate correspondante dans les 39) :
+  //    bulle utilisateur/envoi #2f6fed, titres approbation #9a6a1c / #e8bc7a.
+  //  Une seule entrée 'spark' : dark et light sont ses deux modes, jamais
+  //  deux thèmes séparés. Modes high-contrast/sepia générés comme pour les
+  //  autres thèmes (à partir de dark/light).
+  'spark': {
+    name: 'Spark', desc: 'Palette de la console Spark',
+    modes: {
+      dark: {
+        '--bg-primary': '#17181a', '--bg-secondary': '#26272b', '--bg-sidebar': '#17181a',
+        '--bg-hover': '#2e3036', '--border': '#33353a', '--text-primary': '#eceeeb',
+        '--text-secondary': '#a6aba0', '--text-muted': '#83887e', '--accent': '#7c5cd6',
+        '--accent-green': '#2ea36b', '--tag-bg': '#26272b', '--tag-text': '#7c5cd6',
+        '--code-bg': '#2c2e33', '--search-bg': '#1f2023', '--scrollbar': '#3a3c41',
+        '--resize-handle': '#3a3c41', '--overlay-bg': 'rgba(0,0,0,0.5)', '--danger': '#e8a08d',
+        '--danger-bg': '#40241f', '--success': '#2ea36b', '--success-bg': '#173d29',
+        '--accent-card': '#7c5cd6', '--accent-bg': '#26272b', '--accent-text': '#b39df5',
+        '--green': '#2ea36b', '--green-bg': '#173d29', '--purple': '#7c5cd6',
+        '--purple-bg': '#2a2118', '--surface': '#1f2023', '--surface2': '#17181a',
+        '--surface3': '#26272b', '--border-md': '#3a3c41', '--text': '#eceeeb',
+        '--text-2': '#a6aba0', '--text-3': '#83887e', '--ok': '#7fd6a8',
+        '--warn': '#e8a13c', '--ai': '#7c5cd6', '--err': '#cf4b32'
+      },
+      light: {
+        '--bg-primary': '#fbfbfa', '--bg-secondary': '#f4f5f1', '--bg-sidebar': '#fbfbfa',
+        '--bg-hover': '#e9ebe4', '--border': '#e4e5e0', '--text-primary': '#242624',
+        '--text-secondary': '#6c7268', '--text-muted': '#8a8f84', '--accent': '#7c5cd6',
+        '--accent-green': '#2ea36b', '--tag-bg': '#f4f5f1', '--tag-text': '#7c5cd6',
+        '--code-bg': '#e8eae3', '--search-bg': '#ffffff', '--scrollbar': '#d6d8d1',
+        '--resize-handle': '#d6d8d1', '--overlay-bg': 'rgba(0,0,0,0.3)', '--danger': '#a03a28',
+        '--danger-bg': '#f6e3de', '--success': '#2ea36b', '--success-bg': '#dff2e7',
+        '--accent-card': '#7c5cd6', '--accent-bg': '#eef0ea', '--accent-text': '#5b3df0',
+        '--green': '#2ea36b', '--green-bg': '#dff2e7', '--purple': '#7c5cd6',
+        '--purple-bg': '#fdf6ec', '--surface': '#ffffff', '--surface2': '#fbfbfa',
+        '--surface3': '#eef0ea', '--border-md': '#d6d8d1', '--text': '#242624',
+        '--text-2': '#6c7268', '--text-3': '#8a8f84', '--ok': '#1d7a4c',
+        '--warn': '#e8a13c', '--ai': '#7c5cd6', '--err': '#cf4b32'
+      }
+    }
+  },
+
   'github': {
     name: 'GitHub', desc: 'Contraste doux',
     modes: {
@@ -523,7 +588,7 @@ var THEMES = {
 };
 
 // ── Theme Engine ─────────────────────────────────────────────────────
-var _currentTheme = 'defaut-obsigate';
+var _currentTheme = 'spark';
 var _currentMode = 'dark';
 
 var AVAILABLE_MODES = ['dark', 'light', 'high-contrast', 'sepia'];
@@ -588,7 +653,7 @@ function applyTheme(themeKey, mode) {
     root.style.setProperty(key, vars[key]);
   });
   // #180 — the spreadsheet grid follows the active theme: derive its tokens
-  // from the generic surfaces so every theme (15 built-in × 4 modes, custom
+  // from the generic surfaces so every theme (16 built-in × 4 modes, custom
   // imports) gets a matching grid instead of the hardcoded dark/light pair.
   // color-mix keeps the zebra stripe subtle on both dark and light grounds.
   // #185 — `--grid-border` no longer reuses `--border` (which sits 1-2% off the

frontend/locales/en.json

@@ -2666,5 +2666,107 @@
     "guide105.dl_md_title": "Download this guide as Markdown",
     "guide105.dl_pdf_title": "Download this guide as PDF",
     "guide105.export_title": "ObsiGate User Guide",
-    "guide105.export_footer": "Generated from ObsiGate {version} — {date}. This document mirrors the in-app guide; the latest version always lives in the application."
+    "guide105.export_footer": "Generated from ObsiGate {version} — {date}. This document mirrors the in-app guide; the latest version always lives in the application.",
+  "coffres.acces": "Access and consumers",
+  "coffres.actions": "Actions",
+  "coffres.active": "Active",
+  "coffres.confirm_dek_rotate": "Rotate this vault's DEK? Secrets will be re-encrypted, with no change for consumers.",
+  "coffres.confirm_delete": "Delete this secret? The following grants will break:",
+  "coffres.confirm_revoke_consumer": "Revoke this consumer? All of its distributions will be denied.",
+  "coffres.confirm_revoke_octroi": "Revoke this grant? Access will be denied on the next call.",
+  "coffres.consumer_no_distribution": "No distribution in the recent log.",
+  "coffres.consumers": "Consumers",
+  "coffres.copied": "Copied.",
+  "coffres.copy_failed": "Copy failed.",
+  "coffres.copy_generated": "Copy the generated value",
+  "coffres.copy_reference": "Copy",
+  "coffres.create_coffre_title": "New vault",
+  "coffres.create_octroi": "Create a grant",
+  "coffres.create_secret_title": "New secret",
+  "coffres.created": "Created",
+  "coffres.dek_rotate": "Rotate DEK",
+  "coffres.delete": "Delete",
+  "coffres.deleted": "Secret deleted.",
+  "coffres.description": "Description",
+  "coffres.detail": "Details",
+  "coffres.disabled": "Secret vaults are disabled on this instance (OBSIGATE_SECRETS_ENABLED).",
+  "coffres.expiration": "Expiration",
+  "coffres.expired": "Expired",
+  "coffres.expires": "Expires",
+  "coffres.expiring_soon": "Expiring soon",
+  "coffres.generate": "Generate",
+  "coffres.generate_unavailable": "Generation is unavailable in this browser.",
+  "coffres.grant_all_coffre": "Whole vault",
+  "coffres.journal": "Access log",
+  "coffres.kek_absente": "Master key missing: metadata is visible, but no secret can be created or distributed.",
+  "coffres.kek_generate": "Generate a KEK",
+  "coffres.kek_generate_hint": "The generated KEK is returned only once and is never stored by ObsiGate: back it up outside the repository immediately.",
+  "coffres.kek_new": "New KEK",
+  "coffres.kek_ok": "Master key configured.",
+  "coffres.kek_once_hint": "Copy it now and back it up outside the repository: it will never be shown again.",
+  "coffres.kek_rotate": "Rotate KEK",
+  "coffres.kek_rotated": "KEK rotated. Remember to replace the KEK in the environment or KEK file.",
+  "coffres.kek_rotation_hint": "After rotation, replace the KEK in the environment or KEK file, otherwise distributions will fail.",
+  "coffres.last_use": "Last use",
+  "coffres.loading": "Loading vaults…",
+  "coffres.manual_copy": "One-time manual copy",
+  "coffres.manual_copy_admin_only": "Admin only (no session-based distribution endpoint exists yet on the backend).",
+  "coffres.manual_copy_confirm": "A temporary consumer will be created, the value will be copied to the clipboard without being shown, then the consumer will be revoked immediately. The distribution will be audited.",
+  "coffres.modified": "Modified",
+  "coffres.name": "Name",
+  "coffres.name_hint": "Lowercase, digits, - or _ ; 3 to 128 characters (e.g. gitea-token).",
+  "coffres.name_required": "A name is required.",
+  "coffres.never_in_note": "Never paste the value into the note.",
+  "coffres.new_coffre": "New vault",
+  "coffres.new_consumer": "New consumer",
+  "coffres.new_secret": "New secret",
+  "coffres.no_coffre": "No visible vault.",
+  "coffres.no_secrets": "No secret in this vault.",
+  "coffres.note": "Note",
+  "coffres.octroi_created": "Grant created.",
+  "coffres.octroi_default_90": "Empty = default expiration (90 days).",
+  "coffres.octroi_no_expiration": "No expiration",
+  "coffres.octroi_revoked": "Grant revoked.",
+  "coffres.octrois": "Grants",
+  "coffres.perimetre": "Scope",
+  "coffres.propose_octroi": "Propose a grant (optional)",
+  "coffres.reference": "Reference",
+  "coffres.revoke": "Revoke",
+  "coffres.rotated": "Secret rotated: the new version is active.",
+  "coffres.rotation": "Rotate",
+  "coffres.rotation_title": "Rotate secret",
+  "coffres.save": "Save",
+  "coffres.saved": "Secret saved. The value will no longer be shown.",
+  "coffres.search_placeholder": "Filter secrets…",
+  "coffres.secret": "Secret",
+  "coffres.secret_saved_octroi_failed": "Secret saved, but the grant failed",
+  "coffres.secrets": "Secrets",
+  "coffres.select_secret": "Select a secret to see its metadata.",
+  "coffres.service": "Service",
+  "coffres.show_before_save": "Show before saving",
+  "coffres.slug": "Slug",
+  "coffres.slug_hint": "Lowercase, digits, - or _ ; 3 to 64 characters.",
+  "coffres.status": "Status",
+  "coffres.subtitle": "Secret vaults — metadata only, a value is never shown again after it is saved.",
+  "coffres.target_id": "Target id",
+  "coffres.target_id_required": "A target id is required.",
+  "coffres.target_type": "Target type",
+  "coffres.title": "Secrets",
+  "coffres.token_once": "Token (shown only once)",
+  "coffres.token_once_hint": "Copy it now: it will never be shown again.",
+  "coffres.type": "Type",
+  "coffres.value": "Value",
+  "coffres.value_required": "A value is required.",
+  "coffres.version": "Version",
+  "coffres.import_existing": "Import existing",
+  "coffres.import_title": "Import existing keys",
+  "coffres.import_has_value": "Value present",
+  "coffres.import_no_value": "No value",
+  "coffres.import_already_exists": "Already in the vault",
+  "coffres.import_migrated": "Migrated",
+  "coffres.import_warning": "The AI and tool keys from data/api_keys.json will be copied into the instance vault “ObsiGate interne”. Import deletes nothing. Clearing the plaintext is a separate step, to confirm explicitly — note: the current readers (AI, tools) still read api_keys.json, so clearing deprives them of the key until their reader is wired to the vault.",
+  "coffres.import_done": "Import finished",
+  "coffres.import_purge": "Delete plaintext",
+  "coffres.import_purge_confirm": "Permanently delete the following migrated keys from plaintext? This cannot be undone without restoring the file:",
+  "coffres.import_purged": "Plaintext deleted"
 }

frontend/locales/fr.json

@@ -2666,5 +2666,107 @@
     "guide105.dl_md_title": "Télécharger ce guide en Markdown",
     "guide105.dl_pdf_title": "Télécharger ce guide en PDF",
     "guide105.export_title": "Guide d'utilisation ObsiGate",
-    "guide105.export_footer": "Généré depuis ObsiGate {version} — {date}. Ce document est la copie du guide intégré ; la version la plus récente est toujours dans l'application."
+    "guide105.export_footer": "Généré depuis ObsiGate {version} — {date}. Ce document est la copie du guide intégré ; la version la plus récente est toujours dans l'application.",
+  "coffres.acces": "Accès et consommateurs",
+  "coffres.actions": "Actions",
+  "coffres.active": "Actif",
+  "coffres.confirm_dek_rotate": "Pivoter la DEK de ce coffre ? Les secrets seront re-chiffrés, sans changement pour les consommateurs.",
+  "coffres.confirm_delete": "Supprimer ce secret ? Les octrois suivants seront cassés :",
+  "coffres.confirm_revoke_consumer": "Révoquer ce consommateur ? Toutes ses distributions seront refusées.",
+  "coffres.confirm_revoke_octroi": "Révoquer cet octroi ? L'accès sera refusé dès le prochain appel.",
+  "coffres.consumer_no_distribution": "Aucune distribution dans le journal récent.",
+  "coffres.consumers": "Consommateurs",
+  "coffres.copied": "Copié.",
+  "coffres.copy_failed": "Copie impossible.",
+  "coffres.copy_generated": "Copier la valeur générée",
+  "coffres.copy_reference": "Copier",
+  "coffres.create_coffre_title": "Nouveau coffre",
+  "coffres.create_octroi": "Créer un octroi",
+  "coffres.create_secret_title": "Nouveau secret",
+  "coffres.created": "Créé",
+  "coffres.dek_rotate": "Rotation DEK",
+  "coffres.delete": "Supprimer",
+  "coffres.deleted": "Secret supprimé.",
+  "coffres.description": "Description",
+  "coffres.detail": "Détail",
+  "coffres.disabled": "Les coffres de secrets sont désactivés sur cette instance (OBSIGATE_SECRETS_ENABLED).",
+  "coffres.expiration": "Expiration",
+  "coffres.expired": "Expiré",
+  "coffres.expires": "Expire",
+  "coffres.expiring_soon": "Expire bientôt",
+  "coffres.generate": "Générer",
+  "coffres.generate_unavailable": "Génération indisponible dans ce navigateur.",
+  "coffres.grant_all_coffre": "Tout le coffre",
+  "coffres.journal": "Journal d'accès",
+  "coffres.kek_absente": "Clé maître absente : les métadonnées sont visibles, mais aucun secret ne peut être créé ou distribué.",
+  "coffres.kek_generate": "Générer une KEK",
+  "coffres.kek_generate_hint": "La KEK générée n'est rendue qu'une fois et n'est jamais stockée par ObsiGate : sauvegardez-la hors dépôt immédiatement.",
+  "coffres.kek_new": "Nouvelle KEK",
+  "coffres.kek_ok": "Clé maître configurée.",
+  "coffres.kek_once_hint": "Copiez-la maintenant et sauvegardez-la hors dépôt : elle ne sera plus jamais affichée.",
+  "coffres.kek_rotate": "Rotation KEK",
+  "coffres.kek_rotated": "KEK pivotée. Pensez à remplacer la KEK dans l'environnement ou le fichier KEK.",
+  "coffres.kek_rotation_hint": "Après la rotation, remplacez la KEK dans l'environnement ou le fichier KEK, sinon les distributions échoueront.",
+  "coffres.last_use": "Dernière utilisation",
+  "coffres.loading": "Chargement des coffres…",
+  "coffres.manual_copy": "Copie manuelle à usage unique",
+  "coffres.manual_copy_admin_only": "Réservée aux administrateurs (aucun endpoint de distribution par session n'existe encore côté backend).",
+  "coffres.manual_copy_confirm": "Un consommateur temporaire sera créé, la valeur sera copiée au presse-papiers sans être affichée, puis le consommateur sera révoqué immédiatement. La distribution sera auditée.",
+  "coffres.modified": "Modifié",
+  "coffres.name": "Nom",
+  "coffres.name_hint": "Minuscules, chiffres, - ou _ ; 3 à 128 caractères (ex. gitea-token).",
+  "coffres.name_required": "Un nom est requis.",
+  "coffres.never_in_note": "Ne collez jamais la valeur dans la note.",
+  "coffres.new_coffre": "Nouveau coffre",
+  "coffres.new_consumer": "Nouveau consommateur",
+  "coffres.new_secret": "Nouveau secret",
+  "coffres.no_coffre": "Aucun coffre visible.",
+  "coffres.no_secrets": "Aucun secret dans ce coffre.",
+  "coffres.note": "Note",
+  "coffres.octroi_created": "Octroi créé.",
+  "coffres.octroi_default_90": "Vide = expiration par défaut (90 jours).",
+  "coffres.octroi_no_expiration": "Sans expiration",
+  "coffres.octroi_revoked": "Octroi révoqué.",
+  "coffres.octrois": "Octrois",
+  "coffres.perimetre": "Périmètre",
+  "coffres.propose_octroi": "Proposer un octroi (optionnel)",
+  "coffres.reference": "Référence",
+  "coffres.revoke": "Révoquer",
+  "coffres.rotated": "Secret pivoté : la nouvelle version est active.",
+  "coffres.rotation": "Rotation",
+  "coffres.rotation_title": "Rotation du secret",
+  "coffres.save": "Enregistrer",
+  "coffres.saved": "Secret enregistré. La valeur ne sera plus affichée.",
+  "coffres.search_placeholder": "Filtrer les secrets…",
+  "coffres.secret": "Secret",
+  "coffres.secret_saved_octroi_failed": "Secret enregistré, mais l'octroi a échoué",
+  "coffres.secrets": "Secrets",
+  "coffres.select_secret": "Sélectionnez un secret pour voir ses métadonnées.",
+  "coffres.service": "Service",
+  "coffres.show_before_save": "Afficher avant l'enregistrement",
+  "coffres.slug": "Identifiant (slug)",
+  "coffres.slug_hint": "Minuscules, chiffres, - ou _ ; 3 à 64 caractères.",
+  "coffres.status": "Statut",
+  "coffres.subtitle": "Coffres de secrets — métadonnées seules, aucune valeur n'est jamais affichée après l'enregistrement.",
+  "coffres.target_id": "Identifiant de la cible",
+  "coffres.target_id_required": "L'identifiant de la cible est requis.",
+  "coffres.target_type": "Type de cible",
+  "coffres.title": "Secrets",
+  "coffres.token_once": "Jeton (affiché une seule fois)",
+  "coffres.token_once_hint": "Copiez-le maintenant : il ne sera plus jamais affiché.",
+  "coffres.type": "Type",
+  "coffres.value": "Valeur",
+  "coffres.value_required": "Une valeur est requise.",
+  "coffres.version": "Version",
+  "coffres.import_existing": "Importer l'existant",
+  "coffres.import_title": "Importer les clés existantes",
+  "coffres.import_has_value": "Valeur présente",
+  "coffres.import_no_value": "Aucune valeur",
+  "coffres.import_already_exists": "Déjà dans le coffre",
+  "coffres.import_migrated": "Migré",
+  "coffres.import_warning": "Les clés IA et clés d'outils de data/api_keys.json seront copiées dans le coffre d'instance « ObsiGate interne ». L'import ne supprime rien. La purge du clair est une étape séparée, à confirmer explicitement — attention : les lecteurs actuels (IA, outils) lisent encore api_keys.json, la purge les prive donc de la clé tant que leur lecteur n'est pas branché sur le coffre.",
+  "coffres.import_done": "Import terminé",
+  "coffres.import_purge": "Supprimer le clair",
+  "coffres.import_purge_confirm": "Supprimer définitivement du clair les clés migrées suivantes ? Cette action est irréversible sans restauration du fichier :",
+  "coffres.import_purged": "Clair supprimé"
 }

frontend/style.css

@@ -11,58 +11,58 @@
 
 /* ── Editor save dot state colors ── */
 :root {
-  --ok: #34d399;
-  --warn: #fbbf24;
-  --ai: #8b5cf6;
-  --err: #f87171;
+  --ok: #7fd6a8;
+  --warn: #e8a13c;
+  --ai: #7c5cd6;
+  --err: #cf4b32;
 }
 
 /* ===== THEME — DARK (fallback default, no data-theme) ===== */
 :root {
-  --bg-primary: #0f1117;
-  --bg-secondary: #161b22;
-  --bg-sidebar: #13161d;
-  --bg-hover: #1f2430;
-  --border: #21262d;
-  --text-primary: #e6edf3;
-  --text-secondary: #8b949e;
-  --text-muted: #484f58;
-  --accent: #58a6ff;
-  --accent-green: #3fb950;
-  --tag-bg: #1f2a3a;
-  --tag-text: #79c0ff;
-  --code-bg: #161b22;
-  --search-bg: #21262d;
-  --scrollbar: #30363d;
-  --resize-handle: #30363d;
+  --bg-primary: #17181a;
+  --bg-secondary: #26272b;
+  --bg-sidebar: #17181a;
+  --bg-hover: #2e3036;
+  --border: #33353a;
+  --text-primary: #eceeeb;
+  --text-secondary: #a6aba0;
+  --text-muted: #83887e;
+  --accent: #7c5cd6;
+  --accent-green: #2ea36b;
+  --tag-bg: #26272b;
+  --tag-text: #7c5cd6;
+  --code-bg: #2c2e33;
+  --search-bg: #1f2023;
+  --scrollbar: #3a3c41;
+  --resize-handle: #3a3c41;
   --overlay-bg: rgba(0, 0, 0, 0.5);
-  --danger: #ff7b72;
-  --danger-bg: #3d1a18;
-  --success: #3fb950;
-  --success-bg: #1a3d1f;
-  --accent-card: #58a6ff;
-  --accent-bg: #1f2a3a;
-  --accent-text: #79c0ff;
-  --green: #3fb950;
-  --green-bg: #1a3d1f;
-  --purple: #a371f7;
-  --purple-bg: #2d1b4e;
-  --surface: #161b22;
-  --surface2: #0f1117;
-  --surface3: #0d0f14;
-  --border-md: #30363d;
-  --text: #e6edf3;
-  --text-2: #8b949e;
-  --text-3: #484f58;
+  --danger: #e8a08d;
+  --danger-bg: #40241f;
+  --success: #2ea36b;
+  --success-bg: #173d29;
+  --accent-card: #7c5cd6;
+  --accent-bg: #26272b;
+  --accent-text: #b39df5;
+  --green: #2ea36b;
+  --green-bg: #173d29;
+  --purple: #7c5cd6;
+  --purple-bg: #2a2118;
+  --surface: #1f2023;
+  --surface2: #17181a;
+  --surface3: #26272b;
+  --border-md: #3a3c41;
+  --text: #eceeeb;
+  --text-2: #a6aba0;
+  --text-3: #83887e;
   --mono: "JetBrains Mono", monospace;
   --radius: 6px;
   --radius-lg: 10px;
   /* #154-A1 — data-grid tokens: the sheet reads slightly lighter than the
      chrome (toolbar/panels), headers are clearly distinct from cells. */
-  --grid-bg: #161b22;
-  --grid-header-bg: #1f2430;
-  --grid-header-text: #e6edf3;
-  --grid-border: #3d444d;
+  --grid-bg: #1f2023;
+  --grid-header-bg: #2e3036;
+  --grid-header-text: #eceeeb;
+  --grid-border: #33353a;
   --grid-zebra: rgba(255, 255, 255, 0.025);
 }
 
@@ -7700,6 +7700,8 @@ body.popup-mode .content-area {
   display: flex;
   align-items: center;
   justify-content: center;
+  padding: 16px;
+  box-sizing: border-box;
   opacity: 0;
   pointer-events: none;
   transition: opacity 200ms ease;
@@ -7715,8 +7717,16 @@ body.popup-mode .content-area {
   border: 1px solid var(--border);
   border-radius: 12px;
   box-shadow: 0 16px 48px rgba(0, 0, 0, 0.5);
-  min-width: 400px;
-  max-width: 600px;
+  /* Correctif Phase 2 (modale de création de secret coupée en haut) :
+     sans max-height ni scroll interne, un formulaire long dépassait le
+     viewport. La modale est désormais bornée au viewport, en colonne
+     flex, avec seul le corps qui défile ; l'en-tête et le pied restent
+     toujours visibles. Sur petit écran, la largeur est bornée aussi. */
+  min-width: min(400px, calc(100vw - 32px));
+  max-width: min(600px, calc(100vw - 32px));
+  max-height: calc(100dvh - 32px);
+  display: flex;
+  flex-direction: column;
   transform: scale(0.9);
   transition: transform 200ms ease;
 }
@@ -7731,6 +7741,7 @@ body.popup-mode .content-area {
   display: flex;
   align-items: center;
   justify-content: space-between;
+  flex-shrink: 0;
 }
 
 .obsigate-modal-title {
@@ -7742,6 +7753,8 @@ body.popup-mode .content-area {
 
 .obsigate-modal-body {
   padding: 20px;
+  overflow-y: auto;
+  min-height: 0;
 }
 
 .obsigate-modal-footer {
@@ -7750,6 +7763,7 @@ body.popup-mode .content-area {
   display: flex;
   gap: 10px;
   justify-content: flex-end;
+  flex-shrink: 0;
 }
 
 .modal-input {
@@ -14331,3 +14345,35 @@ body.has-draco-bar .app-container { height: calc(100vh - 60px); }
   color: var(--text-primary); font: inherit; font-size: 13.5px;
 }
 .draco-liens-erreur { color: var(--err); font-size: 13px; margin: 8px 0 0; }
+
+/* ---------------------------------------------------------------------------
+ * Coffre Secrets (Phase 1c, issue #19) — vue Secrets + nœud sidebar.
+ * Réutilise les variables de thème existantes ; aucune valeur de secret
+ * n'est jamais affichée par ces styles (colonne valeur = •••••• en texte).
+ * --------------------------------------------------------------------------- */
+.coffres-view { padding: 16px 20px; max-width: 1100px; }
+.coffres-subtitle { color: var(--text-muted); margin: 0 0 12px; }
+.coffres-banner { padding: 10px 12px; margin: 12px 0; background: var(--bg-secondary, #161b22); border: 1px solid var(--border, #21262d); border-radius: 8px; display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+.coffres-banner.warn { border-color: var(--warning, #f59e0b); }
+.coffres-chips { display: flex; gap: 8px; flex-wrap: wrap; margin: 12px 0; }
+.coffres-chip { white-space: nowrap; }
+.coffres-actions { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; margin: 12px 0; }
+.coffres-actions .modal-input { flex: 1 1 220px; }
+.coffres-table { width: 100%; border-collapse: collapse; margin: 12px 0; }
+.coffres-table th, .coffres-table td { text-align: left; padding: 8px 10px; border-bottom: 1px solid var(--border, #21262d); vertical-align: top; }
+.coffres-table tbody tr { cursor: pointer; }
+.coffres-table tbody tr:hover { background: var(--bg-hover, #1f2430); }
+.coffres-detail { margin-top: 16px; padding: 14px; background: var(--bg-secondary, #161b22); border: 1px solid var(--border, #21262d); border-radius: 8px; }
+.coffres-dl { display: grid; grid-template-columns: 160px 1fr; gap: 4px 12px; margin: 12px 0; }
+.coffres-dl dt { color: var(--text-muted); }
+.coffres-dl dd { margin: 0; overflow-wrap: anywhere; }
+.coffres-line { padding: 6px 0; border-bottom: 1px solid var(--border, #21262d); display: flex; gap: 8px; align-items: center; flex-wrap: wrap; justify-content: space-between; }
+.coffres-empty { color: var(--text-muted); }
+.coffres-alerts { margin: 12px 0; }
+.coffres-alert { color: var(--warning, #f59e0b); padding: 2px 0; }
+.coffres-form { display: grid; gap: 8px; max-width: 560px; margin: 8px 0; }
+.coffres-icon-lock { font-size: 16px; line-height: 1; }
+.coffres-alert-dot { color: var(--warning, #f59e0b); font-weight: 700; margin-left: 4px; }
+.coffres-context-menu { position: fixed; z-index: 1000; min-width: 220px; background: var(--bg-secondary, #161b22); border: 1px solid var(--border, #21262d); border-radius: 8px; padding: 4px; box-shadow: 0 8px 24px rgba(0, 0, 0, 0.4); }
+.coffres-context-item { display: block; width: 100%; text-align: left; padding: 8px 12px; background: transparent; border: none; color: var(--text-primary, #e6edf3); cursor: pointer; border-radius: 6px; }
+.coffres-context-item:hover { background: var(--bg-hover, #1f2430); }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsigate",
-  "version": "2.73.1",
+  "version": "2.81.0",
   "description": "**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.",
   "main": "patch.js",
   "directories": {

tests/test_agent_journal.py

@@ -0,0 +1,302 @@
+"""Émission d'événements vers le journal du service d'agents (#220,
+Fusion Lot 2 vague 5 — contrat ACC-0.2).
+
+Un faux récepteur local capture les POST signés HMAC et les vérifie
+comme le fait le service d'agents ; on prouve aussi l'inactivité sans
+clé, la non-régression métier quand le récepteur est en panne, et le
+garde-fou central : le watcher / l'indexation n'émettent JAMAIS
+(seules les écritures explicites via l'API ou les outils le font).
+"""
+
+import asyncio
+import hashlib
+import hmac
+import json
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from types import SimpleNamespace
+
+import pytest
+
+CLE = "cle-obsigate-de-test"
+
+
+class _Recepteur(BaseHTTPRequestHandler):
+    recus = []
+
+    def do_POST(self):
+        n = int(self.headers.get("Content-Length") or 0)
+        corps = self.rfile.read(n)
+        type(self).recus.append(
+            {"headers": {k.lower(): v for k, v in self.headers.items()},
+             "corps": corps})
+        self.send_response(201)
+        self.end_headers()
+
+    def log_message(self, *a):
+        pass
+
+
+def _demarrer(monkeypatch):
+    _Recepteur.recus = []
+    serveur = HTTPServer(("127.0.0.1", 0), _Recepteur)
+    port = serveur.server_address[1]
+    threading.Thread(target=serveur.serve_forever, daemon=True).start()
+    monkeypatch.setenv("AGENT_EVENEMENTS_URL",
+                       f"http://127.0.0.1:{port}/api/v1/evenements")
+    monkeypatch.setenv("AGENT_EVENEMENTS_CLE", CLE)
+    return serveur
+
+
+def _attendre(types, delai=6.0):
+    """Attend que chaque type demandé soit arrivé ; retourne
+    {type: enveloppe} — la signature HMAC de CHAQUE envoi est
+    revérifiée ici, comme le fait le service."""
+    vus = {}
+    fin = time.time() + delai
+    while time.time() < fin and not all(t in vus for t in types):
+        for recu in list(_Recepteur.recus):
+            env = json.loads(recu["corps"].decode("utf-8"))
+            sig = recu["headers"].get("x-draco-signature", "")
+            attendu = hmac.new(CLE.encode(), recu["corps"],
+                               hashlib.sha256).hexdigest()
+            assert hmac.compare_digest(sig.lower(), attendu), \
+                "signature HMAC invalide"
+            vus.setdefault(env["type"], env)
+        if not all(t in vus for t in types):
+            time.sleep(0.05)
+    manquants = [t for t in types if t not in vus]
+    assert not manquants, f"événements jamais reçus : {manquants}"
+    return vus
+
+
+# ── Enveloppe ────────────────────────────────────────────────────────
+
+
+def test_enveloppe_et_signature(monkeypatch):
+    from backend import agent_journal
+
+    monkeypatch.setenv("AGENT_EVENEMENTS_CLE", CLE)
+    env, corps = agent_journal.construire_enveloppe(
+        agent_journal.TYPE_CREE, "TestVault", "Journal/nouvelle.md")
+    assert env["source_app"] == "obsigate"
+    assert env["domain"] == "pro"  # repli : aucun domaine modélisé (Q-A)
+    assert env["actor"] == "user"
+    assert env["object"] == {
+        "ref": "fichier:TestVault/Journal/nouvelle.md",
+        "label": "nouvelle.md",
+        "url": "/#file=TestVault:Journal/nouvelle.md",
+    }
+    assert json.loads(corps.decode("utf-8")) == env
+    assert env["id"] and env["occurred_at"]
+    sig = hmac.new(CLE.encode(), corps, hashlib.sha256).hexdigest()
+    assert len(sig) == 64
+
+
+def test_domaine_par_vault(monkeypatch):
+    from backend import agent_journal
+
+    monkeypatch.setenv("AGENT_EVENEMENTS_DOMAINES",
+                       json.dumps({"TestVault": "famille"}))
+    assert agent_journal.domaine_du_vault("TestVault") == "famille"
+    assert agent_journal.domaine_du_vault("AutreVault") == "pro"
+
+
+# ── Écritures REST (acteur « user ») ─────────────────────────────────
+
+
+def test_cycle_de_vie_rest(client, monkeypatch):
+    serveur = _demarrer(monkeypatch)
+    try:
+        r = client.post("/api/file/TestVault", json={
+            "path": "Journal/nouvelle.md", "content": "# Nouvelle\n"})
+        assert r.status_code == 200
+
+        r = client.put("/api/file/TestVault/save",
+                       params={"path": "Journal/nouvelle.md"},
+                       json={"content": "# Nouvelle v2\n"})
+        assert r.status_code == 200
+
+        r = client.patch("/api/file/TestVault", json={
+            "path": "Journal/nouvelle.md", "new_name": "renommee.md"})
+        assert r.status_code == 200
+
+        r = client.post("/api/move/TestVault", json={
+            "source_path": "Journal/renommee.md", "destination_dir": "Projets"})
+        assert r.status_code == 200
+
+        r = client.delete("/api/file/TestVault",
+                          params={"path": "Projets/renommee.md"})
+        assert r.status_code == 200
+
+        vus = _attendre([
+            "obsigate.note.created", "obsigate.note.edited",
+            "obsigate.note.moved", "obsigate.note.deleted"])
+
+        env = vus["obsigate.note.created"]
+        assert env["actor"] == "user"
+        assert env["object"]["ref"] == "fichier:TestVault/Journal/nouvelle.md"
+        assert env["object"]["label"] == "nouvelle.md"
+        assert env["object"]["url"] == "/#file=TestVault:Journal/nouvelle.md"
+
+        env = vus["obsigate.note.edited"]
+        assert env["object"]["ref"] == "fichier:TestVault/Journal/nouvelle.md"
+
+        # moved : émis deux fois (renommage puis déplacement). Les
+        # envois partent en fils d'arrière-plan — l'ordre d'arrivée
+        # n'est pas garanti, on compare l'ensemble des références.
+        refs_deplacees = {
+            json.loads(recu["corps"].decode("utf-8"))["object"]["ref"]
+            for recu in _Recepteur.recus
+            if json.loads(recu["corps"].decode("utf-8"))["type"]
+            == "obsigate.note.moved"}
+        assert refs_deplacees == {
+            "fichier:TestVault/Journal/renommee.md",
+            "fichier:TestVault/Projets/renommee.md"}
+
+        env = vus["obsigate.note.deleted"]
+        assert env["object"]["ref"] == "fichier:TestVault/Projets/renommee.md"
+    finally:
+        serveur.shutdown()
+
+
+# ── Écritures par les outils / MCP (acteur « agent:mcp ») ───────────
+
+
+@pytest.fixture
+def vault_outils(tmp_path, monkeypatch):
+    """Vault minimal pour la couche outils (patron test_document_tools)."""
+    import backend.indexer
+
+    vault_dir = tmp_path / "Vault"
+    vault_dir.mkdir()
+    monkeypatch.setitem(
+        backend.indexer.index, "Vault",
+        {"name": "Vault", "path": str(vault_dir), "config": {}})
+    return vault_dir
+
+
+def test_outils_mcp_emettent_agent_mcp(vault_outils, monkeypatch):
+    from backend.tools.api import ToolContext, ToolMode, call_tool
+
+    serveur = _demarrer(monkeypatch)
+    try:
+        ctx = ToolContext(
+            user={"username": "tester", "role": "admin", "vaults": ["*"]},
+            mode=ToolMode.MCP, audit_enabled=False)
+
+        out = call_tool("create_file", ctx, {
+            "vault": "Vault", "path": "par-mcp.md", "content": "# MCP\n",
+        }, confirm=True)
+        assert out.ok
+
+        out = call_tool("edit_file", ctx, {
+            "vault": "Vault", "path": "par-mcp.md", "content": "# MCP v2\n",
+        }, confirm=True)
+        assert out.ok
+
+        out = call_tool("rename_file", ctx, {
+            "vault": "Vault", "path": "par-mcp.md", "new_name": "renomme-mcp.md",
+        }, confirm=True)
+        assert out.ok
+
+        out = call_tool("delete_file", ctx, {
+            "vault": "Vault", "path": "renomme-mcp.md",
+        }, confirm=True)
+        assert out.ok
+
+        vus = _attendre([
+            "obsigate.note.created", "obsigate.note.edited",
+            "obsigate.note.moved", "obsigate.note.deleted"])
+        for env in vus.values():
+            assert env["actor"] == "agent:mcp"
+        assert vus["obsigate.note.created"]["object"]["ref"] == \
+            "fichier:Vault/par-mcp.md"
+        assert vus["obsigate.note.moved"]["object"]["ref"] == \
+            "fichier:Vault/renomme-mcp.md"
+    finally:
+        serveur.shutdown()
+
+
+# ── Inactivité sans clé ──────────────────────────────────────────────
+
+
+def test_inactif_sans_cle(client, monkeypatch):
+    serveur = _demarrer(monkeypatch)
+    monkeypatch.delenv("AGENT_EVENEMENTS_CLE")
+    try:
+        from backend import agent_journal
+
+        assert agent_journal.actif() is False
+        assert agent_journal.emettre(
+            agent_journal.TYPE_CREE, "TestVault", "x.md") is False
+        r = client.post("/api/file/TestVault", json={
+            "path": "sans-journal.md", "content": "# Rien\n"})
+        assert r.status_code == 200
+        time.sleep(0.6)
+        assert _Recepteur.recus == []
+    finally:
+        serveur.shutdown()
+
+
+# ── Garde-fou : watcher et indexation n'émettent jamais ─────────────
+
+
+def test_watcher_et_indexation_sans_evenement(client, test_vault_dir,
+                                              monkeypatch):
+    """Une écriture disque externe (éditeur, synchro de fichiers…)
+    traitée par le watcher puis l'indexeur ne produit AUCUN
+    événement : seuls les appels explicites à l'API émettent."""
+    from pathlib import Path
+
+    appels = []
+    monkeypatch.setattr(
+        "backend.agent_journal.emettre",
+        lambda *a, **k: appels.append((a, k)) or False)
+    monkeypatch.setenv("AGENT_EVENEMENTS_CLE", CLE)
+
+    cible = Path(test_vault_dir) / "externe.md"
+    cible.write_text("# Écrit hors API\n", encoding="utf-8")
+
+    # Chemin watcher : les gestionnaires d'événements filesystem.
+    from backend.watcher import VaultEventHandler
+
+    boucle = asyncio.new_event_loop()
+    try:
+        file_attente: asyncio.Queue = asyncio.Queue()
+        handler = VaultEventHandler("TestVault", file_attente, boucle)
+        evt = SimpleNamespace(is_directory=False, src_path=str(cible),
+                              dest_path=None)
+        handler.on_created(evt)
+        handler.on_modified(evt)
+
+        # Chemin indexation : la même fonction que le watcher appelle
+        # après debounce pour intégrer le fichier à l'index.
+        from backend.indexer import update_single_file
+
+        boucle.run_until_complete(update_single_file("TestVault", "externe.md"))
+    finally:
+        boucle.close()
+
+    assert appels == []
+
+
+# ── Panne du récepteur : le métier n'est jamais affecté ─────────────
+
+
+def test_recepteur_en_panne_ne_casse_rien(client, monkeypatch):
+    # Port fermé : connexion refusée dans le fil d'arrière-plan.
+    monkeypatch.setenv("AGENT_EVENEMENTS_URL",
+                       "http://127.0.0.1:59999/api/v1/evenements")
+    monkeypatch.setenv("AGENT_EVENEMENTS_CLE", CLE)
+    r = client.post("/api/file/TestVault", json={
+        "path": "malgre-panne.md", "content": "# OK\n"})
+    assert r.status_code == 200
+    r = client.put("/api/file/TestVault/save",
+                   params={"path": "malgre-panne.md"},
+                   json={"content": "# OK v2\n"})
+    assert r.status_code == 200
+    r = client.get("/api/file/TestVault", params={"path": "malgre-panne.md"})
+    assert r.status_code == 200
+    assert "OK v2" in r.json()["html"]  # le GET renvoie le Markdown rendu

tests/test_ci_workflow.py

@@ -251,11 +251,17 @@ class TestDependencySecurityFloors:
 
     #: (paquet, plancher minimal, advisories corrigées au-dessus)
     FLOORS = {
-        "pypdf": (6, 16, 1),  # PYSEC-2026-3910, PYSEC-2026-3911 (fix 6.16.1)
+        # #224 : 6.19.0 (toolcache) frappée par 11 CVE, corrigées au plus
+        # tard en 6.21.2 ; avant : PYSEC-2026-3910/3911 (fix 6.16.1).
+        "pypdf": (6, 21, 2),
         # BUG-095 : 2.13.0 a son propre advisory (CVE-2026-102274, fix 2.14.0).
         "pyjwt": (2, 14, 0),  # PYSEC-2026-178 (2.13.0) puis CVE-2026-102274 (2.14.0)
         "urllib3": (2, 8, 0),  # CVE-2026-97687, CVE-2026-97688, CVE-2026-97689 (fix 2.8.0)
         "multidict": (6, 9, 1),  # CVE-2026-104874 (fix 6.9.1 ; 6.7.x toolcache runner)
+        # #224 : transitives / préinstallées toolcache, auditées par pip-audit.
+        "brotli": (1, 2, 1),  # PYSEC-2026-4322, GHSA-9v8h-qqgm-4m35 (fix 1.2.1)
+        "filelock": (4, 2, 1),  # CVE-2026-112940, CVE-2026-112913, CVE-2026-112907 (fix 4.2.1)
+        "opentelemetry-api": (1, 45, 1),  # CVE-2026-114603 (fix 1.45.1)
     }
 
     def test_security_floors_are_declared(self):

tests/test_coffre_secrets.py

@@ -0,0 +1,680 @@
+"""Tests du coffre Secrets ObsiGate (Phase 1a / 1b, issues #17 et #18).
+
+Couverture exigée par les issues :
+- chiffrement/déchiffrement, tag invalide refusé, rotations (secret, DEK,
+  KEK), mode dégradé sans KEK ;
+- matrice d'autorisation, y compris admin contre coffre personnel d'autrui
+  et ACL « * » qui ne donne aucun droit sur un coffre ;
+- contexte manquant refusé, octroi révoqué refusé au prochain appel,
+  expiration respectée, audit complet sans valeur ;
+- lectures = métadonnées seules, jamais de valeur ni de texte chiffré.
+
+Toutes les valeurs de secret utilisées ici sont fictives et ne servent
+qu'aux tests. Le store est isolé par test via OBSIGATE_DATA_DIR et le
+journal d'audit via backend.audit.AUDIT_LOG_FILE.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import shutil
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pytest
+from fastapi import FastAPI, HTTPException
+from fastapi.testclient import TestClient
+
+from backend import audit as audit_module
+from backend.auth.middleware import require_admin, require_auth
+from backend.coffre_crypto import (
+    KEKAbsenteError,
+    KEKInvalideError,
+    TagInvalideError,
+    decrypt_secret_value,
+    encrypt_secret_value,
+    generate_dek,
+    generate_kek_b64,
+    load_kek,
+    parse_kek,
+    unwrap_dek,
+    wrap_dek,
+)
+from backend.coffre_store import (
+    CoffreExisteError,
+    SecretExpireError,
+    ValidationError,
+    create_coffre,
+    create_secret,
+    distribuer_valeur,
+    get_coffre_or_404,
+    rotate_dek,
+    rotate_kek,
+    rotate_secret,
+)
+from backend.routers.coffres import router as coffres_router
+
+VALEUR_TEST = "VALEUR-TEST-FICTIVE-7f3a9c-ne-pas-utiliser"
+VALEUR_TEST_2 = "VALEUR-TEST-FICTIVE-2-b4d8e1-ne-pas-utiliser"
+
+# Utilisateur courant injecté dans les routes via dependency_overrides.
+_COURANT = {"user": None}
+
+
+def _fake_auth():
+    if _COURANT["user"] is None:
+        raise HTTPException(status_code=401, detail="Authentification requise")
+    return _COURANT["user"]
+
+
+def _fake_admin():
+    user = _fake_auth()
+    if user.get("role") != "admin":
+        raise HTTPException(status_code=403, detail="Accès admin requis")
+    return user
+
+
+def _user(username: str, role: str = "user", vaults: list | None = None) -> dict:
+    return {
+        "username": username,
+        "role": role,
+        "vaults": vaults if vaults is not None else [f"home-{username}"],
+        "active": True,
+    }
+
+
+@pytest.fixture
+def env_coffre(tmp_path, monkeypatch):
+    """Environnement isolé : store, audit, KEK et feature flag."""
+    monkeypatch.setenv("OBSIGATE_SECRETS_ENABLED", "1")
+    monkeypatch.setenv("OBSIGATE_DATA_DIR", str(tmp_path))
+    monkeypatch.setenv("OBSIGATE_KEK", generate_kek_b64())
+    monkeypatch.delenv("OBSIGATE_KEK_FILE", raising=False)
+    monkeypatch.setattr(audit_module, "AUDIT_LOG_FILE", tmp_path / "audit.log")
+    _COURANT["user"] = _user("bruno", role="admin")
+    yield tmp_path
+    _COURANT["user"] = None
+
+
+@pytest.fixture
+def client(env_coffre):
+    app = FastAPI()
+    app.include_router(coffres_router)
+    app.dependency_overrides[require_auth] = _fake_auth
+    app.dependency_overrides[require_admin] = _fake_admin
+    with TestClient(app, raise_server_exceptions=False) as test_client:
+        yield test_client
+
+
+def _connecter(client, username: str, role: str = "user", vaults=None):
+    _COURANT["user"] = _user(username, role=role, vaults=vaults)
+
+
+def _creer_coffre_secret(client, slug="personnel", nom="gitea-token", valeur=VALEUR_TEST):
+    resp = client.post(
+        "/api/coffres",
+        json={"slug": slug, "nom": "Personnel", "perimetre": "personnel"},
+    )
+    assert resp.status_code == 200, resp.text
+    resp = client.post(
+        f"/api/coffres/{slug}/secrets",
+        json={
+            "nom": nom,
+            "type": "token",
+            "service": "Gitea",
+            "valeur": valeur,
+        },
+    )
+    assert resp.status_code == 200, resp.text
+    return resp.json()
+
+
+def _creer_consommateur_octroi(client, slug="personnel", nom="gitea-token"):
+    resp = client.post("/api/coffres/consommateurs", json={"nom": "spark"})
+    assert resp.status_code == 200, resp.text
+    consommateur = resp.json()
+    jeton = consommateur["jeton"]
+    resp = client.post(
+        f"/api/coffres/{slug}/octrois",
+        json={
+            "cible_type": "consommateur",
+            "cible_id": consommateur["id"],
+            "secret_nom": nom,
+        },
+    )
+    assert resp.status_code == 200, resp.text
+    return consommateur, jeton, resp.json()
+
+
+def _distribuer(client, jeton, reference="coffre:personnel/gitea-token",
+                contexte_type="mission", contexte_id="mission-test-1"):
+    return client.post(
+        "/api/coffres/distribuer",
+        json={
+            "reference": reference,
+            "contexte_type": contexte_type,
+            "contexte_id": contexte_id,
+        },
+        headers={"Authorization": f"Bearer {jeton}"},
+    )
+
+
+def _fichiers_sans_valeur(tmp_path, valeur=VALEUR_TEST):
+    for path in tmp_path.iterdir():
+        if path.is_file() and path.suffix in (".json", ".log"):
+            assert valeur not in path.read_text(encoding="utf-8"), path.name
+
+
+# ---------------------------------------------------------------------------
+# Crypto (Phase 1a)
+# ---------------------------------------------------------------------------
+
+class TestCrypto:
+    def test_aller_retour_aes_gcm(self):
+        kek = bytes(range(32))
+        dek = generate_dek()
+        wrapped = wrap_dek(dek, kek, "coffre-test")
+        assert unwrap_dek(wrapped, kek, "coffre-test") == dek
+        chiffre = encrypt_secret_value(dek, "secret-1", 1, VALEUR_TEST)
+        assert decrypt_secret_value(dek, "secret-1", 1, chiffre["nonce"], chiffre["ciphertext"]) == VALEUR_TEST
+
+    def test_tag_invalide_refuse(self):
+        dek = generate_dek()
+        chiffre = encrypt_secret_value(dek, "secret-1", 1, VALEUR_TEST)
+        alt = bytearray(base64.b64decode(chiffre["ciphertext"]))
+        alt[-1] ^= 1
+        chiffre_alt = {
+            "nonce": chiffre["nonce"],
+            "ciphertext": base64.b64encode(bytes(alt)).decode("ascii"),
+        }
+        with pytest.raises(TagInvalideError):
+            decrypt_secret_value(dek, "secret-1", 1, chiffre_alt["nonce"], chiffre_alt["ciphertext"])
+
+    def test_aad_incorrect_refuse(self):
+        dek = generate_dek()
+        chiffre = encrypt_secret_value(dek, "secret-1", 1, VALEUR_TEST)
+        with pytest.raises(TagInvalideError):
+            decrypt_secret_value(dek, "secret-2", 1, chiffre["nonce"], chiffre["ciphertext"])
+
+    def test_parse_kek_invalide(self, monkeypatch):
+        with pytest.raises(KEKInvalideError):
+            parse_kek("trop-court")
+        assert len(parse_kek(generate_kek_b64())) == 32
+
+    def test_kek_absente(self, tmp_path, monkeypatch):
+        monkeypatch.delenv("OBSIGATE_KEK", raising=False)
+        monkeypatch.delenv("OBSIGATE_KEK_FILE", raising=False)
+        with pytest.raises(KEKAbsenteError):
+            load_kek()
+
+    def test_kek_fichier_0600_ok_et_trop_permissif_refuse(self, tmp_path, monkeypatch):
+        kek_file = tmp_path / "kek.txt"
+        kek_file.write_text(generate_kek_b64(), encoding="utf-8")
+        os.chmod(kek_file, 0o600)
+        monkeypatch.delenv("OBSIGATE_KEK", raising=False)
+        monkeypatch.setenv("OBSIGATE_KEK_FILE", str(kek_file))
+        assert len(load_kek()) == 32
+        os.chmod(kek_file, 0o644)
+        with pytest.raises(KEKInvalideError):
+            load_kek()
+
+
+# ---------------------------------------------------------------------------
+# Store (Phase 1a)
+# ---------------------------------------------------------------------------
+
+class TestStore:
+    def test_roundtrip_et_aucun_clair_au_repos(self, env_coffre):
+        coffre = create_coffre("personnel", "Personnel", "bruno")
+        secret = create_secret(coffre, "gitea-token", "token", VALEUR_TEST, service="Gitea")
+        assert distribuer_valeur(coffre, secret) == VALEUR_TEST
+        _fichiers_sans_valeur(env_coffre)
+
+    def test_rotation_secret(self, env_coffre):
+        coffre = create_coffre("personnel", "Personnel", "bruno")
+        secret = create_secret(coffre, "gitea-token", "token", VALEUR_TEST)
+        secret = rotate_secret(coffre, "gitea-token", VALEUR_TEST_2)
+        assert secret["version_courante"] == 2
+        assert distribuer_valeur(coffre, secret) == VALEUR_TEST_2
+
+    def test_rotation_dek_puis_kek(self, env_coffre, monkeypatch):
+        coffre = create_coffre("personnel", "Personnel", "bruno")
+        secret = create_secret(coffre, "gitea-token", "token", VALEUR_TEST)
+        rotate_dek("personnel")
+        assert distribuer_valeur(get_coffre_or_404("personnel"), secret) == VALEUR_TEST
+        nouvelle_kek = generate_kek_b64()
+        assert rotate_kek(nouvelle_kek) == 1
+        monkeypatch.setenv("OBSIGATE_KEK", nouvelle_kek)
+        assert distribuer_valeur(get_coffre_or_404("personnel"), secret) == VALEUR_TEST
+
+    def test_mode_degrade_sans_kek(self, env_coffre, monkeypatch):
+        monkeypatch.delenv("OBSIGATE_KEK", raising=False)
+        coffre = create_coffre("personnel", "Personnel", "bruno")
+        assert coffre["dek_chiffree"] is None
+        with pytest.raises(KEKAbsenteError):
+            create_secret(coffre, "gitea-token", "token", VALEUR_TEST)
+
+    def test_validation_et_doublons(self, env_coffre):
+        coffre = create_coffre("personnel", "Personnel", "bruno")
+        with pytest.raises(ValidationError):
+            create_coffre("MAUVAIS SLUG !!", "X", "bruno")
+        with pytest.raises(CoffreExisteError):
+            create_coffre("personnel", "Autre", "bruno")
+        create_secret(coffre, "gitea-token", "token", VALEUR_TEST)
+        with pytest.raises(ValidationError):
+            create_secret(
+                coffre, "autre-secret", "token", VALEUR_TEST,
+                note="api-key: ceci-ressemble-a-un-secret",
+            )
+
+    def test_secret_expire_refuse_a_la_distribution(self, env_coffre):
+        coffre = create_coffre("personnel", "Personnel", "bruno")
+        hier = (datetime.now(timezone.utc) - timedelta(days=1)).isoformat()
+        secret = create_secret(
+            coffre, "vieux-jeton", "token", VALEUR_TEST, expiration=hier
+        )
+        with pytest.raises(SecretExpireError):
+            distribuer_valeur(coffre, secret)
+
+
+# ---------------------------------------------------------------------------
+# API et autorisations (Phase 1b)
+# ---------------------------------------------------------------------------
+
+class TestApiAutorisations:
+    def test_flag_desactive_repond_503(self, client, monkeypatch):
+        monkeypatch.setenv("OBSIGATE_SECRETS_ENABLED", "0")
+        assert client.get("/api/coffres").status_code == 503
+
+    def test_lectures_metadonnees_seules(self, client, env_coffre):
+        _creer_coffre_secret(client)
+        resp = client.get("/api/coffres/personnel/secrets")
+        assert resp.status_code == 200
+        corps = resp.text
+        assert VALEUR_TEST not in corps
+        assert "ciphertext" not in corps
+        assert "nonce" not in corps
+        item = resp.json()[0]
+        assert item["has_value"] is True
+        assert item["reference"] == "coffre:personnel/gitea-token"
+        assert "valeur" not in item
+
+    def test_admin_ne_voit_pas_le_coffre_personnel_d_autrui(self, client):
+        _creer_coffre_secret(client)  # propriétaire : bruno (admin de test)
+        _connecter(client, "alice", role="user")
+        assert client.get("/api/coffres/personnel").status_code == 403
+        assert client.get("/api/coffres/personnel/secrets").status_code == 403
+        # Même un admin avec vaults=["*"] n'a aucun droit sur un coffre
+        # personnel dont il n'est pas propriétaire.
+        _connecter(client, "admin2", role="admin", vaults=["*"])
+        assert client.get("/api/coffres/personnel").status_code == 403
+
+    def test_acl_etoile_ne_donne_aucun_droit_coffre(self, client):
+        _creer_coffre_secret(client)
+        _connecter(client, "mallory", role="user", vaults=["*"])
+        assert client.get("/api/coffres/personnel/secrets").status_code == 403
+
+    def test_coffre_instance_reserve_admin(self, client):
+        _connecter(client, "bruno", role="user")
+        resp = client.post(
+            "/api/coffres",
+            json={"slug": "instance", "nom": "Instance", "perimetre": "instance"},
+        )
+        assert resp.status_code == 403
+        _connecter(client, "bruno", role="admin")
+        resp = client.post(
+            "/api/coffres",
+            json={"slug": "instance", "nom": "Instance", "perimetre": "instance"},
+        )
+        assert resp.status_code == 200
+        _connecter(client, "alice", role="user")
+        assert client.get("/api/coffres/instance").status_code == 403
+
+    def test_creation_secret_sans_kek_repond_503(self, client, monkeypatch):
+        monkeypatch.delenv("OBSIGATE_KEK", raising=False)
+        resp = client.post("/api/coffres", json={"slug": "personnel", "nom": "Personnel"})
+        assert resp.status_code == 200  # métadonnées créées en mode dégradé
+        resp = client.post(
+            "/api/coffres/personnel/secrets",
+            json={"nom": "gitea-token", "type": "token", "valeur": VALEUR_TEST},
+        )
+        assert resp.status_code == 503
+        assert resp.json()["detail"] == "kek_absente"
+
+
+class TestDistribution:
+    def test_distribution_ok_puis_revoquee_puis_consommateur_revoque(self, client, env_coffre):
+        _creer_coffre_secret(client)
+        consommateur, jeton, octroi = _creer_consommateur_octroi(client)
+        resp = _distribuer(client, jeton)
+        assert resp.status_code == 200, resp.text
+        assert resp.json()["valeur"] == VALEUR_TEST
+        assert resp.json()["version"] == 1
+        # Le jeton complet n'est jamais relisté, ni son hash (seul le
+        # préfixe d'affichage, non exploitable, apparaît).
+        liste = client.get("/api/coffres/consommateurs").json()
+        assert jeton not in json.dumps(liste)
+        assert "jeton_hash" not in json.dumps(liste)
+        assert all(set(item.keys()) == {"id", "nom", "jeton_prefixe", "statut", "cree_par", "cree_le"} for item in liste)
+        # Révocation de l'octroi : refusé dès le prochain appel.
+        resp = client.delete(f"/api/coffres/octrois/{octroi['id']}")
+        assert resp.status_code == 200
+        resp = _distribuer(client, jeton)
+        assert resp.status_code == 403
+        assert resp.json()["detail"] == "octroi_revoque"
+        # Révocation du consommateur : tous ses octrois tombent.
+        resp = client.post(
+            "/api/coffres/personnel/octrois",
+            json={"cible_type": "consommateur", "cible_id": consommateur["id"], "secret_nom": "gitea-token"},
+        )
+        assert resp.status_code == 200
+        resp = client.delete(f"/api/coffres/consommateurs/{consommateur['id']}")
+        assert resp.status_code == 200
+        resp = _distribuer(client, jeton)
+        assert resp.status_code == 403
+        assert resp.json()["detail"] == "consommateur_revoque"
+
+    def test_contexte_manquant_refuse(self, client):
+        _creer_coffre_secret(client)
+        _, jeton, _ = _creer_consommateur_octroi(client)
+        resp = client.post(
+            "/api/coffres/distribuer",
+            json={"reference": "coffre:personnel/gitea-token"},
+            headers={"Authorization": f"Bearer {jeton}"},
+        )
+        assert resp.status_code == 400
+        assert resp.json()["detail"] == "contexte_manquant"
+
+    def test_session_utilisateur_ne_distribue_pas(self, client):
+        _creer_coffre_secret(client)
+        _creer_consommateur_octroi(client)
+        resp = _distribuer(client, "jeton-session-utilisateur-fictif")
+        assert resp.status_code == 401
+        assert resp.json()["detail"] == "consommateur_invalide"
+
+    def test_octroi_absent_et_secret_expire(self, client):
+        _creer_coffre_secret(client)
+        resp = client.post("/api/coffres/consommateurs", json={"nom": "sans-octroi"})
+        jeton = resp.json()["jeton"]
+        resp = _distribuer(client, jeton)
+        assert resp.status_code == 403
+        assert resp.json()["detail"] == "octroi_absent"
+        # Secret expiré : 410, même avec un octroi actif.
+        _connecter(client, "bruno", role="admin")
+        hier = (datetime.now(timezone.utc) - timedelta(days=1)).isoformat()
+        resp = client.post(
+            "/api/coffres/personnel/secrets",
+            json={"nom": "vieux-jeton", "type": "token", "valeur": VALEUR_TEST, "expiration": hier},
+        )
+        assert resp.status_code == 200
+        _, jeton2, _ = _creer_consommateur_octroi(client, nom="vieux-jeton")
+        resp = _distribuer(client, jeton2, reference="coffre:personnel/vieux-jeton")
+        assert resp.status_code == 410
+        assert resp.json()["detail"] == "secret_expire"
+
+    def test_rotation_change_la_valeur_distribuee(self, client):
+        _creer_coffre_secret(client)
+        _, jeton, _ = _creer_consommateur_octroi(client)
+        resp = client.post(
+            "/api/coffres/personnel/secrets/gitea-token/rotation",
+            json={"valeur": VALEUR_TEST_2},
+        )
+        assert resp.status_code == 200
+        assert resp.json()["version"] == 2
+        resp = _distribuer(client, jeton)
+        assert resp.json()["valeur"] == VALEUR_TEST_2
+
+    def test_suppression_casse_les_octrois(self, client):
+        _creer_coffre_secret(client)
+        _, jeton, _ = _creer_consommateur_octroi(client)
+        resp = client.delete("/api/coffres/personnel/secrets/gitea-token")
+        assert resp.status_code == 200
+        resp = _distribuer(client, jeton)
+        assert resp.status_code == 403
+        assert resp.json()["detail"] == "octroi_absent"
+
+    def test_octroi_par_defaut_90_jours(self, client):
+        _creer_coffre_secret(client)
+        _, _, octroi = _creer_consommateur_octroi(client)
+        expiration = datetime.fromisoformat(octroi["expiration"])
+        delta = expiration - datetime.now(timezone.utc)
+        assert 89 <= delta.days <= 91
+
+    def test_audit_sans_valeur_et_journal(self, client, env_coffre):
+        _creer_coffre_secret(client)
+        _, jeton, _ = _creer_consommateur_octroi(client)
+        assert _distribuer(client, jeton).status_code == 200
+        _fichiers_sans_valeur(env_coffre)
+        audit = (env_coffre / "audit.log").read_text(encoding="utf-8")
+        assert "distribution_ok" in audit
+        assert VALEUR_TEST not in audit
+        resp = client.get("/api/coffres/personnel/journal")
+        assert resp.status_code == 200
+        actions = [e["action"] for e in resp.json()]
+        assert "secret_cree" in actions
+        assert "distribution_ok" in actions
+        assert "valeur" not in json.dumps(resp.json())
+
+
+# ---------------------------------------------------------------------------
+# Phase 2 — Migration api_keys.json (issue #20)
+# ---------------------------------------------------------------------------
+
+class TestMigrationApiKeys:
+    def _ecrire_api_keys(self, tmp_path):
+        (tmp_path / "api_keys.json").write_text(
+            json.dumps(
+                {
+                    "DEEPSEEK_API_KEY": VALEUR_TEST,
+                    "OBSIGATE_GITEA_TOKEN": VALEUR_TEST_2,
+                    "OBSIGATE_GITEA_URL": "https://example.invalid",
+                    "MISTRAL_API_KEY": "",
+                }
+            ),
+            encoding="utf-8",
+        )
+
+    def test_apercu_import_purge(self, client, env_coffre):
+        self._ecrire_api_keys(env_coffre)
+        resp = client.get("/api/coffres/migration/api-keys")
+        assert resp.status_code == 200, resp.text
+        # Aperçu = métadonnées seules, jamais une valeur.
+        assert VALEUR_TEST not in resp.text
+        assert VALEUR_TEST_2 not in resp.text
+        candidats = {c["nom"]: c for c in resp.json()["candidats"]}
+        assert candidats["deepseek_api_key"]["has_value"] is True
+        assert candidats["mistral_api_key"]["has_value"] is False
+        assert "obsigate_gitea_url" not in candidats  # URL, pas un secret
+        # Import : ne supprime rien dans api_keys.json.
+        resp = client.post("/api/coffres/migration/api-keys/import", json={})
+        assert resp.status_code == 200, resp.text
+        resultat = resp.json()
+        assert resultat["coffre"] == "obsigate-interne"
+        assert "deepseek_api_key" in resultat["migres"]
+        assert "obsigate_gitea_token" in resultat["migres"]
+        assert "mistral_api_key" in resultat["sans_valeur"]
+        cles = json.loads((env_coffre / "api_keys.json").read_text(encoding="utf-8"))
+        assert cles["DEEPSEEK_API_KEY"] == VALEUR_TEST
+        # Les secrets migrés sont visibles en métadonnées et distribuables.
+        resp = client.get("/api/coffres/obsigate-interne/secrets")
+        assert resp.status_code == 200
+        assert VALEUR_TEST not in resp.text
+        assert any(s["nom"] == "deepseek_api_key" and s["has_value"] for s in resp.json())
+        _, jeton, _ = _creer_consommateur_octroi(
+            client, slug="obsigate-interne", nom="deepseek_api_key"
+        )
+        resp = _distribuer(
+            client, jeton, reference="coffre:obsigate-interne/deepseek_api_key"
+        )
+        assert resp.status_code == 200, resp.text
+        assert resp.json()["valeur"] == VALEUR_TEST
+        # Purge sans confirmation : refusée, fichier intact.
+        resp = client.post(
+            "/api/coffres/migration/api-keys/purger",
+            json={"confirmer": False, "noms": ["deepseek_api_key"]},
+        )
+        assert resp.status_code == 400
+        cles = json.loads((env_coffre / "api_keys.json").read_text(encoding="utf-8"))
+        assert "DEEPSEEK_API_KEY" in cles
+        # Purge confirmée : seules les clés listées disparaissent.
+        resp = client.post(
+            "/api/coffres/migration/api-keys/purger",
+            json={"confirmer": True, "noms": ["deepseek_api_key", "obsigate_gitea_token"]},
+        )
+        assert resp.status_code == 200, resp.text
+        assert set(resp.json()["supprimes"]) == {
+            "deepseek_api_key",
+            "obsigate_gitea_token",
+        }
+        cles = json.loads((env_coffre / "api_keys.json").read_text(encoding="utf-8"))
+        assert "DEEPSEEK_API_KEY" not in cles
+        assert "OBSIGATE_GITEA_TOKEN" not in cles
+        assert cles["OBSIGATE_GITEA_URL"] == "https://example.invalid"
+        # Audit sans valeur.
+        _fichiers_sans_valeur(env_coffre)
+        audit = (env_coffre / "audit.log").read_text(encoding="utf-8")
+        assert "migration_api_keys" in audit
+        assert "migration_api_keys_purge" in audit
+
+    def test_import_ne_ecrase_pas_existant(self, client, env_coffre):
+        self._ecrire_api_keys(env_coffre)
+        assert client.post("/api/coffres/migration/api-keys/import", json={}).status_code == 200
+        (env_coffre / "api_keys.json").write_text(
+            json.dumps({"DEEPSEEK_API_KEY": VALEUR_TEST_2}), encoding="utf-8"
+        )
+        resp = client.post("/api/coffres/migration/api-keys/import", json={})
+        assert resp.status_code == 200
+        assert "deepseek_api_key" in resp.json()["deja_existants"]
+        _, jeton, _ = _creer_consommateur_octroi(
+            client, slug="obsigate-interne", nom="deepseek_api_key"
+        )
+        resp = _distribuer(
+            client, jeton, reference="coffre:obsigate-interne/deepseek_api_key"
+        )
+        assert resp.json()["valeur"] == VALEUR_TEST  # valeur d'origine conservée
+
+    def test_import_sans_kek_repond_503(self, client, env_coffre, monkeypatch):
+        # Une clé à migrer est nécessaire : sans valeur à chiffrer,
+        # l'import réussit trivialement même sans KEK (mode dégradé).
+        self._ecrire_api_keys(env_coffre)
+        monkeypatch.delenv("OBSIGATE_KEK", raising=False)
+        resp = client.post("/api/coffres/migration/api-keys/import", json={})
+        assert resp.status_code == 503
+        assert resp.json()["detail"] == "kek_absente"
+
+
+# ---------------------------------------------------------------------------
+# Phase 2 — Restauration sur instance vierge (issue #20)
+# ---------------------------------------------------------------------------
+
+class TestRestaurationVierge:
+    def test_restauration_meme_kek_distribue(self, env_coffre, tmp_path):
+        coffre = create_coffre("personnel", "Personnel", "bruno")
+        secret = create_secret(coffre, "gitea-token", "token", VALEUR_TEST)
+        assert distribuer_valeur(coffre, secret) == VALEUR_TEST
+        # Simulation d'une instance vierge : seuls les deux fichiers sont
+        # copiés, la KEK (variable d'environnement) est inchangée.
+        restaure = tmp_path / "restaure"
+        restaure.mkdir()
+        for nom in ("coffres.json", "coffres_valeurs.json"):
+            shutil.copy(env_coffre / nom, restaure / nom)
+        coffre_r = get_coffre_or_404("personnel", restaure)
+        assert distribuer_valeur(coffre_r, secret, restaure) == VALEUR_TEST
+        for nom in ("coffres.json", "coffres_valeurs.json"):
+            assert VALEUR_TEST not in (restaure / nom).read_text(encoding="utf-8")
+
+    def test_restauration_mauvaise_kek_refuse(self, env_coffre, tmp_path, monkeypatch):
+        coffre = create_coffre("personnel", "Personnel", "bruno")
+        secret = create_secret(coffre, "gitea-token", "token", VALEUR_TEST)
+        restaure = tmp_path / "restaure"
+        restaure.mkdir()
+        for nom in ("coffres.json", "coffres_valeurs.json"):
+            shutil.copy(env_coffre / nom, restaure / nom)
+        # Une autre KEK ne déchiffre rien : tag GCM invalide, pas de valeur.
+        monkeypatch.setenv("OBSIGATE_KEK", generate_kek_b64())
+        coffre_r = get_coffre_or_404("personnel", restaure)
+        with pytest.raises(TagInvalideError):
+            distribuer_valeur(coffre_r, secret, restaure)
+
+
+# ---------------------------------------------------------------------------
+# Phase 3 — Contexte Spark imbriqué (issue #21)
+# ---------------------------------------------------------------------------
+
+class TestDistributionSpark:
+    def test_contexte_nested_mission(self, client):
+        _creer_coffre_secret(client)
+        _, jeton, _ = _creer_consommateur_octroi(client)
+        resp = client.post(
+            "/api/coffres/distribuer",
+            json={
+                "reference": "coffre:personnel/gitea-token",
+                "contexte": {"type": "mission", "id": "mission-test-2"},
+            },
+            headers={"Authorization": f"Bearer {jeton}"},
+        )
+        assert resp.status_code == 200, resp.text
+        assert resp.json()["valeur"] == VALEUR_TEST
+
+    def test_contexte_nested_sans_octroi_acces_requis(self, client):
+        _creer_coffre_secret(client)
+        resp = client.post("/api/coffres/consommateurs", json={"nom": "spark"})
+        jeton = resp.json()["jeton"]
+        resp = client.post(
+            "/api/coffres/distribuer",
+            json={
+                "reference": "coffre:personnel/gitea-token",
+                "contexte": {"type": "mission", "id": "mission-test-3"},
+            },
+            headers={"Authorization": f"Bearer {jeton}"},
+        )
+        # Côté Spark, ce code se traduit par l'état acces_requis.
+        assert resp.status_code == 403
+        assert resp.json()["detail"] == "octroi_absent"
+
+
+# ---------------------------------------------------------------------------
+# Phase 4 — Consommateur + octrois en un appel (issue #22)
+# ---------------------------------------------------------------------------
+
+class TestConsommateurAvecOctrois:
+    def test_avec_octrois_distribue(self, client, env_coffre):
+        _creer_coffre_secret(client)
+        resp = client.post(
+            "/api/coffres/consommateurs/avec-octrois",
+            json={
+                "nom": "tiktak",
+                "octrois": [{"coffre_slug": "personnel", "secret_nom": "gitea-token"}],
+            },
+        )
+        assert resp.status_code == 200, resp.text
+        corps = resp.json()
+        assert corps["nom"] == "tiktak"
+        assert corps["jeton"].startswith("csk_")
+        assert len(corps["octrois"]) == 1
+        assert corps["erreurs"] == []
+        resp = _distribuer(client, corps["jeton"])
+        assert resp.status_code == 200
+        assert resp.json()["valeur"] == VALEUR_TEST
+        liste = client.get("/api/coffres/consommateurs").json()
+        assert corps["jeton"] not in json.dumps(liste)
+        assert "jeton_hash" not in json.dumps(liste)
+
+    def test_avec_octrois_erreur_signalee_sans_annuler(self, client):
+        _creer_coffre_secret(client)
+        resp = client.post(
+            "/api/coffres/consommateurs/avec-octrois",
+            json={
+                "nom": "flowdeck",
+                "octrois": [
+                    {"coffre_slug": "personnel", "secret_nom": "gitea-token"},
+                    {"coffre_slug": "inexistant", "secret_nom": "gitea-token"},
+                ],
+            },
+        )
+        assert resp.status_code == 200, resp.text
+        assert len(resp.json()["octrois"]) == 1
+        assert len(resp.json()["erreurs"]) == 1
+        assert resp.json()["erreurs"][0]["coffre_slug"] == "inexistant"

tests/test_draco_barre.py

@@ -43,8 +43,106 @@ def test_menu_des_applications_par_la_marque():
     assert "font-size: 24px" in _css()
 
 
+def test_panneau_spark_integre_218():
+    # #218 : le bouton Spark de la barre ouvre le panneau de l'agent
+    # commun (mêmes assets partagés que TikTak / Flowdeck / Kanbante).
+    html = _index()
+    assert (FRONTEND / "draco-panneau.js").is_file()
+    assert (FRONTEND / "draco-panneau.css").is_file()
+    assert '<link rel="stylesheet" href="/static/draco-panneau.css" />' in html
+    assert '<script defer src="/static/draco-panneau.js"></script>' in html
+    # L'action spark bascule sur le panneau — plus le message d'attente.
+    assert "window.DRACO_PANNEAU.toggle()" in html
+    assert "arrive en phase 4 du programme Fusion" not in html
+    panneau = (FRONTEND / "draco-panneau.js").read_text(encoding="utf-8")
+    assert "https://agent.dracodev.net" in panneau
+
+
+def test_panneau_bouton_console_221():
+    # #221 : le panneau Spark (asset vendangé, octet-identique dans
+    # les 4 apps) porte un bouton « Console » qui mène à la console
+    # web du service, sur la discussion courante (?disc=) et avec
+    # l'app d'origine (?app= déduite du sous-domaine : og → obsigate).
+    # Révisé par #222 : l'ouverture en nouvel onglet a disparu (la
+    # console s'ouvre en surimpression, voir le test #222) ; le lien
+    # profond, lui, subsiste via urlConsole().
+    panneau = (FRONTEND / "draco-panneau.js").read_text(encoding="utf-8")
+    assert 'data-disc="console"' in panneau
+    assert "ouvrirConsole" in panneau
+    assert "urlConsole" in panneau
+    assert '"disc=" + encodeURIComponent(id)' in panneau
+    assert '"app=" + encodeURIComponent(app)' in panneau
+    assert 'og: "obsigate"' in panneau
+    assert 'window.open(' not in panneau
+
+
+def test_panneau_console_surimpression_222():
+    # #222 : le bouton « Console ⤢ » ouvre la console dans la même
+    # page, en surimpression née à la largeur du panneau et étendue
+    # à toute la fenêtre (transition sur la largeur), avec deux
+    # sorties : « Mode sidebar » et « Fermer l'agent ». L'URL de
+    # l'iframe garde le lien profond de #221 (urlConsole()).
+    panneau = (FRONTEND / "draco-panneau.js").read_text(encoding="utf-8")
+    assert "Console ⤢" in panneau
+    assert "draco-console-sur" in panneau
+    assert "assurerSurimpression" in panneau
+    assert "draco-console-styles" in panneau
+    assert 'surCadre.src = urlConsole()' in panneau
+    assert 'surEl.style.width = "100%"' in panneau
+    assert 'data-dc="sidebar"' in panneau
+    assert "Mode sidebar" in panneau
+    assert "modeSidebarConsole" in panneau
+    assert 'data-dc="fermer"' in panneau
+    assert "Fermer l'agent" in panneau
+    assert "fermerAgentConsole" in panneau
+
+
+def test_csp_ouvre_le_service_d_agents_218():
+    # Le panneau parle au service d'agents : la CSP doit nommer son
+    # hôte en connect-src, sans ouvrir de générique supplémentaire.
+    # #223 : l'origine n'est plus un littéral dans main.py — elle est
+    # dérivée de la configuration (backend.draco_config.agent_origine,
+    # testée via la config dans tests/test_security_headers.py).
+    main = (Path(__file__).resolve().parent.parent / "backend" / "main.py").read_text(encoding="utf-8")
+    ligne = next(l for l in main.splitlines() if "connect-src" in l)
+    assert "agent_origine" in main
+    assert "{agent}" in ligne
+
+
+def test_urls_ecosysteme_via_injection_hote_223():
+    # #223 : panneau Spark, liens TikTak et onglets des apps lisent
+    # window.DRACO_URLS (injecté par l'hôte/backend depuis sa config) ;
+    # les littéraux restants ne sont que les défauts officiels en repli.
+    panneau = (FRONTEND / "draco-panneau.js").read_text(encoding="utf-8")
+    assert "window.DRACO_URLS" in panneau
+    assert "DRACO_URLS.agent" in panneau
+    liens = (FRONTEND / "draco-liens.js").read_text(encoding="utf-8")
+    assert "window.DRACO_URLS" in liens
+    assert "baseTikTak()" in liens
+    html = _index()
+    assert "window.DRACO_URLS" in html
+    assert "DRACO_URLS[a.dataset.app]" in html
+
+
 def test_rail_mobile_vers_le_vrai_hamburger():
     html = _index()
     assert 'matchMedia("(max-width: 768px)")' in html
     assert '"hamburger-btn"' in html
     assert '"sidebar-toggle-btn"' in html
+
+
+def test_panneau_version_service_affichee_225():
+    # #225 : le pied du panneau Spark (mode sidebar) affiche la
+    # version du service d'agents, comme la console pleine page.
+    # La version est lue en direct dans la santé du service
+    # (GET /healthz de l'origine injectée par l'hôte), à l'ouverture
+    # du panneau ; jamais un littéral de version dans l'asset, et
+    # source injoignable = ligne laissée masquée (rien d'affiché).
+    panneau = (FRONTEND / "draco-panneau.js").read_text(encoding="utf-8")
+    assert "draco-panneau-version" in panneau
+    assert "chargerVersion" in panneau
+    assert 'API + "/healthz"' in panneau
+    assert '"Service d\'agents v" + versionConnue' in panneau
+    # La ligne naît masquée et n'est démasquée qu'avec une version lue.
+    assert 'class="draco-panneau-version"' in panneau
+    assert "versionEl.hidden = false" in panneau

tests/test_draco_config.py

@@ -0,0 +1,184 @@
+"""URLs publiques de l'écosystème par configuration — #223 (dev/prod).
+
+Règle : aucun nom public de l'écosystème n'est figé dans le code
+vivant. Défauts = noms **officiels** (production future) ; le dev
+déclare ses noms en ``-dev`` dans son seul ``.env``
+(``DRACO_*_URL`` / ``AGENT_EVENEMENTS_URL``). On vérifie ici la
+config centralisée, la dérivation de l'URL d'événements du journal,
+la reconnaissance des liens profonds des deux environnements et la
+reconstruction des URL d'affichage des références croisées.
+"""
+
+import pytest
+
+from backend import draco_config
+
+
+@pytest.fixture()
+def env_propre(monkeypatch):
+    """Aucune variable d'URL d'écosystème posée (défauts officiels)."""
+    for nom in (
+        "DRACO_AGENT_URL", "DRACO_OBSIGATE_URL", "DRACO_FLOWDECK_URL",
+        "DRACO_TIKTAK_URL", "DRACO_KANBANTE_URL", "DRACO_GITEA_URL",
+        "AGENT_EVENEMENTS_URL",
+    ):
+        monkeypatch.delenv(nom, raising=False)
+    return monkeypatch
+
+
+def test_defauts_officiels_sans_dev(env_propre):
+    assert draco_config.agent_url() == "https://agent.dracodev.net"
+    assert draco_config.app_url("tiktak") == "https://tiktak.dracodev.net"
+    assert draco_config.app_url("obsigate") == "https://og.dracodev.net"
+    assert draco_config.app_url("flowdeck") == "https://flowdeck.dracodev.net"
+    assert draco_config.app_url("kanbante") == "https://kanbante.dracodev.net"
+    assert draco_config.app_url("gitea") == "https://git.dracodev.net"
+    for url in draco_config.urls_publiques().values():
+        assert "-dev" not in url
+
+
+def test_agent_derive_des_evenements(env_propre):
+    """Sans DRACO_AGENT_URL, l'origine suit AGENT_EVENEMENTS_URL —
+    la configuration réelle du poste (dev inclus)."""
+    env_propre.setenv(
+        "AGENT_EVENEMENTS_URL", "https://agent-dev.dracodev.net/api/v1/evenements")
+    assert draco_config.agent_url() == "https://agent-dev.dracodev.net"
+    assert draco_config.agent_origine() == "https://agent-dev.dracodev.net"
+
+
+def test_agent_explicite_prime(env_propre):
+    env_propre.setenv(
+        "AGENT_EVENEMENTS_URL", "https://agent-dev.dracodev.net/api/v1/evenements")
+    env_propre.setenv("DRACO_AGENT_URL", "https://agent.example.net/")
+    assert draco_config.agent_url() == "https://agent.example.net"
+
+
+# ------------------------------------------------- BUG-120 : dérivation sœurs
+
+def test_soeurs_derivees_depuis_agent_dev(env_propre):
+    """BUG-120 : avec **seul** ``AGENT_EVENEMENTS_URL`` en ``-dev``
+    posé (aucune ``DRACO_<APP>_URL``), les URL sœurs servies suivent
+    l'environnement de l'agent ; Gitea ne bouge jamais."""
+    env_propre.setenv(
+        "AGENT_EVENEMENTS_URL", "https://agent-dev.dracodev.net/api/v1/evenements")
+    urls = draco_config.urls_publiques()
+    assert urls["agent"] == "https://agent-dev.dracodev.net"
+    assert urls["obsigate"] == "https://og-dev.dracodev.net"
+    assert urls["flowdeck"] == "https://flowdeck-dev.dracodev.net"
+    assert urls["tiktak"] == "https://tiktak-dev.dracodev.net"
+    assert urls["kanbante"] == "https://kanbante-dev.dracodev.net"
+    assert urls["gitea"] == "https://git.dracodev.net"
+
+
+def test_soeurs_derivees_depuis_draco_agent_url(env_propre):
+    """BUG-120 : la dérivation lit l'agent via ``agent_url()`` — un
+    ``DRACO_AGENT_URL`` en ``-dev`` suffit aussi."""
+    env_propre.setenv("DRACO_AGENT_URL", "https://agent-dev.dracodev.net")
+    assert draco_config.app_url("tiktak") == "https://tiktak-dev.dracodev.net"
+    assert draco_config.app_url("obsigate") == "https://og-dev.dracodev.net"
+
+
+def test_soeur_explicite_prime_sur_derivation(env_propre):
+    """BUG-120 : une ``DRACO_<APP>_URL`` explicite gagne toujours sur
+    la dérivation d'environnement ; les autres sœurs dérivent."""
+    env_propre.setenv(
+        "AGENT_EVENEMENTS_URL", "https://agent-dev.dracodev.net/api/v1/evenements")
+    env_propre.setenv("DRACO_TIKTAK_URL", "https://taches.example.net/")
+    assert draco_config.app_url("tiktak") == "https://taches.example.net"
+    assert draco_config.app_url("flowdeck") == "https://flowdeck-dev.dracodev.net"
+    assert draco_config.app_url("kanbante") == "https://kanbante-dev.dracodev.net"
+
+
+@pytest.mark.parametrize("evenements", [
+    "https://agent.example.net/api/v1/evenements",        # autre domaine
+    "https://agent-dev.example.com/api/v1/evenements",    # suffixe hors dracodev.net
+    "http://deepin.lab.home:8790/api/v1/evenements",      # nom LAN + port
+    "http://192.168.30.101:8790/api/v1/evenements",       # IP + port
+    "https://agent-dev.dracodev.net:8790/api/v1/evenements",  # port exotique
+])
+def test_agent_hors_motif_aucune_derivation(env_propre, evenements):
+    """BUG-120 : hôte d'agent hors motif ``agent<SUFFIXE>.dracodev.net``
+    → **aucune dérivation** (jamais de lien deviné), défauts officiels."""
+    env_propre.setenv("AGENT_EVENEMENTS_URL", evenements)
+    urls = draco_config.urls_publiques()
+    assert urls["obsigate"] == "https://og.dracodev.net"
+    assert urls["flowdeck"] == "https://flowdeck.dracodev.net"
+    assert urls["tiktak"] == "https://tiktak.dracodev.net"
+    assert urls["kanbante"] == "https://kanbante.dracodev.net"
+    assert urls["gitea"] == "https://git.dracodev.net"
+
+
+def test_agent_prod_suffixe_vide_defauts_officiels(env_propre):
+    """BUG-120 : hôte d'agent prod (suffixe vide) → les sœurs dérivées
+    sont exactement les défauts officiels."""
+    env_propre.setenv(
+        "AGENT_EVENEMENTS_URL", "https://agent.dracodev.net/api/v1/evenements")
+    for app, defaut in draco_config.DEFAUTS.items():
+        assert draco_config.app_url(app) == defaut
+
+
+def test_journal_url_suit_la_config(env_propre):
+    from backend import agent_journal
+
+    assert agent_journal._url() == "https://agent.dracodev.net/api/v1/evenements"
+    env_propre.setenv("DRACO_AGENT_URL", "https://agent-dev.dracodev.net")
+    assert agent_journal._url() == "https://agent-dev.dracodev.net/api/v1/evenements"
+    env_propre.setenv(
+        "AGENT_EVENEMENTS_URL", "https://autre.example.net/api/v1/evenements")
+    assert agent_journal._url() == "https://autre.example.net/api/v1/evenements"
+
+
+# ------------------------------------------------------------ liens profonds
+
+def test_parse_hotes_configures(env_propre):
+    """Un lien collé depuis l'environnement dev (hôtes déclarés dans
+    son .env) est reconnu, comme un lien officiel."""
+    from backend.external_refs import parse_deep_link
+
+    env_propre.setenv("DRACO_TIKTAK_URL", "https://tiktak-dev.dracodev.net")
+    env_propre.setenv("DRACO_OBSIGATE_URL", "https://og-dev.dracodev.net")
+    assert parse_deep_link("https://tiktak-dev.dracodev.net/?task=5") == (
+        "tiktak", "task", "5", "TikTak · tâche 5")
+    assert parse_deep_link("https://og-dev.dracodev.net/#file=v:Dossier/Note.md") == (
+        "obsigate", "note", "v:Dossier/Note.md", "ObsiGate · Note.md")
+    # L'officiel reste reconnu en parallèle (lien venu de la prod).
+    assert parse_deep_link("https://tiktak.dracodev.net/?task=5") is not None
+
+
+def test_url_affichage_reconstruite_depuis_config(env_propre, tmp_path):
+    """#223 : la référence stockée garde son URL absolue d'origine
+    (aucune migration), mais l'URL **servie** est reconstruite depuis
+    la config courante."""
+    from backend.external_refs import add_ref, build_deep_link, list_refs
+
+    env_propre.setenv("OBSIGATE_EXTERNAL_REFS_DIR", str(tmp_path / "refs"))
+    assert build_deep_link("tiktak", "task", "42") == \
+        "https://tiktak.dracodev.net/?task=42"
+    assert build_deep_link("kanbante", "card", "Projets/obsigate#7") == \
+        "https://git.dracodev.net/Projets/obsigate/issues/7"
+    assert build_deep_link("obsigate", "note", "v:Dossier/Note.md") == \
+        "https://og.dracodev.net/#file=v:Dossier%2FNote.md"
+
+    env_propre.setenv("DRACO_TIKTAK_URL", "https://tiktak-dev.dracodev.net")
+    ref = add_ref("alice", "Vault", "N.md", "tiktak", "task", "42",
+                  "https://tiktak.dracodev.net/?task=42", "TikTak · tâche 42")
+    assert ref["target_url"] == "https://tiktak.dracodev.net/?task=42"  # stocké tel quel
+    servies = list_refs("alice", "Vault", "N.md")
+    assert servies[0]["target_url"] == "https://tiktak-dev.dracodev.net/?task=42"
+
+
+# ------------------------------------------------------------ injection hôte
+
+def test_index_injecte_draco_urls(client, env_propre):
+    """L'hôte sert index.html avec window.DRACO_URLS issu de sa config.
+
+    BUG-120 : l'agent en ``-dev`` entraîne les sœurs en ``-dev``
+    (dérivation d'environnement) — avant, ``tiktak`` restait en prod.
+    """
+    env_propre.setenv("DRACO_AGENT_URL", "https://agent-dev.dracodev.net")
+    resp = client.get("/")
+    assert resp.status_code == 200
+    assert "window.DRACO_URLS" in resp.text
+    assert '"agent": "https://agent-dev.dracodev.net"' in resp.text
+    assert '"tiktak": "https://tiktak-dev.dracodev.net"' in resp.text
+    assert '"gitea": "https://git.dracodev.net"' in resp.text

tests/test_security_headers.py

@@ -72,3 +72,59 @@ def test_security_headers_present(client):
     csp = resp.headers.get("content-security-policy", "")
     assert "object-src 'none'" in csp
     assert "frame-ancestors 'self'" in csp
+
+
+def _csp_directives(csp: str) -> dict[str, list[str]]:
+    """Découpe une politique CSP en ``{directive: [sources]}``."""
+    directives: dict[str, list[str]] = {}
+    for part in csp.split(";"):
+        tokens = part.split()
+        if tokens:
+            directives[tokens[0]] = tokens[1:]
+    return directives
+
+
+def test_csp_frame_src_allows_agent_console(client, monkeypatch):
+    """BUG-119 : le « mode console » du panneau Spark charge la console du
+    service d'agents (``https://agent.dracodev.net``) dans une iframe —
+    ``frame-src`` doit autoriser cette origine, sinon le navigateur bloque
+    le chargement (« This content is blocked »). Les sources historiques
+    (``'self'`` et ``blob:``, visualiseur PDF) restent en place et aucune
+    autre origine n'est admise.
+
+    #223 : la configuration est neutralisée ici (défaut officiel) —
+    l'origine n'est plus figée dans le code, voir le test via config
+    ci-dessous."""
+    monkeypatch.delenv("DRACO_AGENT_URL", raising=False)
+    monkeypatch.delenv("AGENT_EVENEMENTS_URL", raising=False)
+    resp = client.get("/api/health")
+    csp = resp.headers.get("content-security-policy", "")
+    directives = _csp_directives(csp)
+    assert directives.get("frame-src") == [
+        "'self'",
+        "blob:",
+        "https://agent.dracodev.net",
+    ]
+    assert "https://agent.dracodev.net" in directives.get("connect-src", [])
+
+
+def test_csp_agent_origine_via_config(client, monkeypatch):
+    """#223 : ``frame-src``/``connect-src`` suivent l'origine de l'agent
+    **configurée** — dérivée d'``AGENT_EVENEMENTS_URL`` (config réelle
+    du poste, noms en ``-dev`` en dev), ou de ``DRACO_AGENT_URL`` qui
+    prime. Aucun nom d'environnement n'est codé en dur."""
+    monkeypatch.delenv("DRACO_AGENT_URL", raising=False)
+    monkeypatch.setenv(
+        "AGENT_EVENEMENTS_URL", "https://agent-dev.dracodev.net/api/v1/evenements")
+    resp = client.get("/api/health")
+    directives = _csp_directives(resp.headers.get("content-security-policy", ""))
+    assert directives.get("frame-src") == [
+        "'self'", "blob:", "https://agent-dev.dracodev.net"]
+    assert "https://agent-dev.dracodev.net" in directives.get("connect-src", [])
+    assert "https://agent.dracodev.net" not in directives.get("connect-src", [])
+
+    monkeypatch.setenv("DRACO_AGENT_URL", "https://agent.example.net")
+    resp = client.get("/api/health")
+    directives = _csp_directives(resp.headers.get("content-security-policy", ""))
+    assert directives.get("frame-src") == [
+        "'self'", "blob:", "https://agent.example.net"]

tests/test_themes.py

@@ -2,7 +2,7 @@
 
 Validates:
 - Theme JSON structure validity
-- All 15 built-in themes have required keys and valid CSS colors
+- All 16 built-in themes have required keys and valid CSS colors
 - High-contrast and sepia mode generators produce valid CSS vars
 - Import/export round-trip
 - AVAILABLE_MODES includes all 4 modes
@@ -80,9 +80,9 @@ class TestThemeStructure:
         assert '_genSepia' in self.content
 
     def test_theme_count(self):
-        """Should have 15 built-in themes."""
+        """Should have 16 built-in themes."""
         names = _extract_theme_names(self.content)
-        assert len(names) == 15, f"Expected 15 themes, found {len(names)}: {names}"
+        assert len(names) == 16, f"Expected 16 themes, found {len(names)}: {names}"
 
     def test_required_export_functions(self):
         """All required functions should be exported."""