Recherche partout (#68) : JS compatible ESM (test ObsiGate)

.env.example

@@ -28,6 +28,13 @@ OAUTH_REDIRECT_URI=
 # par release (passé par environment:/env_file: au conteneur).
 # Laisser vide = défaut officiel indiqué en commentaire.
 DRACO_SSO_URL=            # ObsiGate, émettrice SSO — défaut https://og.dracodev.net ; dev : https://og-dev.dracodev.net
+# ── Coffre ObsiGate, côté consommateur Flowdeck (Phase 4, issue ObsiGate #22) ──
+# OBSIGATE_COFFRE_URL vide = dérivée de DRACO_SSO_URL (même hôte).
+# OBSIGATE_CONSUMER_TOKEN = jeton CONSOMMATEUR Flowdeck enregistré dans ObsiGate
+# (octrois) — distinct du jeton MCP de notes et de la session SSO.
+# Ne jamais le copier dans un log, un rapport ou une réponse API.
+OBSIGATE_COFFRE_URL=
+OBSIGATE_CONSUMER_TOKEN=
 DRACO_AGENT_URL=          # Service d'agents Spark — défaut https://agent.dracodev.net ; dev : https://agent-dev.dracodev.net
 TIKTAK_URL=               # TikTak (preset MCP, barre, refs) — défaut https://tiktak.dracodev.net ; dev : https://tiktak-dev.dracodev.net
 KANBANTE_URL=             # Kanbante (barre, refs) — défaut https://kanbante.dracodev.net ; dev : https://kanbante-dev.dracodev.net

CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog - FlowDeck
 
+## v7.84.1 (2026-10-28) — Barre d'apps v0.1.6 vendangée (dérivation -dev, menu •••, compte)
+
+- **Barre d'apps** : vendange de `dracodev-commons` v0.1.6 — dérivation `-dev` par l'hôte courant, menu « ••• » par défaut, menu compte fonctionnel, spark sans dérivation inventée.
+
+## v7.84.0 (2026-10-26) — Fusion : format commun des skills (ACC-4.5), pilote réunion → ObsiGate (ACC-6.2), panneau commun (ACC-4.4)
+
+- **ACC-4.5 — format de skill commun** (`app/services/skill_format.py`,
+  contrat figé ACC-0.3 de `dracodev-commons`). Lecture et validation
+  d'un `SKILL.md` au format commun (frontmatter YAML : `name`,
+  `description`-déclencheur, `version`, `apps`, `domaines`, `outils`,
+  `ecritures` obligatoire dès qu'un outil modifie ; corps en trois
+  sections ordonnées), conversion vers les champs Flowdeck
+  (installable via `skill_gallery.upsert_skill`) et conversion
+  inverse depuis un preset de la galerie. **Preuve du format** :
+  trois skills de la galerie convertis dans `skills-communs/` —
+  `compte-rendu-reunion`, `rapport-hebdo`, `resume-document`.
+- **ACC-6.2 — pilote d'écriture approuvée** (`app/services/meeting_archive.py`).
+  Nouvelle route `POST /api/v2/meetings/transcripts/{id}/archiver-obsigate` :
+  prépare l'archive du résumé de réunion (chemin `Réunions/<date> - <titre>.md`,
+  contenu Markdown avec lien profond vers la note) et la dépose dans
+  la **file d'approbations unifiée** (`agent_approvals`, outil
+  `archiver_reunion_obsigate`) — rien n'est écrit avant approbation.
+  À la décision favorable (route gouvernance), `propose_write_file`
+  part vers ObsiGate par le pont MCP (ACC-2.2) et la distribution est
+  journalisée (nouveau canal `obsigate` de `meeting_distributions`).
+  Sans connecteur ObsiGate configuré, l'exécution échoue avec un
+  message explicite. Pilote : usage réel conditionnel au chantier
+  Meetings (décision A/B) et à la clé ObsiGate dédiée au pont.
+- **ACC-4.4 — panneau de l'agent commun** : intégré depuis la 7.81.0
+  (panneau v3, conversation commune du service d'agents), complété
+  par le mode console (7.82.x) et la version du service en sidebar
+  (7.83.1). Cette version fige l'intégration par des tests de
+  contrat (`tests/test_fusion_panneau_commun.py`) : assets chargés,
+  configuration injectée par l'hôte (aucune URL publique codée en
+  dur), conversation du service — et automatisations locales
+  conservées (décision C5).
+
+## v7.83.1 (2026-10-26) — Panneau Spark : version du service d'agents visible en mode sidebar
+
+- **Panneau Spark** (`static/js/draco-panneau.js`) : le pied du panneau
+  affiche désormais la ligne discrète et permanente « 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 que le panneau
+  connaît déjà), à l'ouverture du panneau, avec cache de session —
+  jamais une valeur codée en dur ; service injoignable = rien
+  d'affiché, aucune erreur visible. Carte fusion #64.
+
 ## v7.83.0 (2026-10-26) — Fusion : serveur MCP complété (ACC-5.1) et pont MCP vers ObsiGate (ACC-2.2)
 
 - **ACC-5.1 — serveur MCP Flowdeck complété** (`app/routers/mcp_server.py`,

VERSION

@@ -1 +1 @@
-7.83.0
+7.84.1

app/config.py

@@ -158,6 +158,13 @@ class Settings(BaseSettings):
     #   KANBANTE_URL=https://kanbante-dev.dracodev.net
     #   FLOWDECK_URL=https://flowdeck-dev.dracodev.net
     draco_sso_url: str = "https://og.dracodev.net"        # ObsiGate (émettrice SSO)
+    # ── Coffre ObsiGate, côté consommateur Flowdeck (Phase 4, issue #22) ──
+    # URL de distribution : vide = dérivée de draco_sso_url (même hôte).
+    # Jeton : le jeton CONSOMMATEUR Flowdeck enregistré dans ObsiGate
+    # (octrois), distinct du jeton MCP de notes et de la session SSO.
+    # Jamais en clair dans un log, un rapport ou une réponse API.
+    obsigate_coffre_url: str = ""
+    obsigate_consumer_token: str = ""
     draco_agent_url: str = "https://agent.dracodev.net"  # service d'agents (Spark)
     tiktak_url: str = "https://tiktak.dracodev.net"
     kanbante_url: str = "https://kanbante.dracodev.net"

app/main.py

@@ -216,7 +216,7 @@ def _lire_version() -> str:
 
 
 # Littéral de version synchronisé avec le fichier VERSION :
-# version="7.83.0"
+# version="7.84.1"
 # Patron historique des bumps (voir scripts/bump_version.py, qui cherche
 # ce littéral) et contrôle de tests/test_pwa_offline.py. La version
 # runtime reste lue dynamiquement depuis VERSION par _lire_version()
@@ -250,6 +250,14 @@ app.add_middleware(
     allow_credentials=True,
 )
 
+# Recherche partout (#68) : CORS bornée pour GET /api/search — ajoutée
+# après CORSMiddleware donc exécutée avant lui (dernier ajouté = le
+# plus externe) : les preflights OPTIONS sont répondus ici, avant
+# tout refus d'origine. La politique CORS globale est inchangée.
+from app.middleware.recherche_cors import RechercheCorsMiddleware
+
+app.add_middleware(RechercheCorsMiddleware)
+
 app.include_router(auth.router)
 app.include_router(sso_router)
 app.include_router(dashboard.router)
@@ -427,3 +435,4 @@ def http_exception_handler(request: Request, exc: _StarHTTPException):
         return problem_response(request, exc)
     from fastapi.responses import JSONResponse
     return JSONResponse({"detail": detail if isinstance(detail, str) else str(detail)}, status_code=status)
+

app/middleware/recherche_cors.py

@@ -0,0 +1,190 @@
+"""CORS bornée pour la recherche fédérée (fusion-trois-apps #68).
+
+La page « Rechercher partout » (``/recherche``) appelle, depuis le
+navigateur, ``GET /api/search`` sur chaque application sœur. Sans
+en-têtes CORS, le navigateur refuse la lecture des réponses
+cross-origin ; sans borne, on ouvrirait la lecture à tout le web.
+Ce module n'autorise donc que :
+
+- le chemin ``/api/search`` (jamais les autres routes, jamais les
+  écritures) ;
+- les origines sœurs : celles résolues par
+  ``app.services.draco_urls.toutes()`` (explicite > hôte > dérivation
+  > défaut officiel), **plus** les origines prod ou ``-dev``
+  officielles correspondant à l'hôte de la requête — ce second
+  ensemble est nécessaire car ce middleware s'exécute avant le
+  middleware CSP qui pose le contexte d'hôte de la requête pour
+  ``draco_urls`` ; sans lui, une page servie par ``flowdeck-dev``
+  verrait ses sœurs ``-dev`` refusées quand la configuration seule
+  ne les déclare pas ;
+- avec credentials (le cookie SSO ``draco_session``, accepté par
+  ``/api/search`` depuis cette livraison, ou la session native).
+
+Jamais ``*``. Le middleware est un ASGI pur : il répond lui-même
+aux preflights OPTIONS (qui ne portent jamais de cookies) et ajoute
+les en-têtes aux réponses de recherche, sans toucher aux autres
+routes ni à la politique CORS globale de l'application.
+"""
+
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+SEARCH_PATH = "/api/search"
+
+PROD_ORIGINS = frozenset({
+    "https://og.dracodev.net",
+    "https://flowdeck.dracodev.net",
+    "https://tiktak.dracodev.net",
+    "https://kanbante.dracodev.net",
+})
+
+DEV_ORIGINS = frozenset({
+    "https://og-dev.dracodev.net",
+    "https://flowdeck-dev.dracodev.net",
+    "https://tiktak-dev.dracodev.net",
+    "https://kanbante-dev.dracodev.net",
+})
+
+# Clés de draco_urls.toutes() qui sont des applications sœurs.
+_SOEUR_KEYS = ("obsigate", "flowdeck", "tiktak", "kanbante")
+
+
+def is_dev_host(hostname: str | None) -> bool:
+    """Même règle que la barre v0.1.6 (voir static/js/recherche.js)."""
+    if not hostname:
+        return False
+    h = hostname.lower().split(":")[0]
+    if not h.endswith(".dracodev.net"):
+        return False
+    first = h.split(".")[0]
+    return len(first) > 4 and first.endswith("-dev")
+
+
+def is_prod_host(hostname: str | None) -> bool:
+    """Hôte dracodev.net qui n'est ni ``-dev`` ni un piège de suffixe."""
+    if not hostname:
+        return False
+    h = hostname.lower().split(":")[0]
+    if not h.endswith(".dracodev.net"):
+        return False
+    first = h.split(".")[0]
+    return len(first) > 0 and not first.endswith("-dev")
+
+
+def origin_of(url: str | None) -> str | None:
+    """Origine (schéma + hôte) d'une URL, sans chemin ni ``/`` final."""
+    if not url:
+        return None
+    parsed = urlparse(url.strip())
+    if parsed.scheme not in ("http", "https") or not parsed.hostname:
+        return None
+    host = parsed.hostname.lower()
+    port = f":{parsed.port}" if parsed.port else ""
+    return f"{parsed.scheme}://{host}{port}"
+
+
+def sister_origins(resolved: dict | None = None, request_host: str | None = None) -> frozenset:
+    """Origines autorisées pour la lecture cross-origin de /api/search.
+
+    ``resolved`` : dictionnaire rendu par ``draco_urls.toutes()``.
+    Sans argument, le résolveur est appelé (import paresseux) ; en cas
+    d'échec, repli sur prod + dev officiels (premier parti uniquement).
+    ``request_host`` ajoute l'ensemble officiel de l'environnement de
+    la requête (voir le docstring du module).
+    """
+    origins = set()
+    if resolved is None:
+        try:
+            from app.services import draco_urls
+
+            resolved = draco_urls.toutes()
+        except Exception:
+            resolved = {}
+    for key in _SOEUR_KEYS:
+        origin = origin_of((resolved or {}).get(key))
+        if origin:
+            origins.add(origin)
+    if is_dev_host(request_host):
+        origins |= DEV_ORIGINS
+    elif is_prod_host(request_host):
+        origins |= PROD_ORIGINS
+    if not origins:
+        return PROD_ORIGINS | DEV_ORIGINS
+    return frozenset(origins)
+
+
+def cors_headers_for(
+    origin: str | None, resolved: dict | None = None, request_host: str | None = None
+) -> dict | None:
+    """En-têtes CORS d'une réponse de recherche, ou None si refusée."""
+    if not origin:
+        return None
+    if origin.strip() not in sister_origins(resolved, request_host):
+        return None
+    return {
+        "Access-Control-Allow-Origin": origin.strip(),
+        "Access-Control-Allow-Credentials": "true",
+        "Vary": "Origin",
+    }
+
+
+def preflight_headers(
+    origin: str | None, resolved: dict | None = None, request_host: str | None = None
+) -> dict | None:
+    """En-têtes d'une réponse de preflight OPTIONS pour /api/search."""
+    headers = cors_headers_for(origin, resolved, request_host)
+    if headers is None:
+        return None
+    headers.update({
+        "Access-Control-Allow-Methods": "GET, OPTIONS",
+        "Access-Control-Allow-Headers": "Accept, Content-Type, Authorization",
+        "Access-Control-Max-Age": "600",
+    })
+    return headers
+
+
+class RechercheCorsMiddleware:
+    """ASGI pur : CORS bornée pour ``GET /api/search`` (voir module)."""
+
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+        path = scope.get("path", "")
+        headers_in = {
+            k.decode("latin-1").lower(): v.decode("latin-1")
+            for k, v in scope.get("headers", [])
+        }
+        origin = headers_in.get("origin", "")
+        request_host = (
+            headers_in.get("x-forwarded-host", "") or headers_in.get("host", "")
+        ).split(",")[0].strip()
+        if path == SEARCH_PATH and scope.get("method") == "OPTIONS":
+            preflight = preflight_headers(origin, request_host=request_host)
+            if preflight is not None:
+                headers_out = [(k.lower().encode("latin-1"), v.encode("latin-1"))
+                               for k, v in preflight.items()]
+                headers_out.append((b"content-length", b"0"))
+                await send({"type": "http.response.start", "status": 204,
+                            "headers": headers_out})
+                await send({"type": "http.response.body", "body": b""})
+                return
+        if path != SEARCH_PATH:
+            await self.app(scope, receive, send)
+            return
+
+        async def send_with_cors(message):
+            if message["type"] == "http.response.start":
+                cors = cors_headers_for(origin, request_host=request_host)
+                if cors is not None:
+                    message["headers"] = list(message.get("headers", [])) + [
+                        (k.lower().encode("latin-1"), v.encode("latin-1"))
+                        for k, v in cors.items()
+                    ]
+            await send(message)
+
+        await self.app(scope, receive, send_with_cors)

app/middleware/security.py

@@ -174,9 +174,29 @@ class ContentSecurityPolicyMiddleware(BaseHTTPMiddleware):
                           request.headers.get("host", ""))
             agent = re.sub(r"[^0-9A-Za-z.\-:/]", "",
                            draco_urls.origine(draco_urls.agent_url()))
-            response.headers[self.CSP_HEADER] = self.CSP_VALUE.format(
+            csp = self.CSP_VALUE.format(
                 nonce=nonce, host=host, agent=agent
             )
+            # Recherche partout (#68) : la page /recherche appelle les
+            # API de recherche des sœurs depuis le navigateur — sa
+            # connect-src doit les nommer, sinon le navigateur bloque
+            # les appels avant même CORS. Les autres pages gardent la
+            # CSP inchangée. `draco_urls` est déjà importé dans ce
+            # dispatch (contexte d'hôte posé plus haut).
+            if request.url.path == "/recherche":
+                try:
+                    soeurs = " ".join(sorted({
+                        draco_urls.origine(draco_urls.toutes()[k])
+                        for k in ("obsigate", "tiktak", "kanbante")
+                    }))
+                    csp = csp.replace(
+                        "connect-src 'self' " + agent + " ",
+                        "connect-src 'self' " + agent + " " + soeurs + " ",
+                        1,
+                    )
+                except Exception:
+                    pass
+            response.headers[self.CSP_HEADER] = csp
         return response
 
 
@@ -288,3 +308,4 @@ class RateLimitMiddleware(BaseHTTPMiddleware):
         for k in expired:
             del self._store[k]
         self._last_prune = now
+

app/migrations.py

@@ -2076,3 +2076,31 @@ def _migration_draco_links(conn: sqlite3.Connection) -> None:
         )
         """
     )
+
+
+@register(52, "coffre ObsiGate (Phase 4) : workspace_id + coffre_reference sur agent_connectors")
+def _migration_coffre_reference(conn: sqlite3.Connection) -> None:
+    """Migration 52 — références ObsiGate pour les connecteurs (issue #22).
+
+    * ``workspace_id`` : le connecteur appartient à un workspace (NULL =
+      connecteur historique global, conservé tel quel — migration
+      opportuniste, pas de big-bang).
+    * ``coffre_reference`` : ``coffre:<slug>/<nom>`` (métadonnée, pas une
+      valeur) ; vide = jeton chiffré local historique.
+    Idempotente (gardée par ``columns()``), comme les migrations 32/34.
+    """
+    cols = columns(conn, "agent_connectors")
+    if "workspace_id" not in cols:
+        conn.execute(
+            "ALTER TABLE agent_connectors "
+            "ADD COLUMN workspace_id INTEGER REFERENCES workspaces(id)"
+        )
+    if "coffre_reference" not in cols:
+        conn.execute(
+            "ALTER TABLE agent_connectors "
+            "ADD COLUMN coffre_reference TEXT NOT NULL DEFAULT ''"
+        )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_agent_connectors_workspace "
+        "ON agent_connectors(workspace_id)"
+    )

app/routers/agent.py

@@ -673,6 +673,8 @@ def create_connectors_route(request: Request, body: dict = Body(default={})):
             body.get("name") or "", body.get("url") or "", str(body.get("secret") or ""),
             kind=str(body.get("kind") or "custom"),
             auth=str(body.get("auth") or "bearer"),
+            workspace_id=body.get("workspace_id"),
+            coffre_reference=body.get("coffre_reference"),
         )
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
@@ -682,11 +684,17 @@ def create_connectors_route(request: Request, body: dict = Body(default={})):
 def update_connectors_route(request: Request, connector_id: int, body: dict = Body(default={})):
     _current_user_id(request)
     try:
+        kwargs = {}
+        if "workspace_id" in body:
+            kwargs["workspace_id"] = body.get("workspace_id")
+        if "coffre_reference" in body:
+            kwargs["coffre_reference"] = body.get("coffre_reference")
         row = connectors.update_connector(
             connector_id,
             name=body.get("name"),
             enabled=body.get("enabled"),
             secret=body.get("secret"),
+            **kwargs,
         )
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
@@ -711,7 +719,8 @@ async def probe_connectors_route(request: Request, body: dict = Body(default={})
         raise HTTPException(status_code=400, detail="connector est requis")
     user_id = _current_user_id(request)
     try:
-        return await connectors.probe(target, user_id)
+        return await connectors.probe(target, user_id,
+                                    workspace_id=body.get("workspace_id"))
     except ValueError as exc:
         raise HTTPException(status_code=404, detail=str(exc)) from exc
 

app/routers/governance.py

@@ -87,4 +87,13 @@ def decide_approval(approval_id: int, request: Request, body: dict = Body(defaul
         raise HTTPException(404, "Pending approval not found")
     audit_log(user, "agent.approval.decide", "agent_approval", approval_id,
               out["status"], request)
+    # Pilote ACC-6.2 : une demande d'archivage de réunion approuvée
+    # s'exécute ici (proposition d'écriture vers ObsiGate) ; le
+    # résultat accompagne la réponse, sans changer le contrat de la
+    # file pour les autres outils.
+    from app.services import meeting_archive
+
+    archive = meeting_archive.traiter_decision_sync(out)
+    if archive is not None:
+        return {**out, "archive": archive}
     return out

app/routers/meetings.py

@@ -396,6 +396,28 @@ def get_transcript_row(transcript_id: int, request: Request):
         raise HTTPException(404, str(exc)) from None
 
 
+@router.post("/api/v2/meetings/transcripts/{transcript_id}/archiver-obsigate",
+             status_code=201)
+def archiver_obsigate(transcript_id: int, request: Request):
+    """Pilote ACC-6.2 : dépose l'archivage du résumé dans ObsiGate
+    dans la file d'approbations unifiée (rien n'est écrit avant
+    l'approbation ; l'exécution part de la décision, voir
+    governance.decide_approval)."""
+    user = _auth_user(request, require_write=True)
+    from app.services import meeting_archive
+
+    try:
+        approval = meeting_archive.demander_approbation(transcript_id, user["id"])
+    except ValueError as exc:
+        msg = str(exc)
+        raise HTTPException(404 if "not found" in msg else 400, msg) from None
+    audit_log(user, "meeting.archive.request", "transcript", transcript_id,
+              f"approval #{approval['id']}", request)
+    archive = meeting_archive.construire_archive(meet.get_transcript(transcript_id))
+    return {"approval": approval, "titre": archive["titre"],
+            "chemin": archive["chemin"]}
+
+
 @router.post("/api/v2/meetings/transcripts/{transcript_id}/consents")
 def post_consent(transcript_id: int, request: Request, body: dict = Body(default={})):
     user = _auth_user(request, require_write=True)

app/routers/search.py

@@ -2,10 +2,19 @@
 
 ``GET /api/search?q=`` backs the Ctrl+K command palette. Returns matching
 editor pages and databases scoped to the current user's accessible workspaces.
+
+Recherche partout (fusion-trois-apps #68) : la même route sert la page
+unifiée (``GET /recherche``, coquille dont les résultats sont chargés
+côté client) et accepte, en plus de la session native, le jeton SSO
+``draco_session`` (validateur local ``app.services.draco``). Sans
+session ni jeton valide, 401 — avant cette livraison, l'absence de
+session donnait une recherche SANS périmètre (``user_id=None`` → ``1=1``
+dans ``_scope_where``) : corrigé ici.
 """
 from __future__ import annotations
 
-from fastapi import APIRouter, Query, Request
+from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi.responses import HTMLResponse
 
 from app.auth.session import SessionManager
 from app.services.search import search as search_service
@@ -17,6 +26,18 @@ router = APIRouter(tags=["search"])
 def search(request: Request, q: str = Query(default="")):
     user = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
     user_id = user.get("id") if user and user.get("id") else None
+    if user_id is None:
+        # Repli SSO draco_session : un jeton valide désigne l'utilisateur
+        # lié, ou l'unique utilisateur actif (cas mono-utilisateur).
+        try:
+            from app.services import draco as draco_service
+
+            draco_user = draco_service.user_for_draco(request)
+            user_id = draco_user.get("id") if draco_user else None
+        except Exception:
+            user_id = None
+    if user_id is None:
+        raise HTTPException(status_code=401, detail="Authentication required")
 
     data = search_service(q, user_id=user_id)
     return {
@@ -25,3 +46,24 @@ def search(request: Request, q: str = Query(default="")):
         "collections": data["collections"],
         "total": len(data["pages"]) + len(data["collections"]),
     }
+
+
+@router.get("/recherche", response_class=HTMLResponse)
+def recherche_page(request: Request, q: str = Query(default="")):
+    """Page de résultats unifiée « Rechercher partout » (fusion #68).
+
+    Coquille seule : les résultats sont chargés côté client par
+    static/js/recherche.js (API de recherche de chaque app, en
+    parallèle, états par application). La palette Ctrl+K native et
+    ``GET /api/search`` restent inchangés par ailleurs.
+    """
+    from app.services import draco_urls
+    from app.templating import ENV
+
+    user = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
+    bases = draco_urls.toutes()
+    template = ENV.get_template("recherche.html")
+    return HTMLResponse(template.render(
+        request=request, q=q.strip(), user=user,
+        bases={k: bases[k] for k in ("obsigate", "flowdeck", "tiktak", "kanbante")},
+    ))

app/services/coffre_reference.py

@@ -0,0 +1,206 @@
+"""Références ObsiGate pour les connecteurs Flowdeck (Phase 4, issue ObsiGate #22).
+
+Un connecteur d'un workspace ne stocke plus un jeton en clair ni même un
+jeton chiffré local : il stocke une **référence** ``coffre:<slug>/<nom>``,
+toujours liée à un ``workspace_id``. À l'appel, le serveur Flowdeck appelle
+``POST /api/coffres/distribuer`` d'ObsiGate avec le jeton consommateur
+Flowdeck, utilise la valeur **en mémoire uniquement**, puis l'oublie :
+
+* aucune valeur n'est persistée (ni en base, ni en fichier, ni en cache) ;
+* aucune valeur n'est journalisée (les logs ne portent que le statut) ;
+* si ObsiGate est indisponible, l'appel échoue proprement — il n'y a
+  **aucun repli** sur une valeur en cache, puisqu'il n'y en a pas.
+
+Format validé ici, aligné sur ObsiGate (``backend/coffre_store.py``) :
+``slug`` et ``nom`` en minuscules, 3 à 64 / 3 à 128 caractères,
+``[a-z0-9_-]`` après le premier caractère. La référence elle-même n'est
+pas un secret (c'est une métadonnée, comme un chemin) : seule la valeur
+distribuée l'est, et elle ne transite que dans la réponse d'ObsiGate.
+
+Isolation workspace (critère central) : l'octroi ObsiGate est accordé au
+**consommateur Flowdeck** (un jeton par application), pas à un workspace.
+L'isolation par workspace est donc appliquée **côté Flowdeck, avant tout
+appel** — voir ``connectors.resolve_secret`` : un connecteur dont le
+``workspace_id`` diffère du workspace demandeur est refusé explicitement
+et le distributeur n'est jamais appelé. Une isolation appliquée côté
+ObsiGate exigerait un consommateur par workspace (reste à faire, voir
+``docs/coffre-reference-flowdeck.md``).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import urllib.error
+import urllib.request
+
+logger = logging.getLogger(__name__)
+
+#: Contexte envoyé à ObsiGate : le workspace Flowdeck demandeur, pour que
+#: la distribution soit traçable côté ObsiGate (journal des distributions).
+CONTEXTE_TYPE = "flowdeck_workspace"
+
+#: Regex ObsiGate, recopiées à l'identique (slug 3–64, nom 3–128).
+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}$")
+
+#: Délai maximal d'une distribution (secondes) — un coffre injoignable ne
+#: doit pas bloquer indéfiniment un appel de connecteur.
+TIMEOUT_S = 10
+
+
+class CoffreReferenceInvalide(ValueError):
+    """La référence ne respecte pas le format ``coffre:<slug>/<nom>``."""
+
+
+class CoffreWorkspaceMismatch(ValueError):
+    """Le connecteur appartient à un autre workspace que le demandeur."""
+
+
+class CoffreAccesRefuse(ValueError):
+    """ObsiGate a refusé la distribution (octroi absent, révoqué, expiré…).
+
+    ``detail`` reprend le code ObsiGate (``octroi_revoque``, …) sans
+    jamais contenir la valeur du secret.
+    """
+
+    def __init__(self, message: str, detail: str = "") -> None:
+        super().__init__(message)
+        self.detail = detail
+
+
+class CoffreIndisponible(ValueError):
+    """ObsiGate est injoignable ou en erreur technique (pas de repli)."""
+
+
+def parse_reference(reference: str) -> tuple[str, str]:
+    """Valide ``coffre:<slug>/<nom>`` et renvoie ``(slug, nom)`` normalisés.
+
+    La casse est ramenée en minuscules, comme côté ObsiGate
+    (``valider_slug`` / ``valider_nom_secret``).
+    """
+    value = (reference or "").strip().lower()
+    if not value.startswith("coffre:") or "/" not in value[7:]:
+        raise CoffreReferenceInvalide(
+            "référence invalide : format attendu coffre:<slug>/<nom>"
+        )
+    slug, nom = value[7:].split("/", 1)
+    if not SLUG_RE.match(slug):
+        raise CoffreReferenceInvalide(
+            "slug invalide : 3 à 64 caractères, minuscules, chiffres, - ou _"
+        )
+    if not NOM_SECRET_RE.match(nom):
+        raise CoffreReferenceInvalide(
+            "nom de secret invalide : 3 à 128 caractères, minuscules, "
+            "chiffres, - ou _"
+        )
+    return slug, nom
+
+
+def is_reference(value: str | None) -> bool:
+    """Vrai si la valeur ressemble à une référence (sans lever d'erreur)."""
+    try:
+        parse_reference(value or "")
+    except CoffreReferenceInvalide:
+        return False
+    return True
+
+
+def _config() -> tuple[str, str]:
+    """(base ObsiGate, jeton consommateur) depuis la configuration.
+
+    L'URL explicite ``obsigate_coffre_url`` prime ; sinon on dérive de
+    ``draco_sso_url`` (ObsiGate, émettrice SSO — même hôte). Le jeton est
+    le jeton **consommateur** Flowdeck enregistré dans ObsiGate, distinct
+    du jeton MCP de notes et de la session SSO.
+    """
+    from app.config import settings
+
+    base = (getattr(settings, "obsigate_coffre_url", "") or "").strip()
+    if not base:
+        base = (settings.draco_sso_url or "").strip()
+    token = (getattr(settings, "obsigate_consumer_token", "") or "").strip()
+    return base.rstrip("/"), token
+
+
+def distribuer(reference: str, workspace_id: int, *, base_url: str | None = None,
+               consumer_token: str | None = None, request=None) -> str:
+    """Distribue une valeur ObsiGate **en mémoire** pour un workspace.
+
+    ``request`` est le point d'injection des tests : un appelable
+    ``(url, payload, headers) -> (status, body_dict)`` qui remplace
+    l'appel HTTP réel (faux endpoint de distribution, clairement
+    identifié comme tel dans les tests). Sans lui, l'appel HTTP réel
+    est effectué via la bibliothèque standard (aucune dépendance).
+
+    Ne conserve rien : la valeur renvoyée doit être utilisée puis
+    oubliée par l'appelant, jamais écrite ni mise en cache.
+    """
+    slug, nom = parse_reference(reference)
+    if not workspace_id or int(workspace_id) <= 0:
+        raise ValueError("workspace_id est requis pour distribuer une référence")
+    workspace_id = int(workspace_id)
+    base, token = _config()
+    if base_url is not None:
+        base = base_url.rstrip("/")
+    if consumer_token is not None:
+        token = consumer_token
+    if not base:
+        raise CoffreIndisponible("URL ObsiGate non configurée (obsigate_coffre_url)")
+    if not token:
+        raise CoffreIndisponible(
+            "jeton consommateur ObsiGate non configuré (obsigate_consumer_token)"
+        )
+    url = f"{base}/api/coffres/distribuer"
+    payload = {
+        "reference": f"coffre:{slug}/{nom}",
+        "contexte_type": CONTEXTE_TYPE,
+        "contexte_id": str(workspace_id),
+    }
+    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+    try:
+        if request is not None:
+            status, body = request(url, payload, headers)
+        else:
+            req = urllib.request.Request(
+                url, data=json.dumps(payload).encode(), headers=headers, method="POST"
+            )
+            try:
+                with urllib.request.urlopen(req, timeout=TIMEOUT_S) as resp:
+                    status, body = resp.status, json.loads(resp.read() or b"{}")
+            except urllib.error.HTTPError as exc:
+                try:
+                    body = json.loads(exc.read() or b"{}")
+                except (ValueError, TypeError):
+                    body = {}
+                status = exc.code
+    except CoffreAccesRefuse:
+        raise
+    except (urllib.error.URLError, TimeoutError, ConnectionError, OSError) as exc:
+        # ObsiGate injoignable : échec propre, SANS repli sur un cache.
+        logger.warning("Distribution ObsiGate injoignable (statut seul journalisé)")
+        raise CoffreIndisponible(
+            "ObsiGate est indisponible : distribution impossible, "
+            "aucune valeur en cache n'est utilisée"
+        ) from exc
+    if status == 200:
+        valeur = (body or {}).get("valeur") or ""
+        if not valeur:
+            raise CoffreIndisponible("ObsiGate a répondu sans valeur")
+        return valeur
+    detail = str((body or {}).get("detail") or "")
+    if status in (401, 403):
+        if detail in ("octroi_revoque", "consommateur_revoque"):
+            message = ("accès révoqué, à ré-accorder dans ObsiGate "
+                       "(l'octroi de cette référence a été révoqué)")
+        elif detail == "octroi_expire":
+            message = "accès expiré, à ré-accorder dans ObsiGate"
+        else:
+            message = "accès refusé par ObsiGate (octroi absent ou invalide)"
+        raise CoffreAccesRefuse(message, detail=detail)
+    if status == 410:
+        raise CoffreAccesRefuse("secret expiré côté ObsiGate", detail="secret_expire")
+    if status in (400,):
+        raise CoffreReferenceInvalide(f"référence rejetée par ObsiGate ({detail})")
+    raise CoffreIndisponible(f"ObsiGate a répondu HTTP {status} (distribution impossible)")

app/services/connectors.py

@@ -1,5 +1,15 @@
 """Connecteurs de l'agent (v7.55.0) — socle : catalogue, statut, fetch gardé SSRF.
 
+Références ObsiGate (Phase 4, issue ObsiGate #22) : un connecteur personnel
+peut pointer vers ``coffre:<slug>/<nom>`` au lieu d'un jeton chiffré local.
+La référence est **toujours liée à un workspace_id** (voir
+``app/services/coffre_reference.py``) ; à l'appel, la valeur est distribuée
+en mémoire par le serveur puis oubliée, jamais persistée ni mise en cache.
+Les secrets déjà chiffrés localement restent valides (migration
+opportuniste, connecteur par connecteur — voir
+``docs/coffre-reference-flowdeck.md``).
+
+
 5 connecteurs **natifs** (gitea, github, web, google, ms365) servis à la volée,
 plus des connecteurs **personnels** persistés (URL + clé) en base avec un
 ``kind`` : ``custom`` | ``discord`` (auth « Bot ») | ``telegram`` (jeton dans
@@ -18,7 +28,9 @@ import logging
 
 from app.config import settings
 from app.db import get_conn
+from app.services import coffre_reference as coffre_module
 from app.services import oauth_connectors
+from app.services.coffre_reference import CoffreWorkspaceMismatch
 from app.services.sso_provisioning import decrypt_secret, encrypt_secret
 
 logger = logging.getLogger(__name__)
@@ -118,18 +130,62 @@ def native_state(kind: str, user_id: int | None = None) -> tuple[str, str]:
     return ("ok", f"recherche web via {settings.web_search_provider or 'duckduckgo'}")
 
 
+#: Colonnes lues pour un connecteur personnel (les deux colonnes coffre
+#: sont ajoutées par la migration 52 ; les bases antérieures les ignorent
+#: via les requêtes tolérantes de `_select_cols` — voir ci-dessous).
+_CONNECTOR_COLS = ("id", "name", "url", "secret_encrypted", "enabled", "status",
+                   "detail", "kind", "auth", "tools_json", "workspace_id",
+                   "coffre_reference")
+
+
+def _select_cols(conn) -> str:
+    """Liste SELECT tolérante : les colonnes coffre n'existent qu'après
+    la migration 52 (bases créées avant, ou tests à schéma figé)."""
+    try:
+        cols = {r[1] for r in conn.execute("PRAGMA table_info(agent_connectors)")}
+    except Exception:  # noqa: BLE001 — repli : colonnes historiques seules
+        cols = set(_CONNECTOR_COLS[:10])
+    wanted = [c for c in _CONNECTOR_COLS if c in cols]
+    return ", ".join(wanted) if wanted else ", ".join(_CONNECTOR_COLS[:10])
+
+
 def _row(r) -> dict:
-    """Ligne `agent_connectors` → dict API (le jeton n'y figure jamais)."""
+    """Ligne `agent_connectors` → dict API (le jeton n'y figure jamais).
+
+    ``coffre_reference`` est une métadonnée (pas une valeur) : elle peut
+    figurer dans la réponse. ``secret_source`` indique la provenance :
+    ``coffre`` (distribué à l'appel), ``chiffre_local`` (Fernet historique)
+    ou ``aucun``.
+    """
     try:
         tools = json.loads(r["tools_json"] or "[]") if "tools_json" in r.keys() else []
     except (ValueError, TypeError):
         tools = []
+    try:
+        reference = r["coffre_reference"] or ""
+    except (KeyError, IndexError):
+        reference = ""
+    try:
+        workspace_id = r["workspace_id"]
+    except (KeyError, IndexError):
+        workspace_id = None
+    try:
+        stored = r["secret_encrypted"]
+    except (KeyError, IndexError):
+        stored = ""
+    if reference:
+        source = "coffre"
+    elif stored:
+        source = "chiffre_local"
+    else:
+        source = "aucun"
     return {
         "id": r["id"], "builtin": False, "kind": r["kind"], "name": r["name"],
         "url": r["url"], "auth": r["auth"], "enabled": bool(r["enabled"]),
         "status": r["status"], "detail": r["detail"] or "",
-        "has_secret": bool(r["secret_encrypted"]), "oauth": False,
-        "tools_count": len(tools),
+        "has_secret": bool(stored or reference), "oauth": False,
+        "tools_count": len(tools), "workspace_id": workspace_id,
+        "coffre_reference": reference, "secret_source": source,
     }
 
 
@@ -146,28 +202,47 @@ def list_connectors(user_id: int | None = None) -> list[dict]:
             "has_secret": False, "oauth": kind in OAUTH_KINDS,
         })
     with get_conn() as conn:
+        cols = _select_cols(conn)
         rows = conn.execute(
-            "SELECT id, name, url, secret_encrypted, enabled, status, detail, "
-            "kind, auth, tools_json FROM agent_connectors ORDER BY id"
+            f"SELECT {cols} FROM agent_connectors ORDER BY id"
         ).fetchall()
     return out + [_row(r) for r in rows]
 
 
 def get(connector_id: int) -> dict | None:
     with get_conn() as conn:
+        cols = _select_cols(conn)
         r = conn.execute(
-            "SELECT id, name, url, secret_encrypted, enabled, status, detail, "
-            "kind, auth, tools_json FROM agent_connectors WHERE id=?",
+            f"SELECT {cols} FROM agent_connectors WHERE id=?",
             (connector_id,),
         ).fetchone()
     return _row(r) if r else None
 
 
+def _workspace_exists(workspace_id: int) -> bool:
+    with get_conn() as conn:
+        row = conn.execute(
+            "SELECT id FROM workspaces WHERE id=?", (workspace_id,)
+        ).fetchone()
+    return row is not None
+
+
 # ── CRUD (personnels) ────────────────────────────────────────────────────────
 
 def create_connector(name: str, url: str, secret: str = "", *,
-                     kind: str = "custom", auth: str = "bearer") -> dict:
-    """Valide l'URL (garde SSRF) puis stocke la clé **chiffrée** (Fernet)."""
+                     kind: str = "custom", auth: str = "bearer",
+                     workspace_id: int | None = None,
+                     coffre_reference: str | None = None) -> dict:
+    """Valide l'URL (garde SSRF) puis stocke la clé **chiffrée** (Fernet).
+
+    Variante coffre (Phase 4) : si ``coffre_reference`` est fourni, le
+    champ jeton **devient** ce champ référence — aucun jeton n'est stocké
+    (``secret_encrypted`` reste vide) et un ``workspace_id`` existant est
+    **obligatoire** (octroi toujours lié à un workspace). ``secret`` et
+    ``coffre_reference`` sont exclusifs. Un connecteur sans référence peut
+    aussi recevoir un ``workspace_id`` (première étape d'une migration
+    opportuniste : rattacher d'abord, basculer ensuite).
+    """
     from app.services.importers.url_fetch import _validate_url
 
     name = (name or "").strip()
@@ -177,22 +252,60 @@ def create_connector(name: str, url: str, secret: str = "", *,
         raise ValueError(f"kind invalide: {kind} (attendu {', '.join(CUSTOM_KINDS)})")
     if auth not in AUTH_SCHEMES:
         raise ValueError(f"auth invalide: {auth} (attendu {', '.join(AUTH_SCHEMES)})")
+    reference = ""
+    if coffre_reference is not None and str(coffre_reference).strip():
+        reference = coffre_module.parse_reference(str(coffre_reference))
+        reference = f"coffre:{reference[0]}/{reference[1]}"
+        if (secret or "").strip():
+            raise ValueError("secret et coffre_reference sont exclusifs "
+                             "(le jeton devient la référence)")
+        if workspace_id is None:
+            raise ValueError("coffre_reference exige un workspace_id "
+                             "(octroi toujours lié à un workspace)")
+    if workspace_id is not None:
+        workspace_id = int(workspace_id)
+        if workspace_id <= 0 or not _workspace_exists(workspace_id):
+            raise ValueError(f"workspace introuvable: {workspace_id}")
     url = (url or "").strip()
-    if "{secret}" in url and not (secret or "").strip():
+    if "{secret}" in url and not (secret or "").strip() and not reference:
         raise ValueError("clé requise : l'URL contient {secret}")
     url = _validate_url(url)                 # lève ValueError si hôte interne
     with get_conn() as conn:
+        cols = {r[1] for r in conn.execute("PRAGMA table_info(agent_connectors)")}
+        extra_cols, extra_vals = "", ()
+        if "workspace_id" in cols:
+            extra_cols += ", workspace_id"
+            extra_vals += (workspace_id,)
+        if "coffre_reference" in cols:
+            extra_cols += ", coffre_reference"
+            extra_vals += (reference,)
         cur = conn.execute(
             "INSERT INTO agent_connectors (name, url, secret_encrypted, status, "
-            "detail, kind, auth) VALUES (?,?,?,?,?,?,?)",
-            (name, url, encrypt_secret(secret or ""), "unknown", "", kind, auth),
+            f"detail, kind, auth{extra_cols}) VALUES (?,?,?,?,?,?,?{',?' * len(extra_vals)})",
+            (name, url, encrypt_secret(secret or "") if not reference else "",
+             "unknown", "", kind, auth, *extra_vals),
         )
         conn.commit()
         cid = cur.lastrowid
     return get(cid)
 
 
-def update_connector(connector_id: int, *, name=None, enabled=None, secret=None) -> dict | None:
+_UNSET = object()
+
+
+def update_connector(connector_id: int, *, name=None, enabled=None, secret=None,
+                     workspace_id=_UNSET, coffre_reference=_UNSET) -> dict | None:
+    """Met à jour un connecteur personnel.
+
+    Règles coffre (Phase 4) :
+    * poser une référence exige un workspace (celui du connecteur, ou
+      celui passé dans le même appel) ; la référence et un jeton local
+      sont exclusifs dans le même appel ;
+    * un ``workspace_id`` déjà posé est **immuable** : on ne transfère pas
+      un octroi d'un workspace à l'autre en éditant le connecteur ;
+    * effacer la référence (``coffre_reference=""``) réactive l'éventuel
+      jeton local dormant, sans jamais le réécrire.
+    """
     row = get(connector_id)
     if row is None:
         return None
@@ -206,7 +319,40 @@ def update_connector(connector_id: int, *, name=None, enabled=None, secret=None)
     if enabled is not None:
         sets.append("enabled=?")
         params.append(1 if enabled else 0)
+    effective_workspace = row.get("workspace_id")
+    if workspace_id is not _UNSET:
+        if workspace_id is None:
+            raise ValueError("workspace_id ne peut pas être effacé")
+        workspace_id = int(workspace_id)
+        if workspace_id <= 0 or not _workspace_exists(workspace_id):
+            raise ValueError(f"workspace introuvable: {workspace_id}")
+        if row.get("workspace_id") is not None and row["workspace_id"] != workspace_id:
+            raise ValueError("workspace_id immuable : un connecteur ne change "
+                             "pas de workspace (pas de transfert d'octroi)")
+        effective_workspace = workspace_id
+        sets.append("workspace_id=?")
+        params.append(workspace_id)
+    reference_cleared = False
+    if coffre_reference is not _UNSET:
+        if coffre_reference is None or not str(coffre_reference).strip():
+            reference_cleared = True
+            sets.append("coffre_reference=?")
+            params.append("")
+        else:
+            parsed = coffre_module.parse_reference(str(coffre_reference))
+            if effective_workspace is None:
+                raise ValueError("coffre_reference exige un workspace_id "
+                                 "(octroi toujours lié à un workspace)")
+            if secret is not None and str(secret).strip():
+                raise ValueError("secret et coffre_reference sont exclusifs "
+                                 "(le jeton devient la référence)")
+            sets.append("coffre_reference=?")
+            params.append(f"coffre:{parsed[0]}/{parsed[1]}")
     if secret is not None:
+        if row.get("coffre_reference") and not reference_cleared:
+            raise ValueError("ce connecteur pointe vers une référence ObsiGate : "
+                             "effacez d'abord coffre_reference pour revenir "
+                             "à un jeton local")
         sets.append("secret_encrypted=?")
         params.append(encrypt_secret(str(secret)))
     if sets:
@@ -226,22 +372,72 @@ def delete_connector(connector_id: int) -> bool:
 
 # ── Réseau (toujours gardé SSRF) ─────────────────────────────────────────────
 
-def _headers(connector_id: int | None = None) -> dict:
-    """En-têtes d'appel : la clé n'est lue (et déchiffrée) qu'ici, jamais renvoyée.
+def resolve_secret(connector_id: int, *, workspace_id: int | None = None,
+                     distribute=None) -> str:
+    """Résout le jeton d'un connecteur **en mémoire**, jamais persisté.
+
+    * Connecteur à référence : le ``workspace_id`` demandé doit être
+      celui du connecteur, sinon ``CoffreWorkspaceMismatch`` explicite
+      **avant tout appel** à ObsiGate (le distributeur n'est pas appelé).
+      La valeur distribuée est renvoyée à l'appelant, qui l'utilise puis
+      l'oublie — aucune mise en cache ici.
+    * Connecteur historique : déchiffrement Fernet local (migration
+      opportuniste : ces connecteurs restent valides tels quels).
+    * Sans jeton ni référence : chaîne vide.
+    """
+    # Lecture directe en base : le dict API de get() n'expose jamais le
+    # jeton (chiffré ou non), c'est ici seulement qu'il est résolu.
+    with get_conn() as conn:
+        cols = _select_cols(conn)
+        r = conn.execute(
+            f"SELECT {cols} FROM agent_connectors WHERE id=?",
+            (connector_id,),
+        ).fetchone()
+    if r is None:
+        raise ValueError(f"Connecteur introuvable: {connector_id}")
+    try:
+        reference = r["coffre_reference"] or ""
+    except (KeyError, IndexError):
+        reference = ""
+    try:
+        owner = r["workspace_id"]
+    except (KeyError, IndexError):
+        owner = None
+    if reference:
+        if workspace_id is None:
+            raise ValueError("workspace_id est requis pour un connecteur "
+                             "à référence ObsiGate")
+        if owner is None or int(owner) != int(workspace_id):
+            raise CoffreWorkspaceMismatch(
+                f"workspace {workspace_id} ne peut pas utiliser ce connecteur "
+                f"(il appartient au workspace {owner}) : octroi d'un autre "
+                "workspace refusé"
+            )
+        return coffre_module.distribuer(
+            reference, int(workspace_id), request=distribute)
+    try:
+        stored = r["secret_encrypted"]
+    except (KeyError, IndexError):
+        stored = ""
+    return decrypt_secret(stored or "")
+
+
+def _headers(connector_id: int | None = None, *, workspace_id: int | None = None,
+             distribute=None) -> dict:
+    """En-têtes d'appel : la clé n'est lue (et déchiffrée/distribuée) qu'ici.
 
     ``auth`` = bearer (défaut) | bot (Discord, jeton préfixé) | none (jeton ailleurs).
+    Pour un connecteur à référence, ``workspace_id`` est obligatoire et
+    l'isolation est vérifiée par ``resolve_secret`` avant distribution.
     """
     headers = {"User-Agent": "FlowDeck-Connectors/1.0"}
     secret, auth = "", "bearer"
     if connector_id:
-        with get_conn() as conn:
-            r = conn.execute(
-                "SELECT secret_encrypted, auth FROM agent_connectors WHERE id=?",
-                (connector_id,),
-            ).fetchone()
-        if r:
-            secret = decrypt_secret(r["secret_encrypted"] or "")
-            auth = r["auth"] or "bearer"
+        row = get(connector_id)
+        if row:
+            auth = row["auth"] or "bearer"
+            secret = resolve_secret(connector_id, workspace_id=workspace_id,
+                                    distribute=distribute)
     if secret and auth == "bot":
         headers["Authorization"] = f"Bot {secret}"
     elif secret and auth != "none":
@@ -250,16 +446,13 @@ def _headers(connector_id: int | None = None) -> dict:
     return headers
 
 
-def _with_secret(url: str, connector_id: int) -> str:
+def _with_secret(url: str, connector_id: int, *, workspace_id: int | None = None,
+                 distribute=None) -> str:
     """Substitue ``{secret}`` (Telegram : le jeton vit dans l'URL, jamais stocké clair)."""
     if "{secret}" not in url:
         return url
-    with get_conn() as conn:
-        r = conn.execute(
-            "SELECT secret_encrypted FROM agent_connectors WHERE id=?",
-            (connector_id,),
-        ).fetchone()
-    secret = decrypt_secret((r["secret_encrypted"] if r else "") or "")
+    secret = resolve_secret(connector_id, workspace_id=workspace_id,
+                            distribute=distribute)
     if not secret:
         raise ValueError("clé manquante pour une URL contenant {secret}")
     return url.replace("{secret}", secret)
@@ -303,13 +496,20 @@ def _resolve(connector: str) -> tuple[str, str | int]:
     raise ValueError(f"Connecteur inconnu: {token}")
 
 
-async def probe(connector: str, user_id: int | None = None) -> dict:
-    """Teste un connecteur et **persiste** le résultat (personnel uniquement)."""
+async def probe(connector: str, user_id: int | None = None, *,
+                workspace_id: int | None = None, distribute=None) -> dict:
+    """Teste un connecteur et **persiste** le résultat (personnel uniquement).
+
+    ``workspace_id`` est transmis aux chemins à référence ObsiGate ; un
+    connecteur à référence testé sans workspace échoue proprement
+    (``error``), jamais avec une valeur d'un autre workspace.
+    """
     kind, ref = _resolve(connector)
     try:
         if kind in MCP_KINDS:
             from app.services import mcp_client
-            tools = await mcp_client.initialize_and_list(int(ref))
+            tools = await mcp_client.initialize_and_list(
+                int(ref), workspace_id=workspace_id, distribute=distribute)
             status, detail = "ok", f"MCP · {len(tools)} outil(s)"
         elif kind in OAUTH_KINDS:
             res = await oauth_connectors.api_get(kind, user_id,
@@ -326,8 +526,10 @@ async def probe(connector: str, user_id: int | None = None) -> dict:
             status, detail = "ok", native_state("web")[1]
         else:
             row = get(int(ref))
-            url = _with_secret(row["url"], int(ref))
-            code, _ = await _get(url, _headers(int(ref)))
+            url = _with_secret(row["url"], int(ref), workspace_id=workspace_id,
+                               distribute=distribute)
+            code, _ = await _get(url, _headers(int(ref), workspace_id=workspace_id,
+                                               distribute=distribute))
             status, detail = ("ok" if code < 400 else "error"), f"HTTP {code}"
     except Exception as exc:  # noqa: BLE001 — un probe ne casse jamais l'UI
         logger.info("Connector probe failed (%s): %s", connector, exc)
@@ -351,7 +553,9 @@ def _gh_headers() -> dict:
 
 
 async def connector_fetch(connector: str, path: str = "", query: str = "",
-                          user_id: int | None = None) -> dict:
+                          user_id: int | None = None, *,
+                          workspace_id: int | None = None,
+                          distribute=None) -> dict:
     """Lit un connecteur pour l'LLM : natif = API, web = recherche, perso = GET."""
     kind, ref = _resolve(connector)
     path = (path or "").strip()
@@ -381,10 +585,12 @@ async def connector_fetch(connector: str, path: str = "", query: str = "",
             return {"status": "error", "text": "Connecteur supprimé"}
         if not row["enabled"]:
             return {"status": "error", "text": "Connecteur désactivé"}
-        url = _with_secret(row["url"], int(ref)).rstrip("/")
+        url = _with_secret(row["url"], int(ref), workspace_id=workspace_id,
+                           distribute=distribute).rstrip("/")
         if path:
             url += "/" + path.lstrip("/")
-        code, text = await _get(url, _headers(int(ref)))
+        code, text = await _get(url, _headers(int(ref), workspace_id=workspace_id,
+                                              distribute=distribute))
     if code >= 400:
         return {"status": "error", "text": f"HTTP {code} — {text[:400]}"}
     return {"status": "ok", "text": text[:FETCH_LIMIT]}

app/services/mcp_client.py

@@ -189,7 +189,8 @@ async def _handshake(url: str, headers: dict | None) -> dict:
     return session
 
 
-def _server(connector_id: int) -> dict:
+def _server(connector_id: int, *, workspace_id: int | None = None,
+              distribute=None) -> dict:
     row = get(connector_id)
     if row is None:
         raise ValueError("Serveur MCP introuvable")
@@ -198,7 +199,8 @@ def _server(connector_id: int) -> dict:
     if not row["enabled"]:
         raise ValueError("Serveur MCP désactivé")
     return {"id": row["id"], "name": row["name"], "url": row["url"],
-            "headers": _headers(connector_id)}
+            "headers": _headers(connector_id, workspace_id=workspace_id,
+                                distribute=distribute)}
 
 
 def _normalize(server: dict, raw: list) -> list[dict]:
@@ -226,10 +228,16 @@ def _save_tools(connector_id: int, tools: list[dict]) -> None:
         conn.commit()
 
 
-async def initialize_and_list(connector_id: int) -> list[dict]:
-    """Handshake + ``tools/list`` → met à jour le cache de la base."""
-    srv = _server(connector_id)
-    url = _with_secret(srv["url"], connector_id)
+async def initialize_and_list(connector_id: int, *, workspace_id: int | None = None,
+                              distribute=None) -> list[dict]:
+    """Handshake + ``tools/list`` → met à jour le cache de la base.
+
+    Pour un serveur à référence ObsiGate, ``workspace_id`` est obligatoire
+    (isolation vérifiée avant distribution, voir ``connectors``).
+    """
+    srv = _server(connector_id, workspace_id=workspace_id, distribute=distribute)
+    url = _with_secret(srv["url"], connector_id, workspace_id=workspace_id,
+                       distribute=distribute)
     session = await _handshake(url, srv["headers"])
     data = await _rpc(url, {"jsonrpc": "2.0", "id": 2, "method": "tools/list",
                             "params": {}}, session)
@@ -276,14 +284,16 @@ def _content_text(result: dict) -> str:
     return "\n".join(p for p in parts if p) or json.dumps(result, ensure_ascii=False)[:4000]
 
 
-async def call_tool(connector_id: int, tool: str, arguments: dict | None = None) -> dict:
+async def call_tool(connector_id: int, tool: str, arguments: dict | None = None, *,
+                    workspace_id: int | None = None, distribute=None) -> dict:
     """``tools/call`` → {status, text} (isError → error, borné à 20 000 car.).
 
     Le handshake (avec session éventuelle) précède systématiquement
     l'appel : c'est la condition T0 des serveurs à session.
     """
-    srv = _server(connector_id)
-    url = _with_secret(srv["url"], connector_id)
+    srv = _server(connector_id, workspace_id=workspace_id, distribute=distribute)
+    url = _with_secret(srv["url"], connector_id, workspace_id=workspace_id,
+                       distribute=distribute)
     session = await _handshake(url, srv["headers"])
     data = await _rpc(url, {
         "jsonrpc": "2.0", "id": 3, "method": "tools/call",

app/services/meeting_archive.py

@@ -0,0 +1,166 @@
+"""Pilote ACC-6.2 — archiver un résumé de réunion Flowdeck dans
+ObsiGate, **via la file d'approbations unifiée**.
+
+Chaîne du pilote (patron d'écriture approuvée §7.5) :
+
+1. ``demander_approbation`` — depuis la note de réunion (transcript
+   avec résumé généré), on prépare l'archive (titre, chemin cible
+   dans le vault, contenu Markdown) et on dépose une demande dans
+   ``agent_approvals`` (outil ``archiver_reunion_obsigate``) : rien
+   n'est écrit tant que Bruno n'a pas approuvé.
+2. À l'approbation (route gouvernance ``…/agent-approvals/{id}/decide``
+   qui appelle ``traiter_decision``), ``executer`` envoie le contenu à
+   ObsiGate par le pont MCP (ACC-2.2) en ``propose_write_file`` —
+   jamais en écriture directe : ObsiGate garde son propre brouillon,
+   l'application propriétaire tranche l'application finale.
+3. La distribution est journalisée dans ``meeting_distributions``
+   (canal ``obsigate``), comme les autres canaux de diffusion.
+
+Prérequis réels (gestes de Bruno, inchangés) : connecteur
+« obsigate » configuré et sondé dans Flowdeck (clé ObsiGate dédiée
+au pont, limitée à un vault) — sans lui, l'exécution échoue avec un
+message explicite, la demande reste tracée. Le pilote est
+**conditionnel au chantier Meetings** (décision A/B de Bruno) pour
+son usage réel ; le code n'en dépend pas : il archive le résumé
+d'un transcript existant.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+
+from app.db import get_conn
+from app.services import draco_urls, meetings
+
+logger = logging.getLogger(__name__)
+
+#: Nom d'« outil » porté par les demandes d'approbation du pilote
+#: dans la file unifiée (`agent_approvals`).
+OUTIL = "archiver_reunion_obsigate"
+
+#: Dossier cible dans le vault ObsiGate.
+DOSSIER = "Réunions"
+
+
+def _assainir(nom: str) -> str:
+    nom = re.sub(r"[\\/:*?\"<>|]+", " ", nom or "")
+    nom = re.sub(r"\s+", " ", nom).strip().strip(".")
+    return nom[:80] or "Réunion sans titre"
+
+
+def construire_archive(tr: dict) -> dict:
+    """Transcript (avec résumé) → {titre, chemin, contenu} de l'archive."""
+    titre = (tr.get("generated_title") or "").strip() or "Réunion"
+    date = str(tr.get("created_at") or "")[:10]
+    chemin = f"{DOSSIER}/{date + ' - ' if date else ''}{_assainir(titre)}.md"
+    lien = f"{draco_urls.flowdeck_url()}/pages/{tr['page_id']}"
+    contenu = (
+        f"# {titre}\n\n"
+        f"> Résumé de réunion archivé depuis Flowdeck "
+        f"({date or 'date inconnue'}) — note source : {lien}\n\n"
+        f"{(tr.get('summary') or '').strip()}\n"
+    )
+    return {"titre": titre, "chemin": chemin, "contenu": contenu}
+
+
+def demander_approbation(transcript_id: int, user_id: int) -> dict:
+    """Dépose la demande d'archivage dans la file d'approbations.
+
+    Lève ValueError si le transcript n'existe pas, si son résumé est
+    vide (rien à archiver) ou si une demande identique est déjà en
+    attente (pas de doublon dans la file).
+    """
+    tr = meetings.get_transcript(transcript_id)
+    if not (tr.get("summary") or "").strip():
+        raise ValueError("Résumé vide : générer le résumé avant d'archiver")
+    archive = construire_archive(tr)
+    args = {"transcript_id": transcript_id, "chemin": archive["chemin"],
+            "titre": archive["titre"]}
+    with get_conn() as conn:
+        en_attente = conn.execute(
+            "SELECT id, args_json FROM agent_approvals "
+            "WHERE tool=? AND status='pending'", (OUTIL,)).fetchall()
+        for row in en_attente:
+            try:
+                if json.loads(row["args_json"] or "{}").get("transcript_id") == transcript_id:
+                    raise ValueError(
+                        "Une demande d'archivage est déjà en attente "
+                        f"(approbation #{row['id']})")
+            except json.JSONDecodeError:
+                continue
+        cur = conn.execute(
+            "INSERT INTO agent_approvals "
+            "(conversation_id, tool, args_json, status, requester_id) "
+            "VALUES (0, ?, ?, 'pending', ?)",
+            (OUTIL, json.dumps(args, ensure_ascii=False), user_id))
+        conn.commit()
+        row = conn.execute("SELECT * FROM agent_approvals WHERE id=?",
+                           (cur.lastrowid,)).fetchone()
+    return dict(row)
+
+
+def _connecteur_obsigate() -> dict | None:
+    """Premier connecteur ObsiGate activé (preset ACC-2.2), ou None."""
+    from app.services import connectors
+
+    for row in connectors.list_connectors():
+        if row.get("kind") == "obsigate" and row.get("enabled"):
+            return row
+    return None
+
+
+async def executer(approval: dict) -> dict:
+    """Exécute un archivage **approuvé** : propose_write_file via le
+    pont MCP. Retourne {status: ok|erreur, detail} — ne lève pas."""
+    from app.services import mcp_client
+
+    try:
+        args = json.loads(approval.get("args_json") or "{}")
+    except json.JSONDecodeError:
+        args = {}
+    transcript_id = args.get("transcript_id")
+    conn = _connecteur_obsigate()
+    if conn is None:
+        return {"status": "erreur",
+                "detail": "Connecteur ObsiGate non configuré dans Flowdeck "
+                          "(Panneau agent → Connecteurs → ObsiGate) : "
+                          "archivage impossible."}
+    try:
+        tr = meetings.get_transcript(int(transcript_id))
+        archive = construire_archive(tr)
+        res = await mcp_client.call_tool(
+            conn["id"], "propose_write_file",
+            {"path": archive["chemin"], "content": archive["contenu"]})
+    except Exception as exc:  # noqa: BLE001 — l'échec est journalisé, pas levé
+        logger.warning("Archivage réunion ObsiGate échoué: %s", exc)
+        return {"status": "erreur", "detail": str(exc)[:300]}
+    if res.get("status") != "ok":
+        return {"status": "erreur",
+                "detail": (res.get("text") or "ObsiGate a refusé la proposition")[:300]}
+    meetings.record_distribution(
+        int(transcript_id), channel="obsigate",
+        actor_id=approval.get("approver_id"),
+        recipients=archive["chemin"], status="propose")
+    return {"status": "ok",
+            "detail": f"Proposition d'écriture envoyée à ObsiGate : "
+                      f"{archive['chemin']} (brouillon à appliquer dans ObsiGate)"}
+
+
+def executer_sync(approval: dict) -> dict:
+    """Variante synchrone pour les routes non async (threadpool)."""
+    return asyncio.run(executer(approval))
+
+
+def traiter_decision_sync(approval: dict) -> dict | None:
+    """Après décision dans la file unifiée : si la demande est du
+    pilote et approuvée, exécuter l'archivage. Sinon None (autre
+    outil) — la route gouvernance est synchrone (threadpool)."""
+    if not approval or approval.get("tool") != OUTIL:
+        return None
+    if approval.get("status") != "approved":
+        return {"status": "rejete",
+                "detail": "Demande rejetée : rien n'a été envoyé à ObsiGate."}
+    return executer_sync(approval)

app/services/meetings.py

@@ -717,8 +717,8 @@ async def summarize_transcript(transcript_id: int, user_id: int | None = None,
 def record_distribution(transcript_id: int, *, channel: str,
                         actor_id: int | None = None,
                         recipients: str = "", status: str = "created") -> dict:
-    if channel not in ("copy_link", "email", "slack"):
-        raise ValueError("channel must be copy_link|email|slack")
+    if channel not in ("copy_link", "email", "slack", "obsigate"):
+        raise ValueError("channel must be copy_link|email|slack|obsigate")
     get_transcript(transcript_id)
     with get_conn() as conn:
         cur = conn.execute(

app/services/skill_format.py

@@ -0,0 +1,218 @@
+"""Format de skill commun (Fusion ACC-0.3) — lecture, validation,
+conversion (ACC-4.5).
+
+Le contrat figé vit dans `dracodev-commons/contrats/skill-format.md` :
+un dossier par skill, un `SKILL.md` à frontmatter YAML (`name`,
+`description` = déclencheur, `version`, `apps`, `domaines`, `outils`,
+section `ecritures` obligatoire dès qu'il y a modification) et un
+corps en trois sections ordonnées — **Quand l'utiliser**,
+**Procédure**, **Garde-fous**.
+
+Ce module est la part Flowdeck de la preuve du format (ACC-4.5) :
+
+- ``analyser_skill_md`` : SKILL.md → structure (métadonnées + sections) ;
+- ``valider`` : contrôle du contrat, liste d'erreurs lisibles ;
+- ``vers_champs_flowdeck`` : conversion vers les champs d'un skill
+  Flowdeck (`agent_skills` / galerie) — les outils `flowdeck.*`
+  deviennent les `allowed_tools`, la Procédure devient le
+  `prompt_template` (précédée du déclencheur et suivie des garde-fous) ;
+- ``depuis_preset_flowdeck`` : conversion inverse d'un preset de la
+  galerie vers un SKILL.md au format commun (point de départ d'une
+  conversion relue par un humain).
+
+Les skills convertis de la galerie vivent dans `skills-communs/` à la
+racine du dépôt ; ils sont installables tels quels via
+``skill_gallery.upsert_skill(vers_champs_flowdeck(...))``.
+"""
+
+from __future__ import annotations
+
+import re
+
+import yaml
+
+#: Sections du corps, dans l'ordre imposé par le contrat.
+SECTIONS = ("Quand l'utiliser", "Procédure", "Garde-fous")
+
+#: Valeurs admises pour l'approbation d'une écriture.
+APPROBATIONS = ("toujours", "selon-portee", "jamais")
+
+#: Champs de frontmatter obligatoires (contrat § « En-tête »).
+CHAMPS_REQUIS = ("name", "description", "version", "apps", "domaines")
+
+_KEBAB = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*$")
+_TITRE_SECTION = re.compile(r"^#{1,3}\s+(.+?)\s*$", re.MULTILINE)
+
+
+def analyser_skill_md(texte: str) -> dict:
+    """SKILL.md → {meta, sections, corps}. Lève ValueError si le
+    frontmatter est absent ou illisible."""
+    brut = (texte or "").replace("\r\n", "\n")
+    if not brut.startswith("---\n"):
+        raise ValueError("SKILL.md doit commencer par un frontmatter YAML (---)")
+    fin = brut.find("\n---", 4)
+    if fin < 0:
+        raise ValueError("Frontmatter YAML non fermé (---)")
+    try:
+        meta = yaml.safe_load(brut[4:fin]) or {}
+    except yaml.YAMLError as exc:
+        raise ValueError(f"Frontmatter YAML illisible : {exc}") from exc
+    if not isinstance(meta, dict):
+        raise ValueError("Frontmatter YAML : un objet est attendu")
+    corps = brut[fin + 4:].lstrip("\n")
+    sections: dict[str, str] = {}
+    marques = [(m.start(), m.group(1).strip()) for m in _TITRE_SECTION.finditer(corps)]
+    for i, (pos, titre) in enumerate(marques):
+        if titre in SECTIONS:
+            debut = corps.find("\n", pos) + 1
+            fin_s = marques[i + 1][0] if i + 1 < len(marques) else len(corps)
+            sections[titre] = corps[debut:fin_s].strip()
+    return {"meta": meta, "sections": sections, "corps": corps}
+
+
+def _outils_flowdeck(skill: dict) -> list[str]:
+    """Noms d'outils Flowdeck déclarés (préfixe `flowdeck.` retiré),
+    lectures (`outils`) puis écritures (`ecritures`), sans doublons."""
+    meta = skill["meta"]
+    noms: list[str] = []
+    for entree in meta.get("outils") or []:
+        nom = str(entree).strip()
+        if nom.startswith("flowdeck."):
+            noms.append(nom[len("flowdeck."):])
+    for entree in meta.get("ecritures") or []:
+        if isinstance(entree, dict):
+            nom = str(entree.get("action") or "").strip()
+            if nom.startswith("flowdeck."):
+                noms.append(nom[len("flowdeck."):])
+    return list(dict.fromkeys(noms))
+
+
+def valider(skill: dict) -> list[str]:
+    """Contrôle le contrat ACC-0.3 → liste d'erreurs (vide = conforme)."""
+    erreurs: list[str] = []
+    meta = skill.get("meta") or {}
+    for champ in CHAMPS_REQUIS:
+        valeur = meta.get(champ)
+        if valeur is None or (isinstance(valeur, str) and not valeur.strip()) \
+                or (isinstance(valeur, list) and not valeur):
+            erreurs.append(f"Champ obligatoire manquant ou vide : {champ}")
+    nom = str(meta.get("name") or "")
+    if nom and not _KEBAB.match(nom):
+        erreurs.append(f"name doit être en kebab-case : {nom!r}")
+    for champ in ("apps", "domaines"):
+        valeur = meta.get(champ)
+        if valeur is not None and (not isinstance(valeur, list)
+                                   or not all(isinstance(v, str) for v in valeur)):
+            erreurs.append(f"{champ} doit être une liste de chaînes")
+    outils = meta.get("outils") or []
+    if not isinstance(outils, list) or not all(isinstance(o, str) for o in outils):
+        erreurs.append("outils doit être une liste de noms (app.outil)")
+    ecritures = meta.get("ecritures") or []
+    if not isinstance(ecritures, list):
+        erreurs.append("ecritures doit être une liste d'objets {action, approbation}")
+        ecritures = []
+    for entree in ecritures:
+        if not isinstance(entree, dict) or not str(entree.get("action") or "").strip():
+            erreurs.append("Chaque écriture doit déclarer une action")
+            continue
+        approbation = str(entree.get("approbation") or "selon-portee")
+        if approbation not in APPROBATIONS:
+            erreurs.append(
+                f"approbation inconnue pour {entree['action']} : {approbation!r} "
+                f"(attendu : {', '.join(APPROBATIONS)})")
+    # Règle du contrat : « ecritures » obligatoire dès que le skill
+    # modifie quelque chose — pour la part Flowdeck, un outil déclaré
+    # qui est un outil d'écriture interne impose la section.
+    if not ecritures and "flowdeck" in (meta.get("apps") or []):
+        from app.services.permission_manager import DESTRUCTIVE_TOOLS, WRITE_TOOLS
+
+        modifiants = [o for o in _outils_flowdeck(skill)
+                      if o in WRITE_TOOLS or o in DESTRUCTIVE_TOOLS]
+        if modifiants:
+            erreurs.append(
+                "Section ecritures obligatoire : le skill utilise des outils "
+                f"d'écriture Flowdeck ({', '.join(modifiants)})")
+    sections = skill.get("sections") or {}
+    for titre in SECTIONS:
+        if not sections.get(titre):
+            erreurs.append(f"Section de corps manquante ou vide : « {titre} »")
+    return erreurs
+
+
+def vers_champs_flowdeck(skill: dict) -> dict:
+    """Skill au format commun → champs Flowdeck (`agent_skills`).
+
+    Le `prompt_template` assemble le déclencheur, la procédure et les
+    garde-fous ; les écritures déclarées restent visibles dans le
+    prompt (le skill ne s'exécute jamais sans la politique d'agent).
+    """
+    erreurs = valider(skill)
+    if erreurs:
+        raise ValueError("Skill non conforme au format commun : " + " ; ".join(erreurs))
+    meta = skill["meta"]
+    sections = skill["sections"]
+    morceaux = [
+        "Quand l'utiliser\n" + sections["Quand l'utiliser"],
+        "Procédure\n" + sections["Procédure"],
+        "Garde-fous\n" + sections["Garde-fous"],
+    ]
+    ecritures = meta.get("ecritures") or []
+    if ecritures:
+        lignes = "\n".join(
+            f"- {e['action']} : approbation "
+            f"{e.get('approbation') or 'selon-portee'}"
+            for e in ecritures)
+        morceaux.append(f"Écritures déclarées (format commun)\n{lignes}")
+    return {
+        "name": str(meta["name"]),
+        "description": str(meta["description"]).strip(),
+        "prompt_template": "\n\n".join(morceaux),
+        "allowed_tools": _outils_flowdeck(skill),
+    }
+
+
+def _slug(nom: str) -> str:
+    import unicodedata
+
+    plat = unicodedata.normalize("NFD", nom.lower())
+    plat = "".join(c for c in plat if unicodedata.category(c) != "Mn")
+    slug = re.sub(r"[^a-z0-9]+", "-", plat).strip("-")
+    return slug or "skill"
+
+
+def depuis_preset_flowdeck(preset: dict, *, domaines: list[str] | None = None) -> str:
+    """Preset de la galerie Flowdeck → SKILL.md au format commun.
+
+    Point de départ d'une conversion (ACC-4.5) : les outils
+    d'écriture du preset deviennent la section `ecritures`
+    (approbation `selon-portee`, le régime par défaut du contrat) ;
+    le texte est à relire par un humain avant diffusion.
+    """
+    from app.services.permission_manager import WRITE_TOOLS
+
+    outils = [str(o) for o in preset.get("allowed_tools") or []]
+    lectures = [o for o in outils if o not in WRITE_TOOLS]
+    ecritures = [o for o in outils if o in WRITE_TOOLS]
+    meta: dict = {
+        "name": _slug(str(preset.get("name") or "skill")),
+        "description": str(preset.get("description") or "").strip(),
+        "version": "1.0.0",
+        "apps": ["flowdeck"],
+        "domaines": domaines or ["pro"],
+        "outils": [f"flowdeck.{o}" for o in lectures],
+    }
+    if ecritures:
+        meta["ecritures"] = [
+            {"action": f"flowdeck.{o}", "approbation": "selon-portee"}
+            for o in ecritures
+        ]
+    front = yaml.safe_dump(meta, allow_unicode=True, sort_keys=False).strip()
+    corps = (
+        f"## Quand l'utiliser\n\n{preset.get('description') or ''}\n\n"
+        f"## Procédure\n\n{preset.get('prompt_template') or ''}\n\n"
+        "## Garde-fous\n\n"
+        "- N'agir que dans les domaines déclarés ; un besoin croisé "
+        "entre domaines est signalé, jamais contourné.\n"
+        "- Ne jamais inventer un contenu absent des sources lues.\n"
+    )
+    return f"---\n{front}\n---\n\n{corps}"

app/templates/_draco_bar.html

@@ -1,5 +1,5 @@
 {# Barre d'apps commune dracodev — Fusion ACC-1.1 (issue #17).
-   Snippet FIGÉ vendangé depuis Projets/dracodev-commons v0.1.4
+   Snippet FIGÉ vendangé depuis Projets/dracodev-commons v0.1.6
    (ui/barre-apps/) : ne pas modifier la structure ici ; toute évolution
    passe par une nouvelle version de commons.
    CSS/JS : /static/css/draco-barre.css, /static/js/vendor/draco-barre.js.
@@ -56,8 +56,8 @@
             <span class="draco-spark-ico">✦</span><span class="draco-spark-txt">Spark</span>
             <span class="draco-badge" data-badge="spark" hidden>0</span>
         </button>
-        <button type="button" class="draco-icon-btn" data-act="menu" aria-label="Plus d'actions" aria-haspopup="menu">•••</button>
-        <span class="draco-avatar" title="{{ user.get('full_name') if user and user.get('full_name') else '' }}">{{ user.full_name[:1].upper() if user and user.get('full_name') else 'F' }}</span>
+        <button type="button" class="draco-icon-btn" data-act="menu" aria-label="Plus d'actions" aria-haspopup="menu" aria-expanded="false">•••</button>
+        <button type="button" class="draco-avatar" data-act="compte" aria-label="Compte" aria-haspopup="menu" aria-expanded="false" title="{{ user.get('full_name') if user and user.get('full_name') else '' }}">{{ user.full_name[:1].upper() if user and user.get('full_name') else 'F' }}</button>
     </div>
 </header>
 <div class="draco-bar-rappel" data-act="rappel-entete" hidden>✦ dracodev — afficher l'en-tête</div>
@@ -86,8 +86,14 @@
                 if (b) { b.click(); } else { dire("Alertes unifiées : arrive avec la fédération (programme Fusion)."); }
                 return;
             }
-            if (act === "palette") { dire("Recherche fédérée ⌘K : arrive avec la fédération (programme Fusion)."); return; }
-            if (act === "menu") { dire("Menu commun : arrive avec la fédération (programme Fusion)."); return; }
+            if (act === "palette") { location.href = "/recherche"; return; }
+            /* v0.1.6 : le toast placeholder "fédération" est remplacé
+               par le menu par défaut du nouveau JS — retourner false le
+               demande explicitement (un onAction existant garde sinon la
+               main). Contenu : Console agent + applications, URL résolues
+               donc dérivées -dev sur un hôte -dev. Nonce CSP du script
+               inchangé. */
+            if (act === "menu") { return false; }
             if (act === "spark") {
                 if (window.DRACO_PANNEAU) { window.DRACO_PANNEAU.toggle(); }
                 else { dire("Spark : le panneau n'a pas pu se charger."); }
@@ -101,3 +107,4 @@
         }
     };
 </script>
+

app/templates/recherche.html

@@ -0,0 +1,36 @@
+{% extends "base.html" %}
+{% block title_prefix %}Rechercher partout{% endblock %}
+{% block content %}
+<link rel="stylesheet" href="/static/css/recherche.css">
+<main class="rp-page" id="recherche" data-host="flowdeck"
+      data-base-obsigate="{{ bases.obsigate }}"
+      data-base-flowdeck="{{ bases.flowdeck }}"
+      data-base-tiktak="{{ bases.tiktak }}"
+      data-base-kanbante="{{ bases.kanbante }}">
+  <h1>Rechercher partout</h1>
+  <p class="rp-hint">Notes ObsiGate, pages Flowdeck, tâches TikTak, cartes Kanbante — dans l'environnement courant (dev reste dev). « / » ou Ctrl+K pour rechercher, ↑/↓ puis Entrée pour ouvrir un résultat.</p>
+  <div class="rp-form">
+    <input id="rp-q" class="rp-input" type="search" name="q" value="{{ q }}"
+           placeholder="Rechercher partout…" autocomplete="off" autofocus>
+  </div>
+  <section class="rp-section" data-rp-section="obsigate">
+    <div class="rp-head"><h2>ObsiGate — notes</h2><span class="rp-count"></span><a class="rp-all" href="#">Tout voir</a></div>
+    <div class="rp-body"><p class="rp-state">Tapez une recherche ci-dessus.</p></div>
+  </section>
+  <section class="rp-section" data-rp-section="flowdeck">
+    <div class="rp-head"><h2>Flowdeck — pages</h2><span class="rp-count"></span><a class="rp-all" href="#">Tout voir</a></div>
+    <div class="rp-body"><p class="rp-state">Tapez une recherche ci-dessus.</p></div>
+  </section>
+  <section class="rp-section" data-rp-section="tiktak">
+    <div class="rp-head"><h2>TikTak — tâches</h2><span class="rp-count"></span><a class="rp-all" href="#">Tout voir</a></div>
+    <div class="rp-body"><p class="rp-state">Tapez une recherche ci-dessus.</p></div>
+  </section>
+  <section class="rp-section" data-rp-section="kanbante">
+    <div class="rp-head"><h2>Kanbante — cartes</h2><span class="rp-count"></span><a class="rp-all" href="#">Tout voir</a></div>
+    <div class="rp-body"><p class="rp-state">Tapez une recherche ci-dessus.</p></div>
+  </section>
+</main>
+{% endblock %}
+{% block scripts %}
+<script src="/static/js/recherche.js"></script>
+{% endblock %}

docs/coffre-reference-flowdeck.md

@@ -0,0 +1,117 @@
+# Flowdeck — Connecteurs à référence ObsiGate (Phase 4, issue ObsiGate #22)
+
+## Principe
+
+Un connecteur personnel d'un workspace peut pointer vers une référence
+ObsiGate au lieu d'un jeton :
+
+```
+coffre:<slug>/<nom>          ex. coffre:flowdeck/gitea-lecture
+```
+
+* Le champ jeton du connecteur **devient** le champ référence : aucun
+  jeton n'est stocké pour ce connecteur (`secret_encrypted` reste vide).
+* L'octroi est **toujours lié à un `workspace_id`** : créer un connecteur
+  à référence sans workspace est refusé (HTTP 400 / `ValueError`).
+* À l'appel, le **serveur** Flowdeck appelle
+  `POST /api/coffres/distribuer` d'ObsiGate avec le jeton consommateur
+  Flowdeck et un contexte `flowdeck_workspace / <workspace_id>`, utilise
+  la valeur **en mémoire**, puis l'oublie. La valeur n'est jamais
+  persistée, jamais mise en cache, jamais journalisée, jamais renvoyée
+  à une réponse API ni au LLM.
+
+## Configuration (serveur Flowdeck)
+
+| Variable | Défaut | Rôle |
+| --- | --- | --- |
+| `OBSIGATE_COFFRE_URL` | dérivée de `DRACO_SSO_URL` | Base ObsiGate pour `/api/coffres/distribuer` |
+| `OBSIGATE_CONSUMER_TOKEN` | (vide = distribution désactivée) | Jeton **consommateur** Flowdeck enregistré dans ObsiGate |
+
+Le jeton consommateur est distinct du jeton MCP de notes et de la
+session SSO. Il ne figure dans aucun log, rapport ou réponse.
+
+## Isolation workspace — ce qui est garanti, et sa limite honnête
+
+**Garanti côté Flowdeck, avant tout appel** (`connectors.resolve_secret`) :
+
+* un connecteur à référence ne se résout que pour son propre
+  `workspace_id` ;
+* workspace A tentant d'utiliser le connecteur (donc la référence /
+  l'octroi) du workspace B reçoit un refus explicite
+  (`CoffreWorkspaceMismatch` : « … ne peut pas utiliser ce connecteur
+  (il appartient au workspace …) : octroi d'un autre workspace refusé »)
+  et **le distributeur n'est pas appelé** ;
+* un `workspace_id` déjà posé sur un connecteur est immuable : on ne
+  transfère pas un octroi en éditant le connecteur ;
+* un connecteur à référence testé/appelé sans `workspace_id` échoue
+  proprement, jamais avec la valeur d'un autre workspace.
+
+**Limite à connaître** : côté ObsiGate, l'octroi est accordé au
+consommateur **Flowdeck** (un jeton par application), pas à un workspace
+— le `contexte_id` transmis sert à la traçabilité, pas à un contrôle
+d'accès côté ObsiGate. L'isolation par workspace repose donc sur le
+contrôle Flowdeck ci-dessus. Une isolation appliquée côté ObsiGate
+exigerait un consommateur par workspace : c'est un reste à faire
+décidé côté ObsiGate (enregistrement de consommateurs par workspace),
+pas un prérequis pour utiliser ce mécanisme.
+
+## Échecs propres, sans repli
+
+| Situation | Comportement Flowdeck |
+| --- | --- |
+| ObsiGate injoignable / timeout / HTTP 5xx | `CoffreIndisponible` — l'appel échoue, **aucune** valeur en cache n'est utilisée (il n'y en a pas) |
+| Octroi révoqué / consommateur révoqué (403) | `CoffreAccesRefuse` — message « accès révoqué, à ré-accorder dans ObsiGate » |
+| Octroi expiré (403) / secret expiré (410) | `CoffreAccesRefuse` avec le code ObsiGate, sans la valeur |
+| Référence mal formée | `CoffreReferenceInvalide` (format `coffre:<slug>/<nom>`, slug 3–64, nom 3–128, minuscules, chiffres, `-`/`_`, aligné sur ObsiGate) |
+
+## Secrets déjà chiffrés : pas de big-bang
+
+Les connecteurs historiques (`secret_encrypted` Fernet) restent valides
+tels quels. La migration est **opportuniste, connecteur par
+connecteur** :
+
+1. (optionnel) rattacher d'abord le connecteur à son workspace
+   (`PATCH /api/agent/connectors/{id}` avec `workspace_id`) ;
+2. puis basculer vers la référence (`PATCH …` avec
+   `coffre_reference: "coffre:<slug>/<nom>"`) — le jeton local dormant
+   n'est pas effacé automatiquement, il est simplement ignoré tant que
+   la référence est posée ; effacer la référence (`""`) le réactive ;
+3. vérifier par un probe avec `workspace_id`, puis supprimer le jeton
+   local si besoin (rotation côté ObsiGate).
+
+## Chemin de migration par connecteur
+
+| Connecteur actuel | État dans cette branche | Chemin |
+| --- | --- | --- |
+| Personnels (`custom`, `discord`, `telegram`, `mcp`, `tiktak`, `obsigate`) | **Implémenté** : `workspace_id` + `coffre_reference`, résolution en mémoire, isolation testée | Basculer connecteur par connecteur (ci-dessus) |
+| Natifs Gitea / GitHub | **Inchangés** : jetons globaux d'instance (`GITEA_TOKEN`, `GITHUB_TOKEN` en `.env`) | Créer un connecteur personnel workspace-scopé à référence vers le même service et l'utiliser à la place du natif, quand le besoin workspace par workspace se présente ; les natifs ne sont pas supprimés (pas de big-bang) |
+| LLM global (`llm_config` id=1) et clés par utilisateur (`user_llm_keys`) | **Inchangés** : clés en clair en base (globale / par utilisateur, pas par workspace) | Travail ultérieur dédié : ajouter une colonne référence sur `user_llm_keys` + résolution par workspace, avec le même patron (distribution en mémoire, workspace obligatoire) ; hors périmètre de cette branche |
+| OAuth Google / M365 (`connector_tokens`) | **Inchangés** : jetons OAuth chiffrés par (kind, utilisateur) | Hors périmètre : le flux OAuth ne se prête pas à une référence coffre sans repenser le refresh ; à traiter séparément si besoin |
+
+## API
+
+* `POST /api/agent/connectors` accepte `workspace_id` et
+  `coffre_reference` (référence sans workspace → 400).
+* `PATCH /api/agent/connectors/{id}` accepte `workspace_id`
+  (premier rattachement seulement) et `coffre_reference` (`""` =
+  effacer la référence).
+* `POST /api/agent/connectors/probe` accepte `workspace_id`.
+* Réponses : `workspace_id`, `coffre_reference`, `secret_source`
+  (`coffre` | `chiffre_local` | `aucun`) — jamais de valeur.
+* `GET /api/agent/connectors` liste les connecteurs avec ces champs.
+
+## Ce qui reste à faire (validation réelle)
+
+* Valider contre une vraie instance ObsiGate : créer le consommateur
+  Flowdeck + les octrois, puis un probe réel avec `workspace_id`
+  (les tests ici utilisent un faux endpoint de distribution).
+* Threader `workspace_id` depuis l'agent : `AgentEngine.workspace_id`
+  → `connector_fetch` (outil LLM) et `McpTool.call_tool` — aujourd'hui
+  ces chemins appellent sans workspace et échouent proprement pour les
+  connecteurs à référence (refus, pas de fuite) ; les connecteurs
+  historiques ne sont pas affectés.
+* Le cas échéant, consommateur ObsiGate par workspace (voir limite
+  ci-dessus) et bascule des natifs Gitea/GitHub et des clés LLM
+  (tableau ci-dessus).
+* Interface : sélecteur de référence dans le formulaire connecteur
+  (aujourd'hui, champ `coffre_reference` via l'API seulement).

skills-communs/compte-rendu-reunion/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: compte-rendu-reunion
+description: >
+  Transforme une note brute de réunion en compte rendu structuré
+  (décisions et actions) dans Flowdeck. À utiliser quand Bruno demande
+  un compte rendu, un CR ou une synthèse décisionnelle à partir d'une
+  note de réunion.
+version: 1.0.0
+apps: [flowdeck]
+domaines: [pro, famille, perso]
+outils:
+  - flowdeck.search_workspace
+  - flowdeck.read_document
+ecritures:
+  - action: flowdeck.create_document
+    approbation: selon-portee
+  - action: flowdeck.write_blocks
+    approbation: selon-portee
+---
+
+## Quand l'utiliser
+
+Quand Bruno fournit une note de réunion brute — ou demande de la
+retrouver dans le workspace — et veut un compte rendu propre :
+décisions prises, actions avec responsable et échéance, points
+ouverts. Ne pas l'utiliser pour un simple résumé informatif sans
+décisions (voir `resume-document`).
+
+## Procédure
+
+1. Retrouver la note de réunion si elle n'est pas fournie
+   (search_workspace), puis la lire intégralement (read_document).
+2. Créer un document « CR — <titre> » (create_document).
+3. Y écrire (write_blocks) la structure : Contexte · Décisions
+   prises · Actions (avec responsable et échéance) · Points ouverts.
+4. Ne garder que ce qui est dans la note ; lister explicitement les
+   points manquants plutôt que de les combler.
+
+## Garde-fous
+
+- Aucune décision ni action inventée : tout vient de la note lue.
+- N'agir que dans les domaines déclarés ; un besoin croisé entre
+  domaines est signalé, jamais contourné.
+- L'écriture du document suit la politique d'approbation de l'agent
+  (section `ecritures`) : le contenu exact est présenté avant
+  exécution quand la portée l'exige.

skills-communs/rapport-hebdo/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: rapport-hebdo
+description: >
+  Agrège les pages et documents modifiés de la semaine dans Flowdeck
+  et rédige un rapport structuré de l'équipe. À utiliser quand Bruno
+  demande le rapport hebdomadaire, un bilan de semaine ou l'état
+  d'avancement de l'équipe.
+version: 1.0.0
+apps: [flowdeck]
+domaines: [pro]
+outils:
+  - flowdeck.search_workspace
+  - flowdeck.read_document
+ecritures:
+  - action: flowdeck.create_document
+    approbation: selon-portee
+  - action: flowdeck.write_blocks
+    approbation: selon-portee
+---
+
+## Quand l'utiliser
+
+Quand Bruno demande le rapport de la semaine : ce qui a avancé, ce
+qui bloque, ce qui a été décidé, et le plan de la semaine suivante.
+Ne pas l'utiliser pour une seule réunion (voir
+`compte-rendu-reunion`) ni pour un document unique (voir
+`resume-document`).
+
+## Procédure
+
+1. Repérer les pages et documents modifiés cette semaine
+   (search_workspace).
+2. Lire les plus significatifs (read_document) et en extraire
+   avancées, blocages et décisions.
+3. Créer un document « Rapport hebdo — <date> » (create_document) et
+   y écrire (write_blocks) la structure : Résumé · Faits marquants ·
+   Blocages · Plan de la semaine prochaine.
+
+## Garde-fous
+
+- Chaque affirmation s'appuie sur un document lu, jamais sur une
+  supposition ; une section sans élément le dit explicitement.
+- Domaine professionnel uniquement (domaine déclaré) : ne pas
+  mélanger des contenus famille ou perso au rapport d'équipe.
+- L'écriture suit la politique d'approbation de l'agent (section
+  `ecritures`).

skills-communs/resume-document/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: resume-document
+description: >
+  Résume un document long de Flowdeck en une page : points clés,
+  chiffres marquants, décisions et questions ouvertes. À utiliser
+  quand Bruno demande de résumer, condenser ou synthétiser un
+  document précis.
+version: 1.0.0
+apps: [flowdeck]
+domaines: [pro, famille, perso]
+outils:
+  - flowdeck.search_workspace
+  - flowdeck.read_document
+ecritures:
+  - action: flowdeck.create_document
+    approbation: selon-portee
+  - action: flowdeck.write_blocks
+    approbation: selon-portee
+---
+
+## Quand l'utiliser
+
+Quand Bruno désigne un document — ou demande de le retrouver — et
+veut l'essentiel en une page. Ne pas l'utiliser pour agréger
+plusieurs documents sur une période (voir `rapport-hebdo`) ni pour
+produire un compte rendu décisionnel de réunion (voir
+`compte-rendu-reunion`).
+
+## Procédure
+
+1. Retrouver le document s'il n'est pas fourni (search_workspace),
+   puis le lire intégralement (read_document).
+2. Créer un document « Résumé — <titre> » (create_document).
+3. Y écrire (write_blocks) : 5 points clés, chiffres marquants,
+   décisions/engagements, questions restées ouvertes. Maximum une
+   page, phrases courtes.
+
+## Garde-fous
+
+- Aucune reformulation qui change le sens ; en cas de doute,
+  citer le passage plutôt que l'interpréter.
+- N'agir que dans les domaines déclarés ; un besoin croisé entre
+  domaines est signalé, jamais contourné.
+- L'écriture suit la politique d'approbation de l'agent (section
+  `ecritures`).

static/css/draco-barre.css

@@ -2,7 +2,9 @@
    v0.1.2 : palier mobile resserré selon la spec (voir @media 700px) ;
    v0.1.3 : la marque ✦ (plus grande) ouvre le menu des applications —
    c'est LE changement d'app en mobile (choix de Bruno, 2026-10-21) ;
-   v0.1.4 : palier mobile élargi de 700 à 900 px (zone morte comblée).
+   v0.1.4 : palier mobile élargi de 700 à 900 px (zone morte comblée) ;
+   v0.1.6 : menus « ••• » et compte (construits par le JS, mêmes jetons
+   que le menu des applications) ; l'avatar est un vrai <button>.
    Jetons repris du prototype validé Console v7.2.
    Thème : clair par défaut, sombre via [data-theme="dark"] sur <html>
    ou prefers-color-scheme si l'app intégratrice ne force rien. */
@@ -42,6 +44,29 @@
   box-shadow: 0 16px 44px rgb(0 0 0 / .28);
 }
 .draco-apps-menu[hidden] { display: none; }
+
+/* Menus « ••• » et compte (v0.1.6) — même boîte que le menu des apps,
+ * ancrés à droite ; leurs items réutilisent .draco-apps-item. */
+.draco-more-menu, .draco-compte-menu {
+  position: absolute; top: calc(100% + 6px); right: 10px; z-index: 400;
+  min-width: 248px; padding: 6px;
+  background: var(--surface); border: 1px solid var(--line); border-radius: 14px;
+  box-shadow: 0 16px 44px rgb(0 0 0 / .28);
+}
+.draco-more-menu[hidden], .draco-compte-menu[hidden] { display: none; }
+.draco-menu-item {
+  display: flex; align-items: center; gap: 10px; width: 100%; box-sizing: border-box;
+  padding: 8px 10px; border: 0; border-radius: 10px;
+  background: transparent; color: var(--ink); font: inherit; text-align: left;
+  text-decoration: none; cursor: pointer;
+}
+.draco-menu-item:hover, .draco-menu-item:focus-visible { background: var(--surface-2); }
+.draco-menu-sep { height: 1px; margin: 6px 10px; background: var(--line); }
+.draco-compte-nom {
+  padding: 8px 10px 10px; font-weight: 700; font-size: 14px;
+  border-bottom: 1px solid var(--line); margin-bottom: 6px;
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
 .draco-apps-item {
   display: flex; align-items: center; gap: 10px;
   padding: 8px 10px; border-radius: 10px;
@@ -122,8 +147,10 @@
 }
 .draco-icon-btn:hover { background: var(--surface-2); }
 .draco-avatar {
-  width: 34px; height: 34px; border-radius: 50%; display: grid; place-items: center;
-  background: #2f6fed; color: #fff; font-weight: 700;
+  width: 34px; height: 34px; border: 0; padding: 0; border-radius: 50%;
+  display: grid; place-items: center; flex: none;
+  background: #2f6fed; color: #fff; font: inherit; font-weight: 700;
+  cursor: pointer;
 }
 
 /* Rappel de l'en-tête masqué — onglet ancré au bord supérieur (v6) */

static/css/recherche.css

@@ -0,0 +1,35 @@
+/* Recherche partout (fusion #68) — classes préfixées .rp- pour éviter
+ * toute collision avec les styles de l'hôte. Couleurs neutres héritées
+ * autant que possible : la page reste lisible en thème clair et sombre. */
+.rp-page { max-width: 880px; margin: 0 auto; padding: 24px 16px 64px; }
+.rp-page h1 { font-size: 1.4rem; margin: 0 0 4px; }
+.rp-hint { opacity: .7; margin: 0 0 16px; font-size: .9rem; }
+.rp-form { display: flex; gap: 8px; margin-bottom: 24px; }
+.rp-input {
+  flex: 1; font: inherit; font-size: 1.05rem; padding: 10px 12px;
+  border: 1px solid #888; border-radius: 8px; background: inherit; color: inherit;
+}
+.rp-input:focus { outline: 2px solid #3b82f6; outline-offset: 1px; }
+.rp-section { margin-bottom: 28px; }
+.rp-head {
+  display: flex; align-items: baseline; gap: 10px;
+  border-bottom: 1px solid #888; padding-bottom: 6px; margin-bottom: 8px;
+}
+.rp-head h2 { font-size: 1.05rem; margin: 0; }
+.rp-count {
+  font-size: .8rem; font-weight: 700; background: #3b82f6; color: #fff;
+  border-radius: 999px; padding: 1px 8px; min-width: 1.2em; text-align: center;
+}
+.rp-count:empty { display: none; }
+.rp-all { margin-left: auto; font-size: .85rem; white-space: nowrap; }
+.rp-state { opacity: .75; margin: 8px 0; }
+.rp-error { opacity: 1; }
+.rp-item {
+  display: block; padding: 8px 10px; border-radius: 8px;
+  text-decoration: none; color: inherit;
+}
+.rp-item:hover, .rp-item:focus { background: rgba(127, 127, 127, .15); outline: none; }
+.rp-item:focus-visible { outline: 2px solid #3b82f6; }
+.rp-title { display: block; font-weight: 600; }
+.rp-context { display: block; font-size: .8rem; opacity: .65; }
+.rp-snippet { display: block; font-size: .88rem; opacity: .85; margin-top: 2px; }

static/js/draco-panneau.js

@@ -46,6 +46,7 @@
   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"; }
@@ -274,6 +275,7 @@
       '  <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");
@@ -282,6 +284,7 @@
     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);
@@ -336,6 +339,35 @@
     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" })
@@ -812,6 +844,7 @@
     root.classList.add("open");
     appliquerTheme();
     verifierIdentite();
+    chargerVersion();
     setTimeout(function () { inputEl.focus(); }, 300);
   }
   function fermer() { if (root) root.classList.remove("open"); }

static/js/recherche.js

@@ -0,0 +1,514 @@
+/* Recherche partout — page de résultats unifiée (fusion-trois-apps #68).
+ *
+ * Vanilla, sans dépendance. Un seul fichier vendangé tel quel par chaque
+ * hôte (ObsiGate, Flowdeck, TikTak, Kanbante) : la configuration vient
+ * des attributs data-* de #recherche, rendus côté serveur par l'hôte.
+ *
+ * Contrat d'API (audité, rien d'inventé) :
+ * - ObsiGate : GET {base}/api/search?q=&vault=all&limit=8
+ *   -> { results: [{ vault, path, title, snippet }] }
+ *   Lien profond vérifié : {base}#file={vault}:{path} (Viewer.openFile).
+ * - Flowdeck : GET {base}/api/search?q=
+ *   -> { pages: [{ title, excerpt, subtitle, url: "/pages/<id>" }],
+ *        collections: [{ title, subtitle, url: "/db/<id>" }] }
+ * - TikTak : GET {base}/api/search?q=
+ *   -> { tasks: [{ id, title, description, status, due_at }], ... }
+ *   Lien profond vérifié : {base}search?q=<q>&task=<id> (page /search).
+ * - Kanbante : GET {base}/api/search?q= (NOUVEAU, cette livraison)
+ *   -> { groups: [{ full_name, rows: [{ issue, column }] }] }
+ *   Lien profond : {base}board/<full_name> (la carte n'a pas d'URL propre
+ *   adressable — même limite que la page /search native de Kanbante).
+ *
+ * Résolution des bases sœurs (même ordre que la barre v0.1.6) :
+ *   1. data-base-* rendus par l'hôte (son propre résolveur : explicite >
+ *      hôte de la requête > dérivation > défaut officiel) ;
+ *   2. window.DRACO_BAR.urls (valeur déjà résolue par la barre) ;
+ *   3. dérivation -dev si l'hôte courant est un hôte -dev dracodev.net ;
+ *   4. href des onglets .draco-apptab rendus ;
+ *   5. défauts officiels prod. Aucune URL inventée (pas de spark-dev).
+ *
+ * Authentification cross-origin : les appels sœurs partent avec
+ * credentials:"include". Le navigateur envoie alors les cookies de
+ * chaque origine, dont le cookie SSO partagé draco_session
+ * (Domain=.dracodev.net), accepté par les 4 API de recherche
+ * (ObsiGate et TikTak nativement, Flowdeck et Kanbante via cette
+ * livraison). Chaque sœur n'autorise en CORS que les origines sœurs
+ * (GET sur l'endpoint de recherche uniquement, pas de "*").
+ * Une sœur injoignable / non autorisée ne casse pas les autres :
+ * sa section affiche l'erreur + un lien vers sa recherche native.
+ */
+(function (global) {
+  "use strict";
+  /* globalThis : le fichier est chargé comme script classique dans les
+   * navigateurs, requis en CJS par les tests TikTak/Kanbante/Flowdeck,
+   * et importé en ESM par le test ObsiGate (frontend/js est "type":
+   * "module") — où `this` de niveau supérieur vaut undefined. */
+
+  var PROD = {
+    obsigate: "https://og.dracodev.net/",
+    flowdeck: "https://flowdeck.dracodev.net/",
+    tiktak: "https://tiktak.dracodev.net/",
+    kanbante: "https://kanbante.dracodev.net/",
+  };
+  var DEV = {
+    obsigate: "https://og-dev.dracodev.net/",
+    flowdeck: "https://flowdeck-dev.dracodev.net/",
+    tiktak: "https://tiktak-dev.dracodev.net/",
+    kanbante: "https://kanbante-dev.dracodev.net/",
+  };
+  var APPS = [
+    { key: "obsigate", label: "ObsiGate" },
+    { key: "flowdeck", label: "Flowdeck" },
+    { key: "tiktak", label: "TikTak" },
+    { key: "kanbante", label: "Kanbante" },
+  ];
+  var COLUMN_LABELS = {
+    backlog: "Backlog",
+    in_progress: "En cours",
+    qa: "QA",
+    review: "Relecture",
+    todo: "À faire",
+    done: "Terminé",
+  };
+  var TIMEOUT_MS = 8000;
+  var DEBOUNCE_MS = 250;
+  var PER_APP_LIMIT = 8;
+
+  function esc(s) {
+    return String(s == null ? "" : s)
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;");
+  }
+
+  function cleanUrl(u) {
+    if (!u) return null;
+    u = String(u).trim();
+    if (!u || u.indexOf("{{") !== -1) return null;
+    return u;
+  }
+
+  function withSlash(u) {
+    return u.charAt(u.length - 1) === "/" ? u : u + "/";
+  }
+
+  /* Même règle que la barre v0.1.6 : première étiquette en -dev ET
+   * domaine dracodev.net, sinon rien (un hôte piège ne déclenche rien). */
+  function isDevHost(hostname) {
+    if (!hostname) return false;
+    var h = String(hostname).toLowerCase();
+    if (h.slice(-13) !== ".dracodev.net") return false;
+    var first = h.split(".")[0];
+    return first.length > 4 && first.slice(-4) === "-dev";
+  }
+
+  /* opts : { host, explicit:{}, barUrls:{}, tabHrefs:{} } */
+  function resolveBases(opts) {
+    opts = opts || {};
+    var dev = isDevHost(opts.host);
+    var out = {};
+    APPS.forEach(function (app) {
+      var key = app.key;
+      var u = cleanUrl(opts.explicit && opts.explicit[key]);
+      if (!u) u = cleanUrl(opts.barUrls && opts.barUrls[key]);
+      if (!u && dev) u = DEV[key];
+      if (!u) u = cleanUrl(opts.tabHrefs && opts.tabHrefs[key]);
+      if (!u) u = PROD[key];
+      out[key] = withSlash(u);
+    });
+    return out;
+  }
+
+  function searchPath(app, q) {
+    if (app === "obsigate") {
+      return "api/search?q=" + encodeURIComponent(q) + "&vault=all&limit=" + PER_APP_LIMIT;
+    }
+    return "api/search?q=" + encodeURIComponent(q);
+  }
+
+  function snippetOf(s, n) {
+    s = String(s == null ? "" : s).replace(/\s+/g, " ").trim();
+    return s.length > (n || 160) ? s.slice(0, n || 160) + "…" : s;
+  }
+
+  /* Normalise la réponse d'une app en [{ title, snippet, context, url }].
+   * base : base résolue de l'app (avec / final). q : requête (liens TikTak). */
+  function normalize(app, data, base, q) {
+    data = data || {};
+    if (app === "obsigate") {
+      return (data.results || []).slice(0, PER_APP_LIMIT).map(function (r) {
+        return {
+          title: r.title || r.path || "Sans titre",
+          snippet: snippetOf(r.snippet || ""),
+          context: (r.vault || "") + (r.path ? " · " + r.path : ""),
+          url:
+            base +
+            "#file=" +
+            encodeURIComponent(r.vault || "") +
+            ":" +
+            encodeURIComponent(r.path || ""),
+        };
+      });
+    }
+    if (app === "flowdeck") {
+      var items = (data.pages || []).concat(data.collections || []);
+      return items.slice(0, PER_APP_LIMIT).map(function (r) {
+        var rel = String(r.url || "").replace(/^\//, "");
+        return {
+          title: r.title || "Sans titre",
+          snippet: snippetOf(r.excerpt || ""),
+          context: r.subtitle || (r.type === "collection" ? "Base" : "Page"),
+          url: base + rel,
+        };
+      });
+    }
+    if (app === "tiktak") {
+      return (data.tasks || []).slice(0, PER_APP_LIMIT).map(function (t) {
+        var ctx = t.status === "done" ? "Terminée" : "Active";
+        if (t.due_at) ctx += " · échéance " + String(t.due_at).slice(0, 10);
+        return {
+          title: t.title || "Sans titre",
+          snippet: snippetOf(t.description || ""),
+          context: "Tâche · " + ctx,
+          url: base + "search?q=" + encodeURIComponent(q || "") + "&task=" + t.id,
+        };
+      });
+    }
+    if (app === "kanbante") {
+      var rows = [];
+      (data.groups || []).forEach(function (g) {
+        (g.rows || []).forEach(function (row) {
+          rows.push({ group: g.full_name, row: row });
+        });
+      });
+      return rows.slice(0, PER_APP_LIMIT).map(function (x) {
+        var issue = x.row.issue || {};
+        var col = COLUMN_LABELS[x.row.column] || x.row.column || "";
+        return {
+          title: "#" + issue.number + " " + (issue.title || "Sans titre"),
+          snippet: snippetOf(issue.body || ""),
+          context: x.group + (col ? " · " + col : ""),
+          url: base + "board/" + x.group,
+        };
+      });
+    }
+    return [];
+  }
+
+  /* Recherche native de l'app (repli quand la section est en erreur). */
+  function nativeSearchUrl(app, base, q) {
+    if (app === "tiktak" || app === "kanbante") {
+      return base + "search?q=" + encodeURIComponent(q || "");
+    }
+    /* ObsiGate et Flowdeck n'ont pas de page de recherche adressable :
+     * leur recherche native vit dans la palette (Ctrl+K) de l'app. */
+    return base;
+  }
+
+  function nativeSearchLabel(app) {
+    if (app === "tiktak" || app === "kanbante") {
+      return "Ouvrir la recherche dans " + appLabel(app);
+    }
+    return "Ouvrir " + appLabel(app) + " (recherche via la palette Ctrl+K)";
+  }
+
+  function appLabel(key) {
+    for (var i = 0; i < APPS.length; i++) {
+      if (APPS[i].key === key) return APPS[i].label;
+    }
+    return key;
+  }
+
+  var api = {
+    esc: esc,
+    isDevHost: isDevHost,
+    resolveBases: resolveBases,
+    searchPath: searchPath,
+    normalize: normalize,
+    nativeSearchUrl: nativeSearchUrl,
+    PROD: PROD,
+    DEV: DEV,
+  };
+  if (typeof module !== "undefined" && module.exports) module.exports = api;
+  global.RecherchePartout = api;
+
+  /* ---- Partie DOM : ne s'exécute que dans un navigateur. ---- */
+  if (typeof document === "undefined") return;
+
+  function fetchSection(app, url, onDone) {
+    var ctrl = null;
+    var timer = null;
+    try {
+      ctrl = new AbortController();
+      timer = setTimeout(function () {
+        ctrl.abort();
+      }, TIMEOUT_MS);
+    } catch (e) {
+      ctrl = null;
+    }
+    var opts = { headers: { Accept: "application/json" }, credentials: "include" };
+    if (ctrl) opts.signal = ctrl.signal;
+    fetch(url, opts)
+      .then(function (resp) {
+        if (!resp.ok) {
+          var err = new Error("HTTP " + resp.status);
+          err.status = resp.status;
+          throw err;
+        }
+        return resp.json();
+      })
+      .then(function (data) {
+        if (timer) clearTimeout(timer);
+        onDone(null, data);
+      })
+      .catch(function (err) {
+        if (timer) clearTimeout(timer);
+        onDone(err, null);
+      });
+  }
+
+  function renderSection(section, state) {
+    /* state : { status: "loading"|"empty"|"error"|"ok", items, message, q, base, app } */
+    var body = section.querySelector(".rp-body");
+    var count = section.querySelector(".rp-count");
+    var toutVoir = section.querySelector(".rp-all");
+    toutVoir.href = nativeSearchUrl(state.app, state.base, state.q);
+    toutVoir.textContent = "Tout voir";
+    toutVoir.title = nativeSearchLabel(state.app);
+    if (state.status === "loading") {
+      count.textContent = "";
+      body.innerHTML = '<p class="rp-state">Recherche…</p>';
+      return;
+    }
+    if (state.status === "error") {
+      count.textContent = "";
+      body.innerHTML =
+        '<p class="rp-state rp-error">' +
+        esc(state.message) +
+        ' — <a href="' +
+        esc(nativeSearchUrl(state.app, state.base, state.q)) +
+        '">' +
+        esc(nativeSearchLabel(state.app)) +
+        "</a></p>";
+      return;
+    }
+    if (state.status === "empty") {
+      count.textContent = "";
+      body.innerHTML =
+        '<p class="rp-state">Aucun résultat pour « ' + esc(state.q) + " ».</p>";
+      return;
+    }
+    count.textContent = String(state.items.length);
+    body.innerHTML = state.items
+      .map(function (item) {
+        return (
+          '<a class="rp-item" data-rp-link href="' +
+          esc(item.url) +
+          '">' +
+          '<span class="rp-title">' +
+          esc(item.title) +
+          "</span>" +
+          (item.context
+            ? '<span class="rp-context">' + esc(item.context) + "</span>"
+            : "") +
+          (item.snippet
+            ? '<span class="rp-snippet">' + esc(item.snippet) + "</span>"
+            : "") +
+          "</a>"
+        );
+      })
+      .join("");
+  }
+
+  function init() {
+    var root = document.getElementById("recherche");
+    if (!root) return;
+    var input = document.getElementById("rp-q");
+    if (!input) return;
+    var hostApp = root.getAttribute("data-host") || "";
+    var explicit = {};
+    APPS.forEach(function (app) {
+      var v = root.getAttribute("data-base-" + app.key);
+      if (v) explicit[app.key] = v;
+    });
+    var barUrls = {};
+    try {
+      if (global.DRACO_BAR && global.DRACO_BAR.urls) barUrls = global.DRACO_BAR.urls;
+    } catch (e) {}
+    var tabHrefs = {};
+    try {
+      document.querySelectorAll(".draco-apptab[data-app]").forEach(function (tab) {
+        var href = tab.getAttribute("href");
+        if (href) tabHrefs[tab.getAttribute("data-app")] = href;
+      });
+    } catch (e) {}
+    var bases = resolveBases({
+      host: global.location.hostname,
+      explicit: explicit,
+      barUrls: barUrls,
+      tabHrefs: tabHrefs,
+    });
+    var sections = {};
+    APPS.forEach(function (app) {
+      var el = document.querySelector('[data-rp-section="' + app.key + '"]');
+      if (el) sections[app.key] = el;
+    });
+
+    var currentQ = "";
+    var runId = 0;
+    var debounceTimer = null;
+
+    function runSearch(q) {
+      currentQ = q;
+      var myRun = ++runId;
+      if (!q) {
+        APPS.forEach(function (app) {
+          var sec = sections[app.key];
+          if (!sec) return;
+          sec.querySelector(".rp-body").innerHTML =
+            '<p class="rp-state">Tapez une recherche ci-dessus.</p>';
+          sec.querySelector(".rp-count").textContent = "";
+          sec.querySelector(".rp-all").href = nativeSearchUrl(app.key, bases[app.key], "");
+        });
+        return;
+      }
+      APPS.forEach(function (app) {
+        var sec = sections[app.key];
+        if (!sec) return;
+        renderSection(sec, { status: "loading", app: app.key, base: bases[app.key], q: q });
+        var url;
+        if (app.key === hostApp) {
+          /* Même origine : pas de CORS, pas de CSP cross-origin. */
+          url = "/" + searchPath(app.key, q);
+        } else {
+          url = bases[app.key] + searchPath(app.key, q);
+        }
+        fetchSection(app.key, url, function (err, data) {
+          if (myRun !== runId) return;
+          if (err) {
+            var msg;
+            if (err.name === "AbortError") msg = "Délai dépassé (8 s)";
+            else if (err.status === 401 || err.status === 403)
+              msg = "Connexion requise sur " + app.label;
+            else if (err.status) msg = "Indisponible (HTTP " + err.status + ")";
+            else msg = "Injoignable depuis cet hôte (CORS ou réseau)";
+            renderSection(sec, {
+              status: "error",
+              message: msg,
+              app: app.key,
+              base: bases[app.key],
+              q: q,
+            });
+            return;
+          }
+          var items = normalize(app.key, data, bases[app.key], q);
+          renderSection(sec, {
+            status: items.length ? "ok" : "empty",
+            items: items,
+            app: app.key,
+            base: bases[app.key],
+            q: q,
+          });
+        });
+      });
+    }
+
+    function scheduleSearch(q, immediate) {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      if (immediate) {
+        runSearch(q);
+        return;
+      }
+      debounceTimer = setTimeout(function () {
+        runSearch(q);
+      }, DEBOUNCE_MS);
+    }
+
+    function syncUrl(q) {
+      try {
+        var url = new URL(global.location.href);
+        if (q) url.searchParams.set("q", q);
+        else url.searchParams.delete("q");
+        global.history.replaceState(null, "", url.toString());
+      } catch (e) {}
+    }
+
+    input.addEventListener("input", function () {
+      var q = input.value.trim();
+      syncUrl(q);
+      scheduleSearch(q, false);
+    });
+    input.addEventListener("keydown", function (e) {
+      if (e.key === "Enter") {
+        var first = document.querySelector("[data-rp-link]");
+        if (first) {
+          e.preventDefault();
+          first.click();
+        }
+      } else if (e.key === "Escape") {
+        input.value = "";
+        syncUrl("");
+        scheduleSearch("", true);
+        input.focus();
+      } else if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+        moveFocus(e.key === "ArrowDown" ? 1 : -1, e);
+      }
+    });
+    document.addEventListener(
+      "keydown",
+      function (e) {
+        var target = e.target;
+        var typing =
+          target &&
+          (target.tagName === "INPUT" ||
+            target.tagName === "TEXTAREA" ||
+            target.isContentEditable);
+        if ((e.key === "/" && !typing) || ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "k")) {
+          e.preventDefault();
+          e.stopPropagation();
+          input.focus();
+          input.select();
+          return;
+        }
+        if (!typing && (e.key === "ArrowDown" || e.key === "ArrowUp")) {
+          moveFocus(e.key === "ArrowDown" ? 1 : -1, e);
+        }
+      },
+      true
+    );
+
+    function moveFocus(delta, e) {
+      var links = Array.prototype.slice.call(document.querySelectorAll("[data-rp-link]"));
+      if (!links.length) return;
+      var active = document.activeElement;
+      var idx = links.indexOf(active);
+      var next;
+      if (idx === -1) next = delta > 0 ? 0 : links.length - 1;
+      else next = (idx + delta + links.length) % links.length;
+      e.preventDefault();
+      links[next].focus();
+    }
+
+    var params = new URLSearchParams(global.location.search);
+    var initialQ = (params.get("q") || "").trim();
+    if (initialQ) {
+      input.value = initialQ;
+      runSearch(initialQ);
+    } else {
+      runSearch("");
+    }
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})(
+  typeof window !== "undefined"
+    ? window
+    : typeof globalThis !== "undefined"
+      ? globalThis
+      : this
+);

static/js/vendor/draco-barre.js

@@ -1,5 +1,10 @@
 /* Barre d'apps commune dracodev — comportement (v0.1.0, ACC-0.2 ;
- * v0.1.3 : menu des applications ouvert par la marque ✦).
+ * v0.1.3 : menu des applications ouvert par la marque ✦ ;
+ * v0.1.5 : noms publics par configuration — aucun nom public d'un
+ * environnement particulier n'est codé en dur, voir « URL » ci-dessous ;
+ * v0.1.6 (prochaine publication — VERSION non bumpée dans cette PR,
+ * la publication est séparée) : dérivation -dev par l'hôte courant,
+ * menu « ••• » par défaut et menu compte fonctionnels, voir ci-dessous).
  *
  * Aucun gestionnaire inline : un seul écouteur délégué sur le document
  * (patron validé par le prototype — les onclick du HTML généré sont
@@ -10,19 +15,158 @@
  *     current: "tiktak",                      // app courante
  *     domain: "pro",                          // domaine actif
  *     counts: { tiktak: 3, kanbante: 3, alertes: 3, spark: 0 },
+ *     user: "Bruno",                          // nom affiché (v0.1.6) ;
+ *       // ou { display_name: "Bruno", username: "bruno" }
+ *     urls: {                                 // bases des applications
+ *       obsigate: "https://og.dracodev.net/",
+ *       flowdeck: "https://flowdeck.dracodev.net/",
+ *       tiktak:   "https://tiktak.dracodev.net/",
+ *       kanbante: "https://kanbante.dracodev.net/",
+ *       agent:    "https://agent.dracodev.net/",
+ *       spark:    "https://spark.dracodev.net/"
+ *     },
  *     onAction: function (act, el) { … }      // l'app relaie les actions
  *   }                                          // qu'elle ne connaît pas
+ *
+ * URL des applications (contrat dev/prod, v0.1.5 puis v0.1.6) —
+ * résolution, dans l'ordre STRICT, pour chaque app :
+ *   1. DRACO_BAR_CONFIG.urls.<app>, injectée par l'app hôte (rendu
+ *      serveur ou client) depuis SA configuration d'environnement —
+ *      explicite, donc prioritaire, même sur un hôte -dev ;
+ *   2. (v0.1.6) SI l'hôte courant est un hôte -dev dracodev.net
+ *      (première étiquette se terminant par -dev : tiktak-dev,
+ *      kanbante-dev, og-dev, flowdeck-dev, agent-dev…), l'URL sœur
+ *      dérivée avec -dev (voir DEV_URLS). C'est le correctif du bug
+ *      constaté sur tiktak-dev / kanbante-dev, où les liens suivaient
+ *      les noms SANS -dev faute de configuration explicite ;
+ *   3. le href déjà rendu dans le fragment HTML, c.-à-d. le jeton
+ *      {{URL_<APP>}} remplacé côté serveur par l'app hôte ;
+ *   4. le défaut officiel ci-dessous (production, noms SANS suffixe).
+ * Un jeton {{URL_…}} non remplacé n'est jamais une URL : il est ignoré
+ * partout (config injectée comme href rendu) et ne peut pas être exposé.
+ * Cas spark (v0.1.6) : AUCUNE dérivation inventée — aucun hôte
+ * spark-dev connu ; sur un hôte -dev, spark retombe sur l'étape 3
+ * (href rendu) puis 4 (défaut prod), sauf config explicite (étape 1).
+ * Les clés agent et spark ne correspondent à aucun onglet de la barre :
+ * elles sont résolues et exposées via DRACO_BAR.urls pour le panneau
+ * Spark (panneau-agent), qui suit le même contrat d'injection.
  * Actions émises (data-act) : rail, palette, domaine (data-dom),
- * alertes, spark, menu, rappel-entete. L'app intégratrice décide de
- * chacune (ouvrir la palette, le panneau Spark, changer de domaine…).
- * Action INTERNE (jamais relayée) : apps — la marque ✦ ouvre le menu
- * des applications, construit depuis les onglets ; c'est le moyen de
- * changer d'app en mobile, où les onglets sont repliés (v0.1.2).
+ * alertes, spark, rappel-entete. L'app intégratrice décide de chacune
+ * (ouvrir la palette, le panneau Spark, changer de domaine…).
+ * Actions INTERNES (jamais relayées comme avant) : apps — la marque ✦
+ * ouvre le menu des applications, construit depuis les onglets ;
+ * c'est le moyen de changer d'app en mobile, où les onglets sont
+ * repliés (v0.1.2). Menu « ••• » et compte : voir ci-dessous.
+ *
+ * Menu « ••• » (v0.1.6) — audit des hôtes : ObsiGate est le seul hôte
+ * connu à gérer l'action "menu" via onAction (il déclenche son propre
+ * bouton d'en-tête #header-menu-btn) ; les autres hôtes ne la gèrent
+ * pas et le bouton restait mort (relais vers un onAction absent, puis
+ * événement draco:bar sans écouteur). Comportement désormais :
+ *   - sans onAction : un menu par défaut FONCTIONNEL s'ouvre — accès à
+ *     la console agent (URL agent résolue, donc dérivée -dev sur un
+ *     hôte -dev) et aux quatre applications (URL résolues) ; fermeture
+ *     par clic extérieur, Échap ou choix d'un lien ;
+ *   - avec onAction : l'hôte garde la main (comportement historique,
+ *     zéro régression pour ObsiGate) ; il peut demander explicitement
+ *     le menu par défaut en retournant false pour l'action "menu".
+ * Menu compte (v0.1.6) — l'avatar, auparavant un <span> mort affichant
+ * un « B » codé en dur dans le fragment, est un vrai <button>
+ * (data-act="compte"). Son initiale vient de cfg.user ou, à défaut, de
+ * la première lettre du title {{UTILISATEUR}} remplacé ; sans nom connu,
+ * le neutre ✦ est conservé (jamais de lettre codée en dur). Le clic
+ * ouvre un petit menu affichant le nom de l'utilisateur ; les items
+ * Profil / Déconnexion sont relayés à l'hôte via onAction ou, à défaut,
+ * via l'événement draco:bar (détail { act: "profil" | "deconnexion" }),
+ * mais le menu affiche l'identité même sans gestionnaire hôte.
+ * Accessibilité : vrais <button>, aria-haspopup / aria-expanded,
+ * role="menu" / "menuitem", fermeture par Échap et clic extérieur.
  */
 (function () {
   "use strict";
   var cfg = window.DRACO_BAR_CONFIG || {};
 
+  /* Défauts OFFICIELS (production) — les seuls noms publics présents
+   * dans ce fichier, documentés comme défauts (contrat dev/prod). */
+  var DEFAULT_URLS = {
+    obsigate: "https://og.dracodev.net/",
+    flowdeck: "https://flowdeck.dracodev.net/",
+    tiktak: "https://tiktak.dracodev.net/",
+    kanbante: "https://kanbante.dracodev.net/",
+    agent: "https://agent.dracodev.net/",
+    spark: "https://spark.dracodev.net/"
+  };
+
+  /* Dérivation -dev (v0.1.6) — appliquée UNIQUEMENT quand l'hôte courant
+   * est lui-même un hôte -dev dracodev.net (voir isDevHost). spark est
+   * volontairement absent : aucun hôte spark-dev connu, aucune URL
+   * inventée ; spark retombe sur href rendu puis défaut prod. */
+  var DEV_URLS = {
+    obsigate: "https://og-dev.dracodev.net/",
+    flowdeck: "https://flowdeck-dev.dracodev.net/",
+    tiktak: "https://tiktak-dev.dracodev.net/",
+    kanbante: "https://kanbante-dev.dracodev.net/",
+    agent: "https://agent-dev.dracodev.net/"
+  };
+
+  var APP_LABELS = {
+    obsigate: "ObsiGate", flowdeck: "Flowdeck",
+    tiktak: "TikTak", kanbante: "Kanbante"
+  };
+
+  /* Vrai si hostname est un hôte -dev dracodev.net : première étiquette
+   * se terminant par -dev ET domaine dracodev.net (un suffixe -dev sur
+   * un autre domaine, ou un hôte piège du type x-dev.dracodev.net.evil,
+   * ne déclenche rien). Insensible à la casse. */
+  function isDevHost(hostname) {
+    if (!hostname) return false;
+    var h = String(hostname).toLowerCase();
+    if (h.slice(-13) !== ".dracodev.net") return false;
+    var first = h.split(".")[0];
+    return first.length > 4 && first.slice(-4) === "-dev";
+  }
+
+  /* Un jeton {{…}} non remplacé n'est pas une URL : l'ignorer. */
+  function cleanUrl(u) {
+    if (!u || typeof u !== "string") return null;
+    if (u.indexOf("{{") !== -1) return null;
+    if (!u.replace(/\s/g, "")) return null;
+    return u;
+  }
+
+  function withSlash(u) {
+    return u.charAt(u.length - 1) !== "/" ? u + "/" : u;
+  }
+
+  function resolveUrls() {
+    var host = "";
+    try { host = (window.location && window.location.hostname) || ""; } catch (e) { host = ""; }
+    var dev = isDevHost(host);
+    var urls = {};
+    Object.keys(DEFAULT_URLS).forEach(function (app) {
+      /* 1. Config explicite de l'hôte — prioritaire, même sur -dev. */
+      var u = cleanUrl(cfg.urls && cfg.urls[app]);
+      /* 2. Dérivation -dev par l'hôte courant (spark : pas de dérivée). */
+      if (!u && dev) u = DEV_URLS[app] || null;
+      /* 3. href rendu dans le fragment (jeton remplacé côté serveur). */
+      if (!u) {
+        var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
+        var href = tab ? tab.getAttribute("href") : null;
+        u = cleanUrl(href);
+      }
+      /* 4. Défaut officiel (production). */
+      if (!u) u = DEFAULT_URLS[app];
+      urls[app] = withSlash(u);
+    });
+    return urls;
+  }
+  function applyUrls(urls) {
+    document.querySelectorAll(".draco-apptab, .draco-apps-item").forEach(function (t) {
+      if (t.dataset.app && urls[t.dataset.app]) t.setAttribute("href", urls[t.dataset.app]);
+    });
+  }
+  var resolvedUrls = resolveUrls();
+
   function setCounts(counts) {
     Object.keys(counts || {}).forEach(function (k) {
       /* Toutes les occurrences : l'onglet ET sa ligne dans le menu. */
@@ -43,26 +187,122 @@
     });
   }
 
-  /* ── Menu des applications (v0.1.3) ──────────────────────────────
-   * Construit depuis les onglets présents dans la barre : mêmes
-   * liens, mêmes icônes, mêmes badges. Ouvert par la marque ✦
-   * (data-act="apps"), fermé par un clic extérieur, Échap, ou le
-   * choix d'une application (la navigation suit son cours). */
+  /* ── Identité / avatar (v0.1.6) ───────────────────────────────────
+   * Nom : cfg.user (chaîne, ou objet display_name / name / username),
+   * sinon le title de l'avatar quand le jeton {{UTILISATEUR}} a bien été
+   * remplacé côté serveur. L'initiale en découle ; sans nom, le neutre
+   * ✦ du fragment est conservé — jamais de lettre codée en dur. */
+  function userName() {
+    var u = cfg.user;
+    if (typeof u === "string" && u.replace(/\s/g, "")) return u.trim();
+    if (u && typeof u === "object") {
+      var n = u.display_name || u.name || u.username;
+      if (n && String(n).replace(/\s/g, "")) return String(n).trim();
+    }
+    return null;
+  }
+  function titleName() {
+    var av = document.querySelector(".draco-avatar");
+    var t = av ? av.getAttribute("title") : null;
+    if (t && t.indexOf("{{") === -1 && t.replace(/\s/g, "")) return t.trim();
+    return null;
+  }
+  function displayName() { return userName() || titleName(); }
+  function syncAvatar() {
+    var av = document.querySelector(".draco-avatar");
+    if (!av) return;
+    /* Compatibilité avec un fragment vendangé antérieur (avatar <span>
+     * sans data-act) : le rendre déclencheur du menu compte. */
+    if (!av.getAttribute("data-act")) av.setAttribute("data-act", "compte");
+    if (!av.getAttribute("aria-haspopup")) av.setAttribute("aria-haspopup", "menu");
+    var name = displayName();
+    if (name) {
+      av.textContent = name.charAt(0).toUpperCase();
+      av.setAttribute("title", name);
+      av.setAttribute("aria-label", "Compte : " + name);
+    }
+  }
+
+  /* ── Menus déroulants (apps, •••, compte) ──────────────────────────
+   * Un seul menu ouvert à la fois ; fermeture par clic extérieur,
+   * Échap, ou choix d'un item. aria-expanded tenu à jour sur chaque
+   * déclencheur. Les href des menus sont (re)synchronisés avec
+   * resolvedUrls à chaque ouverture, pour que setUrls et la dérivation
+   * -dev s'y reflètent même si le menu a été construit avant. */
   var bar = document.querySelector(".draco-bar");
   var brand = bar ? bar.querySelector(".draco-brand") : null;
-  var menu = null;
+  var moreBtn = bar ? bar.querySelector('[data-act="menu"]') : null;
+  var avatarBtn = document.querySelector(".draco-avatar");
+  var appsMenu = null, moreMenu = null, compteMenu = null;
 
-  function buildMenu() {
-    if (!bar || !brand || menu) return;
-    menu = document.createElement("div");
-    menu.className = "draco-apps-menu";
-    menu.hidden = true;
-    menu.setAttribute("role", "menu");
-    menu.setAttribute("aria-label", "Applications");
+  function setExpanded(btn, open) {
+    if (btn) btn.setAttribute("aria-expanded", open ? "true" : "false");
+  }
+  function refreshMenuHrefs(menu) {
+    if (!menu) return;
+    menu.querySelectorAll(".draco-apps-item").forEach(function (a) {
+      if (a.dataset.app && resolvedUrls[a.dataset.app]) a.setAttribute("href", resolvedUrls[a.dataset.app]);
+    });
+  }
+  function togglePopup(menu, btn, force) {
+    if (!menu) return;
+    var open = typeof force === "boolean" ? force : menu.hidden;
+    menu.hidden = !open;
+    setExpanded(btn, open);
+  }
+  function closeAllPopups() {
+    if (appsMenu) togglePopup(appsMenu, brand, false);
+    if (moreMenu) togglePopup(moreMenu, moreBtn, false);
+    if (compteMenu) togglePopup(compteMenu, avatarBtn, false);
+  }
+  function tabLabel(app) {
+    var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
+    var fort = tab ? tab.querySelector(".draco-apptab-txt strong") : null;
+    return fort ? fort.textContent : (APP_LABELS[app] || app);
+  }
+  function tabRole(app) {
+    var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
+    var petit = tab ? tab.querySelector(".draco-apptab-txt small") : null;
+    return petit ? petit.textContent : "";
+  }
+  function menuLink(app, nom, role) {
+    var a = document.createElement("a");
+    a.className = "draco-apps-item draco-menu-item";
+    a.href = resolvedUrls[app] || "#";
+    a.dataset.app = app;
+    a.setAttribute("role", "menuitem");
+    var txt = document.createElement("span");
+    txt.className = "draco-apps-item-txt";
+    var n = document.createElement("span");
+    n.className = "draco-apps-item-nom";
+    n.textContent = nom;
+    txt.appendChild(n);
+    if (role) {
+      var r = document.createElement("span");
+      r.className = "draco-apps-item-role";
+      r.textContent = role;
+      txt.appendChild(r);
+    }
+    a.appendChild(txt);
+    return a;
+  }
+
+  /* Menu des applications (v0.1.3) — construit depuis les onglets
+   * présents dans la barre : mêmes liens, mêmes icônes, mêmes badges.
+   * Ouvert par la marque ✦ (data-act="apps"), fermé par un clic
+   * extérieur, Échap, ou le choix d'une application (la navigation
+   * suit son cours). */
+  function buildAppsMenu() {
+    if (!bar || !brand || appsMenu) return;
+    appsMenu = document.createElement("div");
+    appsMenu.className = "draco-apps-menu";
+    appsMenu.hidden = true;
+    appsMenu.setAttribute("role", "menu");
+    appsMenu.setAttribute("aria-label", "Applications");
     document.querySelectorAll(".draco-apptab").forEach(function (t) {
       var a = document.createElement("a");
       a.className = "draco-apps-item";
-      a.href = t.getAttribute("href");
+      a.href = resolvedUrls[t.dataset.app] || t.getAttribute("href");
       a.dataset.app = t.dataset.app;
       a.setAttribute("role", "menuitem");
       var ico = t.querySelector(".draco-apptab-ico");
@@ -84,44 +324,167 @@
       a.appendChild(txt);
       var badge = t.querySelector(".draco-badge");
       if (badge) a.appendChild(badge.cloneNode(true));
-      menu.appendChild(a);
+      appsMenu.appendChild(a);
     });
-    bar.appendChild(menu);
+    bar.appendChild(appsMenu);
+  }
+  function toggleAppsMenu(force) {
+    buildAppsMenu();
+    if (!appsMenu) return;
+    if (force !== false) refreshMenuHrefs(appsMenu);
+    togglePopup(appsMenu, brand, force);
   }
 
-  function toggleMenu(force) {
-    buildMenu();
-    if (!menu) return;
-    var open = typeof force === "boolean" ? force : menu.hidden;
-    menu.hidden = !open;
-    if (brand) brand.setAttribute("aria-expanded", open ? "true" : "false");
+  /* Menu « ••• » par défaut (v0.1.6) — console agent + applications.
+   * Construit depuis les URL résolues (donc dérivées -dev sur un hôte
+   * -dev) ; l'hôte qui gère "menu" via onAction garde la main (voir
+   * l'en-tête) et ne voit jamais ce menu, sauf s'il retourne false. */
+  function buildMoreMenu() {
+    if (!bar || !moreBtn || moreMenu) return;
+    moreMenu = document.createElement("div");
+    moreMenu.className = "draco-more-menu";
+    moreMenu.hidden = true;
+    moreMenu.setAttribute("role", "menu");
+    moreMenu.setAttribute("aria-label", "Plus d'actions");
+    moreMenu.appendChild(menuLink("agent", "Console agent", "Agent commun"));
+    var sep = document.createElement("div");
+    sep.className = "draco-menu-sep";
+    sep.setAttribute("aria-hidden", "true");
+    moreMenu.appendChild(sep);
+    ["obsigate", "flowdeck", "tiktak", "kanbante"].forEach(function (app) {
+      moreMenu.appendChild(menuLink(app, tabLabel(app), tabRole(app)));
+    });
+    bar.appendChild(moreMenu);
+  }
+  function toggleMoreMenu(force) {
+    buildMoreMenu();
+    if (!moreMenu) return;
+    if (force !== false) refreshMenuHrefs(moreMenu);
+    togglePopup(moreMenu, moreBtn, force);
+  }
+
+  /* Menu compte (v0.1.6) — en-tête d'identité + Profil / Déconnexion
+   * relayés à l'hôte. L'en-tête est rafraîchi à chaque ouverture, pour
+   * refléter un title posé après coup par l'hôte (ex. ObsiGate, qui
+   * remplit l'avatar depuis /api/auth/me après chargement). */
+  function buildCompteMenu() {
+    if (!bar || !avatarBtn || compteMenu) return;
+    compteMenu = document.createElement("div");
+    compteMenu.className = "draco-compte-menu";
+    compteMenu.hidden = true;
+    compteMenu.setAttribute("role", "menu");
+    compteMenu.setAttribute("aria-label", "Compte");
+    var head = document.createElement("div");
+    head.className = "draco-compte-nom";
+    compteMenu.appendChild(head);
+    [["profil", "Profil"], ["deconnexion", "Déconnexion"]].forEach(function (pair) {
+      var b = document.createElement("button");
+      b.type = "button";
+      b.className = "draco-menu-item";
+      b.setAttribute("data-compte-act", pair[0]);
+      b.setAttribute("role", "menuitem");
+      b.textContent = pair[1];
+      compteMenu.appendChild(b);
+    });
+    bar.appendChild(compteMenu);
+  }
+  function refreshCompteMenu() {
+    if (!compteMenu) return;
+    var head = compteMenu.querySelector(".draco-compte-nom");
+    var name = displayName();
+    if (head) head.textContent = name || "Compte";
+  }
+  function toggleCompteMenu(force) {
+    buildCompteMenu();
+    if (!compteMenu) return;
+    if (force !== false) { syncAvatar(); refreshCompteMenu(); }
+    togglePopup(compteMenu, avatarBtn, force);
+  }
+
+  /* Relais d'une action vers l'hôte : onAction si présent, sinon
+   * événement draco:bar (contrat historique des actions relayées). */
+  function relay(act, el, ev) {
+    if (typeof cfg.onAction === "function") cfg.onAction(act, el, ev);
+    else document.dispatchEvent(new CustomEvent("draco:bar", { detail: { act: act, el: el } }));
   }
 
   document.addEventListener("click", function (ev) {
-    var el = ev.target.closest("[data-act]");
-    if (el && el.dataset.act === "apps") {
-      ev.preventDefault();
-      toggleMenu();
+    /* Items du menu compte : relais + fermeture, jamais de navigation. */
+    var compteItem = ev.target.closest ? ev.target.closest("[data-compte-act]") : null;
+    if (compteItem) {
+      relay(compteItem.getAttribute("data-compte-act"), compteItem, ev);
+      toggleCompteMenu(false);
       return;
     }
-    if (menu && !menu.hidden && !ev.target.closest(".draco-apps-menu") && !ev.target.closest(".draco-brand")) {
-      toggleMenu(false);
+    var el = ev.target.closest ? ev.target.closest("[data-act]") : null;
+    if (el && el.dataset.act === "apps") {
+      ev.preventDefault();
+      if (moreMenu) toggleMoreMenu(false);
+      if (compteMenu) toggleCompteMenu(false);
+      toggleAppsMenu();
+      return;
+    }
+    if (el && el.dataset.act === "menu") {
+      if (appsMenu) toggleAppsMenu(false);
+      if (compteMenu) toggleCompteMenu(false);
+      /* Hôte prioritaire : il garde la main, sauf s'il demande
+       * explicitement le menu par défaut en retournant false.
+       * Sans onAction, le menu par défaut s'ouvre (il ne restait
+       * auparavant qu'un événement draco:bar sans écouteur). */
+      if (typeof cfg.onAction === "function") {
+        var handled = cfg.onAction("menu", el, ev);
+        if (handled === false) toggleMoreMenu();
+      } else {
+        toggleMoreMenu();
+      }
+      return;
+    }
+    if (el && el.dataset.act === "compte") {
+      if (appsMenu) toggleAppsMenu(false);
+      if (moreMenu) toggleMoreMenu(false);
+      toggleCompteMenu();
+      return;
+    }
+    /* Clic extérieur : ferme tout menu ouvert (clic dans un menu ou
+     * sur son déclencheur déjà traité ci-dessus). */
+    var inPopup = ev.target.closest ? (ev.target.closest(".draco-apps-menu") ||
+      ev.target.closest(".draco-more-menu") || ev.target.closest(".draco-compte-menu")) : null;
+    if (!inPopup && ((appsMenu && !appsMenu.hidden) || (moreMenu && !moreMenu.hidden) || (compteMenu && !compteMenu.hidden))) {
+      closeAllPopups();
     }
     if (!el) return;
     var act = el.dataset.act;
     if (act === "domaine") setDomain(el.dataset.dom);
-    if (typeof cfg.onAction === "function") cfg.onAction(act, el, ev);
-    else document.dispatchEvent(new CustomEvent("draco:bar", { detail: { act: act, el: el } }));
+    relay(act, el, ev);
   });
 
   document.addEventListener("keydown", function (ev) {
-    if (ev.key === "Escape") toggleMenu(false);
+    if (ev.key === "Escape") closeAllPopups();
   });
 
-  /* API publique : l'app met les compteurs à jour sans recharger. */
-  window.DRACO_BAR = { setCounts: setCounts, setCurrent: setCurrent, setDomain: setDomain };
+  /* API publique : l'app met les compteurs à jour sans recharger.
+   * setUrls(urls) fusionne de nouvelles bases (même contrat que
+   * DRACO_BAR_CONFIG.urls — donc prioritaires sur la dérivation -dev)
+   * et les ré-applique aux onglets et aux menus ; DRACO_BAR.urls expose
+   * les bases résolues (défauts inclus), pour le panneau Spark et tout
+   * autre consommateur de l'hôte. */
+  window.DRACO_BAR = {
+    setCounts: setCounts, setCurrent: setCurrent, setDomain: setDomain,
+    urls: resolvedUrls,
+    setUrls: function (urls) {
+      cfg.urls = Object.assign({}, cfg.urls, urls || {});
+      resolvedUrls = resolveUrls();
+      window.DRACO_BAR.urls = resolvedUrls;
+      applyUrls(resolvedUrls);
+    }
+  };
 
-  buildMenu();
+  applyUrls(resolvedUrls);
+  buildAppsMenu();
+  buildMoreMenu();
+  buildCompteMenu();
+  syncAvatar();
+  refreshCompteMenu();
   if (cfg.current) setCurrent(cfg.current);
   if (cfg.domain) setDomain(cfg.domain);
   if (cfg.counts) setCounts(cfg.counts);

tests/recherche.test.js

@@ -0,0 +1,68 @@
+/* Tests Node sans navigateur de recherche.js (logique pure).
+ * Usage : node recherche.test.js — sortie 0 si tout passe. */
+"use strict";
+const assert = require("node:assert/strict");
+const rp = require("../static/js/recherche.js");
+
+let n = 0;
+function ok(cond, label) {
+  assert.ok(cond, label);
+  n += 1;
+}
+
+/* esc */
+ok(rp.esc('<a href="x">&') === "&lt;a href=&quot;x&quot;&gt;&amp;", "esc échappe HTML");
+
+/* isDevHost : même règle que la barre v0.1.6 */
+ok(rp.isDevHost("tiktak-dev.dracodev.net") === true, "dev reconnu");
+ok(rp.isDevHost("tiktak.dracodev.net") === false, "prod non dev");
+ok(rp.isDevHost("x-dev.dracodev.net.evil") === false, "hôte piège rejeté");
+ok(rp.isDevHost("dev.dracodev.net") === false, "étiquette trop courte rejetée");
+ok(rp.isDevHost("TIKTAK-DEV.DRACODEV.NET") === true, "insensible à la casse");
+
+/* resolveBases : ordre explicite > barre > dev > href > prod */
+let b = rp.resolveBases({
+  host: "tiktak-dev.dracodev.net",
+  explicit: { obsigate: "https://og-perso.example/" },
+  barUrls: { flowdeck: "https://flowdeck-barre.example/" },
+  tabHrefs: { kanbante: "https://kanbante-href.example/" },
+});
+ok(b.obsigate === "https://og-perso.example/", "explicite prioritaire");
+ok(b.flowdeck === "https://flowdeck-barre.example/", "barre avant dev");
+ok(b.tiktak === "https://tiktak-dev.dracodev.net/", "dev pour l'hôte courant");
+ok(b.kanbante === "https://kanbante-dev.dracodev.net/", "dev avant href");
+b = rp.resolveBases({ host: "tiktak.dracodev.net", tabHrefs: { kanbante: "https://kanbante-href.example/" } });
+ok(b.kanbante === "https://kanbante-href.example/", "href en prod");
+ok(b.obsigate === "https://og.dracodev.net/", "défaut prod");
+b = rp.resolveBases({});
+ok(b.flowdeck === "https://flowdeck.dracodev.net/", "défaut prod sans hôte");
+
+/* searchPath */
+ok(rp.searchPath("obsigate", "café & thé") === "api/search?q=caf%C3%A9%20%26%20th%C3%A9&vault=all&limit=8", "path ObsiGate");
+ok(rp.searchPath("tiktak", "a b") === "api/search?q=a%20b", "path TikTak");
+
+/* normalize ObsiGate */
+let items = rp.normalize("obsigate", { results: [{ vault: "home-bruno", path: "Notes/Idée.md", title: "Idée", snippet: "extrait" }] }, "https://og-dev.dracodev.net/", "idée");
+ok(items.length === 1 && items[0].url === "https://og-dev.dracodev.net/#file=home-bruno:Notes%2FId%C3%A9e.md", "lien profond ObsiGate");
+ok(items[0].context === "home-bruno · Notes/Idée.md", "contexte ObsiGate");
+
+/* normalize Flowdeck */
+items = rp.normalize("flowdeck", { pages: [{ title: "P", excerpt: "ex", subtitle: "Espace", url: "/pages/42" }], collections: [{ title: "B", subtitle: "Database · Espace", url: "/db/7" }] }, "https://flowdeck-dev.dracodev.net/", "p");
+ok(items.length === 2 && items[0].url === "https://flowdeck-dev.dracodev.net/pages/42", "lien page Flowdeck");
+ok(items[1].url === "https://flowdeck-dev.dracodev.net/db/7", "lien base Flowdeck");
+
+/* normalize TikTak */
+items = rp.normalize("tiktak", { tasks: [{ id: 9, title: "Faire X", description: "d", status: "active", due_at: "2026-10-30 09:00:00" }] }, "https://tiktak-dev.dracodev.net/", "faire");
+ok(items[0].url === "https://tiktak-dev.dracodev.net/search?q=faire&task=9", "lien profond TikTak");
+ok(items[0].context === "Tâche · Active · échéance 2026-10-30", "contexte TikTak");
+
+/* normalize Kanbante */
+items = rp.normalize("kanbante", { groups: [{ full_name: "Projets/site", rows: [{ issue: { number: 12, title: "Bug", body: "corps" }, column: "in_progress" }] }] }, "https://kanbante-dev.dracodev.net/", "bug");
+ok(items[0].title === "#12 Bug" && items[0].url === "https://kanbante-dev.dracodev.net/board/Projets/site", "lien tableau Kanbante");
+ok(items[0].context === "Projets/site · En cours", "contexte Kanbante");
+
+/* nativeSearchUrl */
+ok(rp.nativeSearchUrl("tiktak", "https://tiktak-dev.dracodev.net/", "q") === "https://tiktak-dev.dracodev.net/search?q=q", "repli TikTak");
+ok(rp.nativeSearchUrl("obsigate", "https://og-dev.dracodev.net/", "q") === "https://og-dev.dracodev.net/", "repli ObsiGate = accueil (palette)");
+
+console.log("recherche.test.js : " + n + " assertions OK");

tests/test_coffre_reference_flowdeck.py

@@ -0,0 +1,282 @@
+"""Phase 4 (issue ObsiGate #22) — connecteurs Flowdeck à référence ObsiGate.
+
+Couverture : format de référence, création liée à un workspace, isolation
+(A ne distribue pas avec l'octroi de B — le faux distributeur n'est même
+pas appelé), distribution en mémoire sans persistance ni cache, octroi
+révoqué, ObsiGate indisponible (aucun repli), connecteurs historiques
+chiffrés toujours valides, routes API.
+
+Le distributeur est un FAUX endpoint (appelable injecté), clairement
+identifié comme tel : aucun test ne parle à une vraie instance ObsiGate.
+Les valeurs de test sont fictives (``TEST-VALUE-XXXX``).
+"""
+
+import pytest
+from conftest import anon_csrf
+
+from app.db import get_conn
+from app.services import coffre_reference, connectors
+from app.services.coffre_reference import (
+    CoffreAccesRefuse,
+    CoffreIndisponible,
+    CoffreReferenceInvalide,
+    CoffreWorkspaceMismatch,
+)
+
+PUBLIC_URL = "https://example.com/api"
+REFERENCE = "coffre:flowdeck/gitea-lecture"
+FAKE_VALUE = "TEST-VALUE-XXXX"
+
+
+@pytest.fixture(autouse=True)
+def _faux_jeton_consommateur():
+    """Le distributeur exige un jeton consommateur : valeur fictive de test.
+
+    Sans elle, ``distribuer`` refuserait avant même d'appeler le faux
+    endpoint (comportement voulu en production).
+    """
+    import app.config
+
+    app.config.settings.obsigate_consumer_token = "TEST-CONSUMER-TOKEN-XXXX"
+    yield
+
+
+def _workspaces():
+    with get_conn() as conn:
+        conn.execute(
+            "INSERT OR IGNORE INTO users (id, login, full_name, is_admin) "
+            "VALUES (1, 'tester', 'Tester', 1)"
+        )
+        conn.execute(
+            "INSERT INTO workspaces (name, owner_id) VALUES ('Atelier A', 1)"
+        )
+        conn.execute(
+            "INSERT INTO workspaces (name, owner_id) VALUES ('Atelier B', 1)"
+        )
+        conn.commit()
+        rows = conn.execute(
+            "SELECT id FROM workspaces ORDER BY id"
+        ).fetchall()
+    return int(rows[0]["id"]), int(rows[1]["id"])
+
+
+class _FakeDistributeur:
+    """Faux endpoint ObsiGate : compte les appels, ne persiste rien."""
+
+    def __init__(self, behaviour="ok"):
+        self.behaviour = behaviour
+        self.calls = []
+
+    def __call__(self, url, payload, headers):
+        self.calls.append((url, dict(payload)))
+        assert url.endswith("/api/coffres/distribuer"), url
+        assert headers.get("Authorization", "").startswith("Bearer "), headers
+        if self.behaviour == "ok":
+            return 200, {"reference": payload["reference"], "valeur": FAKE_VALUE,
+                         "version": 1}
+        if self.behaviour == "revoque":
+            return 403, {"detail": "octroi_revoque"}
+        if self.behaviour == "indisponible":
+            raise ConnectionError("faux ObsiGate injoignable")
+        raise AssertionError(self.behaviour)
+
+
+def _create_coffre(client, ws, **kw):
+    body = {"name": "Conn coffre", "url": PUBLIC_URL,
+            "workspace_id": ws, "coffre_reference": REFERENCE, **kw}
+    r = client.post("/api/agent/connectors", json=body)
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+# ── Format ─────────────────────────────────────────────────────────────────
+
+@pytest.mark.parametrize("bad", [
+    "gitea-lecture", "coffre:", "coffre:slug-seul", "coffre:AB/mauvais",
+    "coffre:a/b", "coffre:ok/mauvais nom", "coffre:ok/",
+])
+def test_reference_invalide_rejetee(bad):
+    with pytest.raises(CoffreReferenceInvalide):
+        coffre_reference.parse_reference(bad)
+
+
+def test_reference_normalisee_minuscules():
+    assert coffre_reference.parse_reference("Coffre:FlowDeck/Gitea-Lecture") == (
+        "flowdeck", "gitea-lecture")
+
+
+# ── Création liée au workspace ─────────────────────────────────────────────
+
+def test_creation_coffre_exige_workspace(client):
+    r = client.post("/api/agent/connectors",
+                    json={"name": "Sans WS", "url": PUBLIC_URL,
+                          "coffre_reference": REFERENCE})
+    assert r.status_code == 400, r.text
+    assert "workspace" in r.text.lower()
+
+
+def test_creation_coffre_refuse_secret_et_reference(client):
+    ws_a, _ = _workspaces()
+    r = client.post("/api/agent/connectors",
+                    json={"name": "Ambigu", "url": PUBLIC_URL, "secret": "x",
+                          "workspace_id": ws_a, "coffre_reference": REFERENCE})
+    assert r.status_code == 400, r.text
+
+
+def test_creation_coffre_ne_stocke_aucun_jeton(client):
+    ws_a, _ = _workspaces()
+    row = _create_coffre(client, ws_a)
+    assert row["coffre_reference"] == REFERENCE
+    assert row["workspace_id"] == ws_a
+    assert row["secret_source"] == "coffre"
+    assert row["has_secret"] is True
+    assert FAKE_VALUE not in str(row)
+    with get_conn() as conn:
+        stored = conn.execute(
+            "SELECT secret_encrypted, coffre_reference FROM agent_connectors "
+            "WHERE id=?", (row["id"],)
+        ).fetchone()
+    assert stored["secret_encrypted"] == ""          # aucun jeton stocké
+    assert stored["coffre_reference"] == REFERENCE   # métadonnée seulement
+
+
+def test_creation_workspace_introuvable(client):
+    r = client.post("/api/agent/connectors",
+                    json={"name": "WS ?", "url": PUBLIC_URL,
+                          "workspace_id": 999999, "coffre_reference": REFERENCE})
+    assert r.status_code == 400, r.text
+
+
+# ── Résolution + isolation (critère central) ───────────────────────────────
+
+def test_resolve_bon_workspace_distribue_en_memoire(client):
+    ws_a, _ = _workspaces()
+    row = _create_coffre(client, ws_a)
+    fake = _FakeDistributeur()
+    valeur = connectors.resolve_secret(row["id"], workspace_id=ws_a,
+                                       distribute=fake)
+    assert valeur == FAKE_VALUE
+    assert len(fake.calls) == 1
+    _, payload = fake.calls[0]
+    assert payload["reference"] == REFERENCE
+    assert payload["contexte_type"] == "flowdeck_workspace"
+    assert payload["contexte_id"] == str(ws_a)
+    # Rien n'a été persisté ni mis en cache par la distribution.
+    with get_conn() as conn:
+        stored = conn.execute(
+            "SELECT secret_encrypted FROM agent_connectors WHERE id=?",
+            (row["id"],)
+        ).fetchone()
+    assert stored["secret_encrypted"] == ""
+    assert FAKE_VALUE not in str(connectors.get(row["id"]))
+
+
+def test_isolation_workspace_a_ne_distribue_pas_octroi_de_b(client):
+    ws_a, ws_b = _workspaces()
+    row = _create_coffre(client, ws_b)   # octroi du workspace B
+    fake = _FakeDistributeur()
+    with pytest.raises(CoffreWorkspaceMismatch) as exc:
+        connectors.resolve_secret(row["id"], workspace_id=ws_a,
+                                  distribute=fake)
+    assert "ne peut pas utiliser" in str(exc.value)
+    assert fake.calls == []              # distributeur jamais appelé
+
+
+def test_resolve_sans_workspace_refuse(client):
+    ws_a, _ = _workspaces()
+    row = _create_coffre(client, ws_a)
+    fake = _FakeDistributeur()
+    with pytest.raises(ValueError, match="workspace_id"):
+        connectors.resolve_secret(row["id"], distribute=fake)
+    assert fake.calls == []
+
+
+def test_headers_bon_workspace_mauvais_workspace(client):
+    ws_a, ws_b = _workspaces()
+    row = _create_coffre(client, ws_a)
+    fake = _FakeDistributeur()
+    headers = connectors._headers(row["id"], workspace_id=ws_a,
+                                  distribute=fake)
+    assert headers["Authorization"] == f"Bearer {FAKE_VALUE}"
+    with pytest.raises(CoffreWorkspaceMismatch):
+        connectors._headers(row["id"], workspace_id=ws_b, distribute=fake)
+
+
+# ── Échecs propres ─────────────────────────────────────────────────────────
+
+def test_octroi_revoque_message_explicite_sans_repli(client):
+    ws_a, _ = _workspaces()
+    row = _create_coffre(client, ws_a)
+    fake = _FakeDistributeur(behaviour="revoque")
+    with pytest.raises(CoffreAccesRefuse) as exc:
+        connectors.resolve_secret(row["id"], workspace_id=ws_a,
+                                  distribute=fake)
+    assert "révoqué" in str(exc.value)
+    assert "ré-accorder" in str(exc.value)
+    assert exc.value.detail == "octroi_revoque"
+
+
+def test_obsigate_indisponible_sans_valeur_en_cache(client):
+    ws_a, _ = _workspaces()
+    row = _create_coffre(client, ws_a)
+    fake = _FakeDistributeur(behaviour="indisponible")
+    for _ in range(2):   # deux appels : aucun ne doit renvoyer une valeur
+        with pytest.raises(CoffreIndisponible):
+            connectors.resolve_secret(row["id"], workspace_id=ws_a,
+                                      distribute=fake)
+    assert len(fake.calls) == 2          # chaque appel retente, rien en cache
+
+
+# ── Migration opportuniste ─────────────────────────────────────────────────
+
+def test_connecteur_historique_chiffre_toujours_valide(client):
+    body = {"name": "Conn perso", "url": PUBLIC_URL, "secret": "sk-live-abc"}
+    row = client.post("/api/agent/connectors", json=body).json()
+    assert row["secret_source"] == "chiffre_local"
+    assert connectors.resolve_secret(row["id"]) == "sk-live-abc"
+
+
+def test_bascule_patch_vers_reference_puis_retour(client):
+    ws_a, ws_b = _workspaces()
+    row = client.post("/api/agent/connectors",
+                      json={"name": "Migrable", "url": PUBLIC_URL,
+                            "secret": "sk-live-abc"}).json()
+    cid = row["id"]
+    # 1. rattacher au workspace, 2. basculer vers la référence.
+    r = client.patch(f"/api/agent/connectors/{cid}",
+                     json={"workspace_id": ws_a})
+    assert r.status_code == 200, r.text
+    r = client.patch(f"/api/agent/connectors/{cid}",
+                     json={"coffre_reference": REFERENCE})
+    assert r.status_code == 200, r.text
+    assert r.json()["secret_source"] == "coffre"
+    # Le workspace est immuable : pas de transfert d'octroi vers B.
+    r = client.patch(f"/api/agent/connectors/{cid}",
+                     json={"workspace_id": ws_b})
+    assert r.status_code == 400, r.text
+    # Effacer la référence réactive le jeton local dormant.
+    r = client.patch(f"/api/agent/connectors/{cid}",
+                     json={"coffre_reference": ""})
+    assert r.status_code == 200, r.text
+    assert r.json()["secret_source"] == "chiffre_local"
+    assert connectors.resolve_secret(cid) == "sk-live-abc"
+
+
+def test_probe_coffre_sans_workspace_echoue_proprement(client, monkeypatch):
+    ws_a, _ = _workspaces()
+    row = _create_coffre(client, ws_a)
+
+    async def ok_get(url, headers=None):
+        return 200, "{}"
+
+    monkeypatch.setattr(connectors, "_get", ok_get)
+    r = client.post("/api/agent/connectors/probe",
+                    json={"connector": str(row["id"])})
+    assert r.status_code == 200
+    assert r.json()["status"] == "error"   # refus, pas de fuite inter-workspace
+
+
+def test_routes_exigent_session(client):
+    anon_csrf(client)
+    assert client.post("/api/agent/connectors",
+                       json={"name": "x", "url": PUBLIC_URL}).status_code == 401

tests/test_fusion_format_commun.py

@@ -0,0 +1,78 @@
+"""Fusion ACC-4.5 — conversion d'Agents & Skills Flowdeck au format
+commun (contrat ACC-0.3, `dracodev-commons/contrats/skill-format.md`).
+
+Preuve du format : trois presets de la galerie Flowdeck convertis en
+`skills-communs/<nom>/SKILL.md` (compte-rendu-reunion, rapport-hebdo,
+resume-document). Ils doivent être conformes au contrat, se convertir
+en champs Flowdeck et s'installer dans un workspace via le chemin
+existant (`skill_gallery.upsert_skill`).
+"""
+
+from pathlib import Path
+
+import pytest
+
+from app.services import skill_format, skill_gallery
+
+RACINE = Path(__file__).resolve().parent.parent
+CONVERTIS = ["compte-rendu-reunion", "rapport-hebdo", "resume-document"]
+
+
+def _lire(nom: str) -> str:
+    return (RACINE / "skills-communs" / nom / "SKILL.md").read_text(encoding="utf-8")
+
+
+def test_trois_skills_convertis_conformes():
+    for nom in CONVERTIS:
+        skill = skill_format.analyser_skill_md(_lire(nom))
+        assert skill_format.valider(skill) == [], (nom, skill_format.valider(skill))
+        assert skill["meta"]["name"] == nom
+        assert skill["meta"]["apps"] == ["flowdeck"]
+        assert skill["meta"]["version"] == "1.0.0"
+        # Toute écriture est déclarée, avec approbation explicite.
+        actions = {e["action"] for e in skill["meta"]["ecritures"]}
+        assert actions == {"flowdeck.create_document", "flowdeck.write_blocks"}
+
+
+def test_conversion_vers_flowdeck_et_installation(client):
+    for nom in CONVERTIS:
+        skill = skill_format.analyser_skill_md(_lire(nom))
+        champs = skill_format.vers_champs_flowdeck(skill)
+        assert champs["name"] == nom
+        assert set(champs["allowed_tools"]) == {
+            "search_workspace", "read_document", "create_document", "write_blocks"}
+        assert "Procédure" in champs["prompt_template"]
+        assert "Garde-fous" in champs["prompt_template"]
+        row, cree = skill_gallery.upsert_skill(
+            champs, workspace_id=None, created_by=1)
+        assert cree is True and row["name"] == nom
+
+
+def test_validation_rejette_les_ecarts():
+    incomplet = skill_format.analyser_skill_md(
+        "---\nname: mauvais nom\napps: [flowdeck]\n---\n\n## Procédure\n\nx\n")
+    erreurs = skill_format.valider(incomplet)
+    assert any("kebab" in e for e in erreurs)
+    assert any("description" in e for e in erreurs)
+    assert any("Quand l'utiliser" in e for e in erreurs)
+    with pytest.raises(ValueError):
+        skill_format.vers_champs_flowdeck(incomplet)
+
+
+def test_ecritures_obligatoires_si_outil_ecrivant():
+    texte = (
+        "---\nname: supprime-tout\ndescription: x\nversion: 1.0.0\n"
+        "apps: [flowdeck]\ndomaines: [pro]\noutils: [flowdeck.delete_page]\n---\n\n"
+        "## Quand l'utiliser\n\nx\n\n## Procédure\n\nx\n\n## Garde-fous\n\nx\n")
+    erreurs = skill_format.valider(skill_format.analyser_skill_md(texte))
+    assert any("ecritures obligatoire" in e for e in erreurs)
+
+
+def test_aller_retour_depuis_un_preset():
+    preset = skill_gallery.get_gallery("compte-rendu-reunion")
+    texte = skill_format.depuis_preset_flowdeck(preset, domaines=["pro"])
+    skill = skill_format.analyser_skill_md(texte)
+    assert skill_format.valider(skill) == []
+    champs = skill_format.vers_champs_flowdeck(skill)
+    assert champs["name"] == "compte-rendu-de-reunion"
+    assert "create_document" in champs["allowed_tools"]

tests/test_fusion_panneau_commun.py

@@ -0,0 +1,57 @@
+"""Fusion ACC-4.4 — panneau de l'agent commun intégré à Flowdeck.
+
+Le panneau commun (composant partagé des quatre apps, contrat
+d'injection `dracodev-commons`) est intégré depuis la 7.81.0
+(panneau v3), complété par le mode console (7.82.x) et la version du
+service affichée en mode sidebar (7.83.1, fusion #64). Ces tests
+figent le contrat d'intégration côté Flowdeck :
+
+- le gabarit de base charge les assets du panneau et injecte la
+  configuration (URL du service d'agents résolue par configuration,
+  jamais un nom public codé en dur dans le JS) ;
+- le panneau parle au service d'agents (conversation **commune** :
+  même discussion perpétuelle que dans les autres apps) ;
+- les automatisations locales de Flowdeck restent locales (C5) :
+  le panneau commun ne remplace pas le moteur d'agent local.
+"""
+
+from pathlib import Path
+
+RACINE = Path(__file__).resolve().parent.parent
+
+
+def test_gabarit_charge_le_panneau_et_injecte_la_config():
+    base = (RACINE / "app/templates/base.html").read_text(encoding="utf-8")
+    assert "/static/css/draco-panneau.css" in base
+    assert "/static/js/draco-panneau.js" in base
+    assert "window.DRACO_PANNEAU_CONFIG" in base
+    assert "draco_agent_url()" in base
+
+
+def test_panneau_parle_au_service_agent_conversation_commune():
+    js = (RACINE / "static/js/draco-panneau.js").read_text(encoding="utf-8")
+    # Même conversation continue que dans les autres apps : le
+    # panneau s'appuie sur l'API du service (contrat commons).
+    assert "/api/v1/me" in js
+    assert "/api/v1/chat" in js
+    assert "/api/v1/conversations" in js
+    # La configuration vient de l'hôte ; le seul repli est le nom
+    # officiel — aucun nom public d'app en dur dans le composant.
+    assert "DRACO_PANNEAU_CONFIG" in js
+    for nom in ("flowdeck-dev", "og-dev", "tiktak-dev", "kanbante-dev",
+                "agent-dev"):
+        assert f"://{nom}." not in js  # aucune URL publique -dev codée en dur
+
+
+def test_assets_panneau_servis(client):
+    for chemin in ("/static/js/draco-panneau.js", "/static/css/draco-panneau.css"):
+        r = client.get(chemin)
+        assert r.status_code == 200, chemin
+
+
+def test_automatisations_locales_conservées(client):
+    # C5 : l'agent local de Flowdeck (automatisations, gouvernance)
+    # reste en place à côté du panneau commun.
+    r = client.get("/api/v2/agent-approvals", params={"status": "pending"})
+    assert r.status_code == 200
+    assert "approvals" in r.json()

tests/test_fusion_pilote_reunion_obsigate.py

@@ -0,0 +1,191 @@
+"""Fusion ACC-6.2 — pilote d'écriture approuvée : archiver un résumé
+de réunion Flowdeck dans ObsiGate via la file d'approbations unifiée.
+
+Chaîne testée : demande déposée dans `agent_approvals` (outil
+`archiver_reunion_obsigate`) → décision dans la file (route
+gouvernance) → si approuvée, `propose_write_file` part vers ObsiGate
+par le pont MCP (ACC-2.2) et la distribution est journalisée (canal
+`obsigate`). Rejet = rien n'est envoyé. Sans connecteur ObsiGate,
+l'exécution échoue proprement avec un message explicite.
+
+La preuve réelle reste conditionnelle (chantier Meetings A/B +
+clé ObsiGate dédiée de Bruno) ; ici le serveur MCP est simulé.
+"""
+
+import asyncio
+import json
+
+import pytest
+
+from app.auth.session import SessionManager
+from app.db import get_conn
+from app.services import mcp_client, meeting_archive, meetings
+from app.services.importers import url_fetch
+
+
+@pytest.fixture(autouse=True)
+def _dns_monde_reel(monkeypatch):
+    monkeypatch.setattr(url_fetch, "_validate_url", lambda url: url.strip())
+    monkeypatch.setattr(mcp_client, "_sessions", {})
+
+
+@pytest.fixture
+def admin_cookies():
+    with get_conn() as conn:
+        conn.execute(
+            "INSERT OR IGNORE INTO users (id, login, full_name, is_admin)"
+            " VALUES (1, 'tester', 'Tester', 1)")
+        conn.commit()
+    session = SessionManager.create_session(
+        {"id": 1, "login": "tester", "is_admin": 1})
+    return {"flowdeck_session": session}
+
+
+def _transcript_avec_resume():
+    with get_conn() as conn:
+        pid = conn.execute(
+            "INSERT INTO pages (workspace, title, content, content_format)"
+            " VALUES ('test', 'Réunion hebdo', '', 'blocks')").lastrowid
+        tid = conn.execute(
+            "INSERT INTO meeting_transcripts (page_id, summary)"
+            " VALUES (?, ?)",
+            (pid, "## Décisions\n\n- Lancer le pilote d'archivage.\n"
+                  "- Revoir le pont MCP la semaine prochaine.")).lastrowid
+        conn.commit()
+    meetings._update(tid, generated_title="Hebdo produit", status="done")
+    return tid
+
+
+def _creer_connecteur_obsigate(client):
+    r = client.post("/api/agent/connectors", json={
+        "name": "ObsiGate", "kind": "obsigate",
+        "url": "https://og.dracodev.net/mcp",
+        "secret": "og_cle_pont_test", "auth": "bearer"})
+    assert r.status_code == 200, r.text
+    return r.json()["id"]
+
+
+def _faux_rpc_obsigate(appels):
+    async def fake_rpc(url, payload, headers=None):
+        appels.append(payload.get("method"))
+        method = payload.get("method")
+        if method == "initialize":
+            return {"result": {"protocolVersion": "2025-03-26",
+                               "serverInfo": {"name": "obsigate"}}}
+        if method == "tools/call":
+            params = payload.get("params") or {}
+            appels.append((params.get("name"), params.get("arguments")))
+            return {"result": {"content": [
+                {"type": "text", "text": json.dumps({"draft_id": "b-42"})}]}}
+        return {}
+    return fake_rpc
+
+
+def test_demande_approbation_et_gardes(client, admin_cookies):
+    tid = _transcript_avec_resume()
+    r = client.post(f"/api/v2/meetings/transcripts/{tid}/archiver-obsigate",
+                    cookies=admin_cookies)
+    assert r.status_code == 201, r.text
+    body = r.json()
+    assert body["titre"] == "Hebdo produit"
+    assert body["chemin"].startswith("Réunions/")
+    assert body["chemin"].endswith("Hebdo produit.md")
+    approval = body["approval"]
+    assert approval["tool"] == "archiver_reunion_obsigate"
+    assert approval["status"] == "pending"
+    assert json.loads(approval["args_json"])["transcript_id"] == tid
+    # Doublon refusé tant que la demande est en attente.
+    r2 = client.post(f"/api/v2/meetings/transcripts/{tid}/archiver-obsigate",
+                     cookies=admin_cookies)
+    assert r2.status_code == 400
+
+
+def test_resume_vide_refuse(client, admin_cookies):
+    with get_conn() as conn:
+        pid = conn.execute(
+            "INSERT INTO pages (workspace, title, content, content_format)"
+            " VALUES ('test', 'Vide', '', 'blocks')").lastrowid
+        tid = conn.execute(
+            "INSERT INTO meeting_transcripts (page_id) VALUES (?)",
+            (pid,)).lastrowid
+        conn.commit()
+    r = client.post(f"/api/v2/meetings/transcripts/{tid}/archiver-obsigate",
+                    cookies=admin_cookies)
+    assert r.status_code == 400
+    assert "Résumé vide" in r.text
+
+
+def test_approbation_execute_la_proposition(client, admin_cookies, monkeypatch):
+    _creer_connecteur_obsigate(client)
+    appels: list = []
+    monkeypatch.setattr(mcp_client, "_rpc", _faux_rpc_obsigate(appels))
+    tid = _transcript_avec_resume()
+    r = client.post(f"/api/v2/meetings/transcripts/{tid}/archiver-obsigate",
+                    cookies=admin_cookies)
+    aid = r.json()["approval"]["id"]
+
+    d = client.post(f"/api/v2/agent-approvals/{aid}/decide",
+                    cookies=admin_cookies, json={"approve": True})
+    assert d.status_code == 200, d.text
+    body = d.json()
+    assert body["status"] == "approved"
+    assert body["archive"]["status"] == "ok", body["archive"]
+    assert "Réunions/" in body["archive"]["detail"]
+    # propose_write_file a reçu le résumé, jamais un apply direct.
+    calls = [a for a in appels if isinstance(a, tuple)]
+    assert len(calls) == 1 and calls[0][0] == "propose_write_file"
+    assert "Lancer le pilote" in calls[0][1]["content"]
+    assert calls[0][1]["path"].endswith("Hebdo produit.md")
+    # Distribution journalisée, canal obsigate.
+    with get_conn() as conn:
+        rows = conn.execute(
+            "SELECT * FROM meeting_distributions WHERE transcript_id=?",
+            (tid,)).fetchall()
+    assert len(rows) == 1
+    assert rows[0]["channel"] == "obsigate" and rows[0]["status"] == "propose"
+
+
+def test_rejet_ne_envoie_rien(client, admin_cookies, monkeypatch):
+    _creer_connecteur_obsigate(client)
+    appels: list = []
+    monkeypatch.setattr(mcp_client, "_rpc", _faux_rpc_obsigate(appels))
+    tid = _transcript_avec_resume()
+    aid = meeting_archive.demander_approbation(tid, 1)["id"]
+    d = client.post(f"/api/v2/agent-approvals/{aid}/decide",
+                    cookies=admin_cookies, json={"approve": False})
+    assert d.json()["archive"]["status"] == "rejete"
+    assert not [a for a in appels if isinstance(a, tuple)]
+    with get_conn() as conn:
+        n = conn.execute(
+            "SELECT COUNT(*) AS n FROM meeting_distributions"
+            " WHERE transcript_id=?", (tid,)).fetchone()["n"]
+    assert n == 0
+
+
+def test_sans_connecteur_erreur_explicite(client, admin_cookies):
+    tid = _transcript_avec_resume()
+    aid = meeting_archive.demander_approbation(tid, 1)["id"]
+    d = client.post(f"/api/v2/agent-approvals/{aid}/decide",
+                    cookies=admin_cookies, json={"approve": True})
+    archive = d.json()["archive"]
+    assert archive["status"] == "erreur"
+    assert "Connecteur ObsiGate non configuré" in archive["detail"]
+
+
+def test_construire_archive_contenu(client):
+    tr = meetings.get_transcript(_transcript_avec_resume())
+    archive = meeting_archive.construire_archive(tr)
+    assert archive["chemin"].startswith("Réunions/")
+    assert "# Hebdo produit" in archive["contenu"]
+    assert "Lancer le pilote" in archive["contenu"]
+    assert "/pages/" in archive["contenu"]  # lien profond vers la note
+
+
+def test_executer_async_direct(client, monkeypatch):
+    appels: list = []
+    monkeypatch.setattr(mcp_client, "_rpc", _faux_rpc_obsigate(appels))
+    tid = _transcript_avec_resume()
+    approval = meeting_archive.demander_approbation(tid, 1)
+    # Sans connecteur : erreur propre, pas d'exception.
+    out = asyncio.run(meeting_archive.executer(approval))
+    assert out["status"] == "erreur"

tests/test_recherche.py

@@ -0,0 +1,73 @@
+"""Tests de la recherche fédérée Flowdeck (fusion #68).
+
+Fonctions pures de app/middleware/recherche_cors.py uniquement :
+aucune base, aucun serveur.
+"""
+
+from app.middleware.recherche_cors import (
+    cors_headers_for,
+    is_dev_host,
+    is_prod_host,
+    origin_of,
+    preflight_headers,
+    sister_origins,
+)
+
+RESOLVED_DEV = {
+    "obsigate": "https://og-dev.dracodev.net/",
+    "flowdeck": "https://flowdeck-dev.dracodev.net",
+    "tiktak": "https://tiktak-dev.dracodev.net/",
+    "kanbante": "https://kanbante-dev.dracodev.net/",
+    "agent": "https://agent-dev.dracodev.net/",
+    "gitea": "https://git.dracodev.net/",
+}
+
+
+def test_is_dev_host():
+    assert is_dev_host("flowdeck-dev.dracodev.net") is True
+    assert is_dev_host("flowdeck.dracodev.net") is False
+    assert is_dev_host("x-dev.dracodev.net.evil") is False
+    assert is_dev_host("flowdeck-dev.dracodev.net:8443") is True
+    assert is_prod_host("flowdeck.dracodev.net") is True
+    assert is_prod_host("flowdeck-dev.dracodev.net") is False
+
+
+def test_origin_of():
+    assert origin_of("https://og-dev.dracodev.net/") == "https://og-dev.dracodev.net"
+    assert origin_of("{{URL_OBSIGATE}}") is None
+
+
+def test_sister_origins_dev():
+    assert sister_origins(RESOLVED_DEV) == {
+        "https://og-dev.dracodev.net",
+        "https://flowdeck-dev.dracodev.net",
+        "https://tiktak-dev.dracodev.net",
+        "https://kanbante-dev.dracodev.net",
+    }
+
+
+def test_sister_origins_ajoute_env_de_la_requete():
+    # Configuration muette (hors requête) + hôte dev : les -dev passent.
+    assert "https://og-dev.dracodev.net" in sister_origins(
+        {}, request_host="flowdeck-dev.dracodev.net"
+    )
+    assert "https://og.dracodev.net" in sister_origins(
+        {}, request_host="flowdeck.dracodev.net"
+    )
+    assert "https://og-dev.dracodev.net" not in sister_origins(
+        {}, request_host="flowdeck.dracodev.net"
+    )
+
+
+def test_cors_headers():
+    headers = cors_headers_for("https://og-dev.dracodev.net", RESOLVED_DEV)
+    assert headers["Access-Control-Allow-Origin"] == "https://og-dev.dracodev.net"
+    assert headers["Access-Control-Allow-Credentials"] == "true"
+    assert cors_headers_for("https://evil.example", RESOLVED_DEV) is None
+    assert cors_headers_for("https://og.dracodev.net", RESOLVED_DEV) is None
+
+
+def test_preflight_headers():
+    headers = preflight_headers("https://kanbante-dev.dracodev.net", RESOLVED_DEV)
+    assert headers["Access-Control-Allow-Methods"] == "GET, OPTIONS"
+    assert preflight_headers("https://evil.example", RESOLVED_DEV) is None