Chantier 5 (fusion #69/#71) : alertes en onglets + onglet Console Spark : tests mjs 17

CHANGELOG.md

@@ -6,7 +6,7 @@ Format basé sur [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/),
 et [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 > **En cours de développement** : les changements à venir sont listés dans la section
-> [Unreleased](#unreleased). La dernière version livrée est **2.81.3**.
+> [Unreleased](#unreleased). La dernière version livrée est **2.81.4**.
 
 ---
 
@@ -14,6 +14,14 @@ et [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [2.81.4] — 2026-10-28
+
+### Modifié
+
+- **Barre (#70)** : bouton « ••• » retiré (menu par défaut supprimé), « Console Spark » ajoutée au menu de la marque, fermeture/focus corrigés.
+- **Alertes unifiées (#69)** : panneau actives puis historique, par application, avec pastille ; agrégation à la demande, pas une fédération temps réel ; CSP connect-src sœurs.
+- **Rechercher partout (#68)** : page `/recherche` unifiée par application, liens profonds dans l'environnement courant (dérivation `-dev` respectée), CORS bornée à `/api/search` ; la palette de la barre ouvre désormais `/recherche`.
+
 ## [2.81.3] — 2026-10-28
 
 ### Modifié

VERSION

@@ -1 +1 @@
-2.81.3
+2.81.4

backend/main.py

@@ -531,6 +531,15 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Recherche partout (#68) : CORS bornée pour GET /api/search — ajoutée
+# après le CORSMiddleware global donc exécutée avant lui (dernier
+# ajouté = le plus externe) : les preflights OPTIONS sont répondus
+# ici, et les réponses de /api/search reçoivent les en-têtes sœurs.
+# La politique same-origin explicite du middleware global reste la
+# règle par défaut pour tout le reste.
+from backend.recherche_cors import RechercheCorsMiddleware
+
+app.add_middleware(RechercheCorsMiddleware)
 # Auth router
 # Multi-format export (HTML / MD bundle / ePub) — voir backend.routers.files_media (#85 T6c).
 from backend.ai_routes import router as ai_router
@@ -950,6 +959,71 @@ if FRONTEND_DIR.exists():
             return HTMLResponse(content=_html_with_nonce(request, "admin.html"), headers={"Cache-Control": "no-cache"})
         raise HTTPException(status_code=404, detail="Admin page not found")
 
+    @app.get("/recherche", response_class=HTMLResponse)
+    async def serve_recherche_page(request: Request):
+        """Page « Rechercher partout » (fusion #68) — déclarée AVANT le
+        catch-all SPA comme /admin.html, sinon index.html serait servi.
+
+        frontend/recherche.html est servi avec les jetons {{URL_*}}
+        remplacés par urls_publiques() (même contrat que le fragment
+        de barre) et le nonce CSP frais ; la réponse pose sa propre
+        CSP (préservée par SecurityHeadersMiddleware, qui ne la pose
+        que si elle est absente) dont le connect-src autorise les
+        origines sœurs — sinon le navigateur bloquerait les appels
+        sœurs avant même CORS. La CSP par défaut (same-origin) reste
+        inchangée pour toutes les autres pages.
+        """
+        import json as _json
+
+        from backend.csp import inject_csp_nonce
+        from backend.draco_config import urls_publiques
+        from backend.recherche_cors import origin_of
+
+        recherche_file = FRONTEND_DIR / "recherche.html"
+        if not recherche_file.exists():
+            raise HTTPException(status_code=404, detail="Recherche page not found")
+        html = recherche_file.read_text(encoding="utf-8")
+        urls = urls_publiques()
+        for jeton, cle in (
+            ("{{URL_OBSIGATE}}", "obsigate"),
+            ("{{URL_FLOWDECK}}", "flowdeck"),
+            ("{{URL_TIKTAK}}", "tiktak"),
+            ("{{URL_KANBANTE}}", "kanbante"),
+        ):
+            html = html.replace(jeton, urls.get(cle, ""))
+        script = (
+            "<script>window.DRACO_URLS = "
+            + _json.dumps(urls).replace("<", "\\u003c")
+            + ";</script>"
+        )
+        if "</head>" in html:
+            html = html.replace("</head>", script + "</head>", 1)
+        else:
+            html = script + html
+        html = inject_csp_nonce(html, request.state.csp_nonce)
+        soeurs = " ".join(sorted({
+            origin_of(urls.get(cle, "")) or ""
+            for cle in ("obsigate", "flowdeck", "tiktak", "kanbante")
+        } - {""}))
+        csp = (
+            "default-src 'self'; "
+            f"script-src 'self' 'nonce-{request.state.csp_nonce}'; "
+            "style-src 'self' 'unsafe-inline'; "
+            "img-src 'self' data:; "
+            f"connect-src 'self' {soeurs}; "
+            "font-src 'self' data:; "
+            "worker-src 'self' blob:; "
+            "frame-src 'self'; "
+            "object-src 'none'; "
+            "base-uri 'self'; "
+            "form-action 'self'; "
+            "frame-ancestors 'self';"
+        )
+        return HTMLResponse(
+            content=html,
+            headers={"Cache-Control": "no-cache", "Content-Security-Policy": csp},
+        )
+
     @app.get("/{full_path:path}")
     async def serve_spa(request: Request, full_path: str):
         """Serve the SPA index.html for all non-API routes."""

backend/recherche_cors.py

@@ -0,0 +1,189 @@
+"""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 de ``backend.draco_config``
+  (``urls_publiques()`` : explicite > dérivation par l'hôte de
+  l'agent > défaut officiel), **plus** les origines prod ou ``-dev``
+  officielles correspondant à l'hôte de la requête — ce second
+  ensemble couvre le cas où la configuration seule ne déclare pas
+  l'environnement courant ;
+- avec credentials (le cookie SSO ``draco_session``, accepté par
+  ``/api/search`` via le repli de ``backend.auth.middleware``, ou
+  le cookie natif ``access_token``).
+
+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 same-origin explicite du CORSMiddleware
+global (``allow_origins=[]``), qui reste la règle par défaut.
+"""
+
+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_config.urls_publiques() 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 frontend/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 ``urls_publiques()``.
+    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 backend.draco_config import urls_publiques
+
+            resolved = urls_publiques()
+        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)

desktop/Cargo.lock

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

desktop/Cargo.toml

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

desktop/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/nicedoc/obsigate/main/desktop/tauri.conf.schema.json",
   "productName": "ObsiGate",
-  "version": "2.81.3",
+  "version": "2.81.4",
   "identifier": "com.obsigate.desktop",
   "build": {
     "frontendDist": "../frontend",

docs/ROADMAP.md

@@ -1,6 +1,6 @@
 # ObsiGate — Roadmap
 
-> **Version :** 2.81.3 | **Dernière mise à jour :** 2026-10-28
+> **Version :** 2.81.4 | **Dernière mise à jour :** 2026-10-28
 > **Ce fichier ne contient que le travail à venir** (🔵 En cours + ⚪ Backlog) et un index compact
 > vers les fonctionnalités livrées.
 > - **Méthode de livraison à appliquer pour toute tâche : [DELIVERY_WORKFLOW.md](./DELIVERY_WORKFLOW.md)**

frontend/draco-alertes.css

@@ -37,3 +37,22 @@
 .draco-alertes-meta { font-size: 11.5px; color: var(--text-tertiary, #777); margin-top: 4px; }
 .draco-alertes-empty { font-size: 13px; color: var(--text-dim, #999); padding: 6px 0; }
 .draco-alertes-empty a { color: inherit; }
+/* Chantier 5 — onglets + filtre (mêmes variables d'hôte, mêmes replis). */
+.draco-alertes-tabs { display: flex; flex-wrap: wrap; gap: 6px; margin: 2px 0 12px; }
+.draco-alertes-tab {
+  border: 1px solid var(--border, #333); background: transparent;
+  color: inherit; border-radius: 999px; padding: 5px 11px;
+  cursor: pointer; font-size: 13px; line-height: 1.3;
+}
+.draco-alertes-tab[aria-selected="true"] { background: #e8762c; border-color: #e8762c; color: #fff; }
+.draco-alertes-tab:focus-visible { outline: 2px solid #e8762c; outline-offset: 2px; }
+.draco-alertes-filtre { display: flex; gap: 8px; align-items: center; margin: 0 0 4px; }
+.draco-alertes-filtre label { font-size: 13px; color: var(--text-dim, #999); }
+.draco-alertes-filtre input {
+  flex: 1; min-width: 0; background: transparent; color: inherit;
+  border: 1px solid var(--border, #333); border-radius: 8px; padding: 6px 10px;
+  font-size: 13px;
+}
+.draco-alertes-compte { font-size: 12.5px; color: var(--text-dim, #999); margin: 4px 0 10px; min-height: 1em; }
+.draco-alertes-compte:empty { display: none; }
+.draco-alertes-item.is-error { border-color: #c2437e; }

frontend/draco-alertes.js

@@ -1,14 +1,25 @@
-/* Alertes unifiées dracodev — Fusion #69 (chantier 2).
+/* Alertes unifiées dracodev — Fusion #69 (chantier 2) + chantier 5
+ * (onglets + composant partagé + onglet Console Spark).
+ *
+ * SOURCE CANONIQUE : Projets/dracodev-commons, ui/alertes/. Les copies
+ * dans les 4 hôtes (TikTak, Kanbante, Flowdeck, ObsiGate) sont des
+ * vendoring byte-identiques de ce fichier — ne pas les modifier sur
+ * place, toute évolution passe par commons puis re-vendoring.
  *
  * Agrégation À LA DEMANDE, pas une fédération temps réel : à chaque
  * ouverture du panneau (et au chargement, pour la pastille), le module
  * interroge les API de notifications réellement exposées par chaque
  * application, avec les identifiants du navigateur (credentials:
  * "include"). Aucune alerte n'est inventée : une source injoignable
- * ou non authentifiée affiche son état réel (« Connexion requise »)
- * avec un lien profond vers sa page native, jamais du vide déguisé.
+ * ou non authentifiée affiche son état réel par section (une section
+ * en échec n'empêche jamais de consulter les autres), jamais du vide
+ * déguisé. En attendant le correctif CORS des allowlists (autre
+ * chantier), une section inter-origines peut afficher cet état
+ * d'erreur : c'est un état d'erreur transitoire, pas un comportement
+ * normal — aucun état « Injoignable » systématique n'est présenté
+ * comme normal.
  *
- * Sources réelles (audit #69, 2026-10-28) :
+ * Sources réelles (audit #69, 2026-10-28, inchangé) :
  *   - Flowdeck : GET {base}/api/notifications?limit=50
  *     -> { notifications: [{id, ntype, title, message, url, is_read,
  *     created_at}], unread } ; active = is_read = 0 ; lien = base + url.
@@ -23,20 +34,55 @@
  *     est compté comme actif ; lien = base + "/board/" + repo.
  *   - ObsiGate : AUCUNE notification entrante consultable. Ses
  *     /api/notify/* sont des canaux d'envoi sortants (admin, secrets
- *     masqués), pas un journal lisible par l'utilisateur. La section
+ *     masqués), pas un journal lisible par l'utilisateur. L'onglet
  *     ObsiGate le dit et renvoie vers l'accueil d'ObsiGate.
+ *   - Console Spark : AUCUN endpoint d'alertes console n'est publié
+ *     sur agent-commun main au moment de ce chantier (autre chantier
+ *     en cours). L'onglet Console Spark affiche donc un état vide
+ *     HONNÊTE (« source indisponible », lien vers la console) et ne
+ *     fabrique aucune alerte. Branchement prévu, sans deviner d'URL :
+ *     poser window.DRACO_ALERTES_CONSOLE_URL (ou
+ *     DRACO_BAR_CONFIG.consoleAlertsUrl) vers l'endpoint livré par
+ *     l'autre chantier ; forme attendue : tableau, ou
+ *     {alerts:[...]} / {items:[...]}, chaque alerte portant title,
+ *     detail|message|context, date|created_at, active (booléen) ou
+ *     status/state (pause budget, accès requis, en attente, fermée…),
+ *     url|link. Les missions en pause budget / accès requis et les
+ *     approbations en attente y apparaîtront avec leurs états réels.
  *
  * Résolution des bases (même ordre que barre-apps v0.1.6) :
  *   1. window.DRACO_BAR.urls déjà résolue par la barre, sinon
  *      window.DRACO_BAR_CONFIG.urls (config explicite de l'hôte) ;
  *   2. dérivation -dev par l'hôte courant (hôte -dev dracodev.net) ;
- *   3. href rendu de l'onglet .draco-apptab[data-app] ;
+ *   3. href rendu de l'onglet .draco-apptab[data-app] (l'onglet
+ *      « Console Spark » ajouté par le chantier 5 porte data-app
+ *      "agent", donc la base agent suit le même ordre) ;
  *   4. défaut officiel (production).
  * ObsiGate n'a pas de .draco-apptab dans tous les cas : l'étape 3 y
- * lit aussi window.DRACO_URLS (injecté par son backend).
+ * lit aussi window.DRACO_URLS (injecté par son backend, clé "agent"
+ * incluse).
  * Aucun nom en -dev n'est un défaut : la dérivée -dev ne s'applique
  * que sur un hôte -dev, exactement comme la barre.
  *
+ * Présentation (identique partout, imposée par ce seul fichier) :
+ *   champs par alerte = application, titre, date, état, lien profond
+ *   (environnement -dev respecté via la résolution ci-dessus) ;
+ *   ordre = date décroissante dans chaque onglet (sans date en
+ *   dernier) ; format de date = toLocaleString("fr-FR"), « sans date »
+ *   si absente ou illisible ; libellés d'état affichés = « Active »,
+ *   « Lue », ou le libellé d'événement Kanbante (ex. « Fermée »),
+ *   ou l'état réel console quand la source existe. Le type brut
+ *   Kanbante (« moved »…) n'est plus affiché : il dupliquait le
+ *   libellé d'état en anglais.
+ *   Onglets : Tout, ObsiGate, Flowdeck, TikTak, Kanbante,
+ *   Console Spark, Historique — dans cet ordre. Tout et chaque onglet
+ *   par application ne montrent QUE les alertes actives ; Historique
+ *   ne montre QUE les alertes fermées (lues / événements Kanbante /
+ *   console fermées). Le filtre texte (titre + contexte) s'applique
+ *   APRÈS le périmètre de l'onglet courant : il ne mélange jamais
+ *   actifs et historique. L'onglet courant est dans l'URL
+ *   (#alertes=<onglet>, partageable, retour arrière via pushState).
+ *
  * Le fichier ne touche à AUCUN fichier ui/barre-apps.* : il consomme
  * seulement l'action "alertes" relayée par l'hôte et DRACO_BAR.setCounts
  * pour la pastille (repli : mise à jour directe du badge).
@@ -50,23 +96,39 @@
     obsigate: "https://og.dracodev.net/",
     flowdeck: "https://flowdeck.dracodev.net/",
     tiktak: "https://tiktak.dracodev.net/",
-    kanbante: "https://kanbante.dracodev.net/"
+    kanbante: "https://kanbante.dracodev.net/",
+    agent: "https://agent.dracodev.net/"
   };
   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/"
+    kanbante: "https://kanbante-dev.dracodev.net/",
+    agent: "https://agent-dev.dracodev.net/"
   };
   var APP_LABELS = {
     obsigate: "ObsiGate", flowdeck: "Flowdeck",
-    tiktak: "TikTak", kanbante: "Kanbante"
+    tiktak: "TikTak", kanbante: "Kanbante", console: "Console Spark"
   };
   var APP_ORDER = ["obsigate", "flowdeck", "tiktak", "kanbante"];
+  var ALL_APPS = ["obsigate", "flowdeck", "tiktak", "kanbante", "console"];
+  var TABS = ["tout", "obsigate", "flowdeck", "tiktak", "kanbante", "console", "historique"];
+  var TAB_LABELS = {
+    tout: "Tout", obsigate: "ObsiGate", flowdeck: "Flowdeck",
+    tiktak: "TikTak", kanbante: "Kanbante",
+    console: "Console Spark", historique: "Historique"
+  };
   var EVENT_LABELS = {
     created: "créée", moved: "déplacée", closed: "fermée",
     reopened: "rouverte", commented: "commentée"
   };
+  var CONSOLE_ACTIVE_STATUSES = [
+    "active", "pending", "pause", "pause_budget", "acces_requis",
+    "en_attente", "en attente", "requise", "awaiting"
+  ];
+  var CONSOLE_CLOSED_STATUSES = [
+    "closed", "resolved", "resolue", "lue", "terminee", "done", "fermee"
+  ];
 
   function isDevHost(hostname) {
     if (!hostname) return false;
@@ -98,12 +160,16 @@
   }
   function fmtDate(s) {
     var t = parseDate(s);
-    if (!t) return s ? String(s).slice(0, 16) : "";
+    if (!t) return "";
     try { return t.toLocaleString("fr-FR"); } catch (e) { return t.toISOString().slice(0, 16); }
   }
+  function capitalize(s) {
+    s = String(s || "");
+    return s ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+  }
 
   /* Résolution des bases. `env` permet les tests sans navigateur :
-   * { hostname, barUrls, configUrls, tabHrefs, dracoUrls }. */
+   * { hostname, barUrls, configUrls, tabHrefs, dracoUrls, consoleUrl }. */
   function resolveUrls(env) {
     env = env || {};
     var hostname = env.hostname;
@@ -112,28 +178,31 @@
     }
     var dev = isDevHost(hostname);
     var urls = {};
-    APP_ORDER.forEach(function (app) {
-      var u = cleanUrl(env.barUrls && env.barUrls[app])
-        || cleanUrl(env.configUrls && env.configUrls[app]);
+    ALL_APPS.forEach(function (key) {
+      var app = key === "console" ? "agent" : key;
+      var out = key === "console" ? "agent" : key;
+      var u = cleanUrl(env.barUrls && (env.barUrls[key] || env.barUrls[app]))
+        || cleanUrl(env.configUrls && (env.configUrls[key] || env.configUrls[app]));
       if (!u && dev) u = DEV_URLS[app] || null;
       if (!u) {
         var href = null;
-        if (env.tabHrefs && env.tabHrefs[app]) href = env.tabHrefs[app];
+        if (env.tabHrefs && (env.tabHrefs[key] || env.tabHrefs[app])) href = env.tabHrefs[key] || env.tabHrefs[app];
         else if (typeof document !== "undefined" && document.querySelector) {
           var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
           href = tab ? tab.getAttribute("href") : null;
         }
         u = cleanUrl(href);
       }
-      if (!u && env.dracoUrls && env.dracoUrls[app]) u = cleanUrl(env.dracoUrls[app]);
+      if (!u && env.dracoUrls && (env.dracoUrls[key] || env.dracoUrls[app])) u = cleanUrl(env.dracoUrls[key] || env.dracoUrls[app]);
       if (!u) {
         /* ObsiGate : window.DRACO_URLS injecté par le backend. */
         try {
-          if (global.DRACO_URLS && global.DRACO_URLS[app]) u = cleanUrl(global.DRACO_URLS[app]);
+          if (global.DRACO_URLS && (global.DRACO_URLS[key] || global.DRACO_URLS[app])) u = cleanUrl(global.DRACO_URLS[key] || global.DRACO_URLS[app]);
         } catch (e) { /* rien */ }
       }
       if (!u) u = DEFAULT_URLS[app];
-      urls[app] = withSlash(u);
+      urls[out] = withSlash(u);
+      if (key === "console") urls.console = withSlash(u);
     });
     return urls;
   }
@@ -151,9 +220,23 @@
     } catch (e) { /* rien */ }
     return {
       barUrls: bar.urls || null, configUrls: cfg.urls || null,
-      tabHrefs: tabs, dracoUrls: global.DRACO_URLS || null
+      tabHrefs: tabs, dracoUrls: global.DRACO_URLS || null,
+      consoleUrl: null
     };
   }
+  /* URL de la source console, si l'hôte l'a configurée. AUCUNE URL
+   * n'est devinée : sans configuration, la source est indisponible
+   * (état vide honnête, voir renderCurrent). */
+  function consoleSourceUrl(env) {
+    env = env || {};
+    if (env.consoleUrl) return env.consoleUrl;
+    try {
+      if (global.DRACO_ALERTES_CONSOLE_URL) return global.DRACO_ALERTES_CONSOLE_URL;
+      var cfg = global.DRACO_BAR_CONFIG || {};
+      if (cfg.consoleAlertsUrl) return cfg.consoleAlertsUrl;
+    } catch (e) { /* rien */ }
+    return null;
+  }
 
   function normalizeFlowdeck(base, payload) {
     var list = (payload && payload.notifications) || [];
@@ -192,7 +275,48 @@
       };
     });
   }
-  /* Actives d'abord, puis date décroissante (sans date en dernier). */
+  function normalizeConsole(base, payload) {
+    var list = Array.isArray(payload) ? payload
+      : (payload && (payload.alerts || payload.items)) || [];
+    return list.map(function (n) {
+      var status = String(n.status || "").toLowerCase().replace(/_/g, " ").trim();
+      var stateRaw = String(n.state || status || "");
+      var active;
+      if (typeof n.active === "boolean") active = n.active;
+      else if (status && CONSOLE_ACTIVE_STATUSES.indexOf(status.replace(/ /g, "_")) !== -1) active = true;
+      else if (status && CONSOLE_CLOSED_STATUSES.indexOf(status.replace(/ /g, "_")) !== -1) active = false;
+      else if (/pause|acc[eè]s|attente/.test(stateRaw.toLowerCase())) active = true;
+      else if (/ferm|résol|resol|termin/.test(stateRaw.toLowerCase())) active = false;
+      else active = true; /* source réelle, statut inconnu : on l'expose en active */
+      return {
+        app: "console", id: n.id, title: n.title || "(sans titre)",
+        detail: n.detail || n.message || n.context || "", date: n.date || n.created_at || "",
+        active: active, state: stateRaw || (active ? "en attente" : "fermée"),
+        kind: n.kind || n.type || "",
+        url: n.url || n.link ? joinUrl(base, n.url || n.link) : withSlash(base)
+      };
+    });
+  }
+  /* Libellé d'état AFFICHÉ, uniforme partout (les valeurs brutes de
+   * normalize* sont inchangées, pour compatibilité des tests #69). */
+  function displayState(a) {
+    if (a.active) return "Active";
+    if (a.app === "kanbante") return capitalize(a.state);
+    if (a.app === "console") return capitalize(a.state);
+    return "Lue";
+  }
+  function metaLine(a) {
+    var date = fmtDate(a.date) || "sans date";
+    /* Kanbante : le type brut (« moved ») dupliquait le libellé
+     * d'état ; il n'est plus affiché. Les autres apps gardent leur
+     * type quand il apporte une information. */
+    if (a.app === "kanbante") return APP_LABELS[a.app] + " · " + date + " · " + displayState(a);
+    var kind = a.kind ? " · " + a.kind : "";
+    return APP_LABELS[a.app] + kind + " · " + date + " · " + displayState(a);
+  }
+  /* Actives d'abord, puis date décroissante (sans date en dernier).
+   * Dans un onglet, le périmètre est déjà homogène (que des actives
+   * ou que des fermées) : l'ordre effectif est donc la date décroissante. */
   function sortAlerts(list) {
     return list.slice().sort(function (a, b) {
       if (a.active !== b.active) return a.active ? -1 : 1;
@@ -208,9 +332,74 @@
     list.forEach(function (a) { if (a.active) n++; });
     return n;
   }
+  function allItems(results) {
+    var all = [];
+    ALL_APPS.forEach(function (app) {
+      (results[app] && results[app].items || []).forEach(function (a) { all.push(a); });
+    });
+    return all;
+  }
+  /* Périmètre d'un onglet. Retour : { items, errors, consoleMissing }.
+   * Tout et onglets par application = actives seulement ; Historique =
+   * fermées seulement. Les erreurs de section sont remontées dans
+   * chaque onglet concerné (jamais silencieusement avalées). */
+  function scopeAlerts(all, tab, results) {
+    results = results || {};
+    var items = [], errors = [];
+    function collect(app, pred) {
+      if (results[app] && results[app].error) errors.push({ app: app, error: results[app].error });
+      all.forEach(function (a) { if (a.app === app && pred(a)) items.push(a); });
+    }
+    if (tab === "historique") {
+      ALL_APPS.forEach(function (app) { collect(app, function (a) { return !a.active; }); });
+    } else if (tab === "tout") {
+      ALL_APPS.forEach(function (app) { collect(app, function (a) { return a.active; }); });
+    } else if (ALL_APPS.indexOf(tab) !== -1) {
+      collect(tab, function (a) { return a.active; });
+    } else {
+      ALL_APPS.forEach(function (app) { collect(app, function (a) { return a.active; }); });
+    }
+    return {
+      items: sortAlerts(items), errors: errors,
+      consoleMissing: !!(results.console && results.console.sourceMissing)
+    };
+  }
+  function countByTab(all, results) {
+    var counts = {};
+    TABS.forEach(function (tab) { counts[tab] = scopeAlerts(all, tab, results).items.length; });
+    return counts;
+  }
+  /* Filtre texte, appliqué APRÈS le périmètre de l'onglet : titre ou
+   * contexte, insensible à la casse, sans jamais mélanger actifs et
+   * historique (le périmètre est déjà fixé par scopeAlerts). */
+  function filterAlerts(list, q) {
+    q = String(q || "").trim().toLowerCase();
+    if (!q) return list.slice();
+    return list.filter(function (a) {
+      return (String(a.title || "").toLowerCase().indexOf(q) !== -1)
+        || (String(a.detail || "").toLowerCase().indexOf(q) !== -1);
+    });
+  }
+  /* Onglet depuis le hash d'URL : "#alertes=historique" -> "historique",
+   * "#alertes" -> "tout", autre -> null. */
+  function parseAlertTab(hash) {
+    if (!hash) return null;
+    var h = String(hash).replace(/^#/, "");
+    if (h === "alertes") return "tout";
+    var m = /^alertes=([a-z]+)$/.exec(h);
+    if (m && TABS.indexOf(m[1]) !== -1) return m[1];
+    return null;
+  }
+  function hashForTab(tab) {
+    if (TABS.indexOf(tab) === -1) tab = "tout";
+    return "#alertes=" + tab;
+  }
 
   /* ---- Rendu (navigateur seulement) ---- */
-  var panel = null, listEl = null, badgeTimer = null;
+  var panel = null, listEl = null, tabsEl = null, filterEl = null,
+    countEl = null, badgeTimer = null;
+  var currentTab = "tout", currentData = null, currentFilter = "";
+  var panelPushed = false, closingViaBack = false, suppressHash = false;
 
   function el(tag, cls, text) {
     var d = document.createElement(tag);
@@ -226,96 +415,204 @@
     var box = el("div", "draco-alertes-box");
     var head = el("div", "draco-alertes-head");
     head.appendChild(el("h2", "", "Alertes unifiées"));
-    var note = el("p", "draco-alertes-note",
-      "Agrégation à la demande, pas une fédération temps réel : " +
-      "les alertes sont relues dans chaque application à l'ouverture.");
     var close = el("button", "draco-alertes-close", "✕");
     close.setAttribute("aria-label", "Fermer");
-    close.addEventListener("click", closePanel);
+    close.addEventListener("click", function () { closePanel(); });
     head.appendChild(close);
     box.appendChild(head);
-    box.appendChild(note);
+    box.appendChild(el("p", "draco-alertes-note",
+      "Agrégation à la demande, pas une fédération temps réel : " +
+      "les alertes sont relues dans chaque application à l'ouverture. " +
+      "Une section en échec n'empêche pas de consulter les autres."));
+    tabsEl = el("div", "draco-alertes-tabs");
+    tabsEl.setAttribute("role", "tablist");
+    tabsEl.setAttribute("aria-label", "Alertes par application");
+    tabsEl.addEventListener("keydown", onTabsKeydown);
+    box.appendChild(tabsEl);
+    var filtre = el("div", "draco-alertes-filtre");
+    var lbl = el("label", "", "Filtrer");
+    lbl.setAttribute("for", "draco-alertes-filtre-input");
+    filtre.appendChild(lbl);
+    filterEl = el("input", "");
+    filterEl.type = "search";
+    filterEl.id = "draco-alertes-filtre-input";
+    filterEl.setAttribute("placeholder", "Filtrer par titre ou contexte, dans cet onglet…");
+    filterEl.setAttribute("aria-label", "Filtrer les alertes de l'onglet courant");
+    filterEl.addEventListener("input", function () {
+      currentFilter = filterEl.value;
+      renderCurrent();
+    });
+    filtre.appendChild(filterEl);
+    box.appendChild(filtre);
+    countEl = el("p", "draco-alertes-compte", "");
+    box.appendChild(countEl);
     listEl = el("div", "draco-alertes-list");
+    listEl.setAttribute("role", "tabpanel");
     box.appendChild(listEl);
     ov.appendChild(box);
     ov.addEventListener("click", function (ev) { if (ev.target === ov) closePanel(); });
     document.addEventListener("keydown", function (ev) {
-      if (ev.key === "Escape") closePanel();
+      if (ev.key === "Escape" && panel && panel.style.display !== "none") closePanel();
     });
     document.body.appendChild(ov);
     panel = ov;
     return ov;
   }
-  function closePanel() { if (panel) panel.style.display = "none"; }
-
-  function renderSection(title, items, fallback) {
-    var sec = el("section", "draco-alertes-section");
-    sec.appendChild(el("h3", "", title + " (" + items.length + ")"));
-    if (!items.length) {
-      sec.appendChild(el("p", "draco-alertes-empty", fallback));
-      return sec;
+  function closePanel() {
+    if (!panel) return;
+    panel.style.display = "none";
+    if (panelPushed) {
+      panelPushed = false;
+      closingViaBack = true;
+      try { history.back(); } catch (e) { closingViaBack = false; }
+      return;
     }
-    items.forEach(function (a) {
-      var row = el("div", "draco-alertes-item" + (a.active ? " is-active" : ""));
-      var main = el("div", "draco-alertes-main");
-      var link = el("a", "draco-alertes-title", a.title);
-      link.href = a.url;
-      main.appendChild(link);
-      if (a.detail) main.appendChild(el("div", "draco-alertes-detail", a.detail));
-      var meta = el("div", "draco-alertes-meta",
-        APP_LABELS[a.app] + (a.kind ? " · " + a.kind : "") +
-        " · " + (a.date ? fmtDate(a.date) : "sans date") + " · " + a.state);
-      main.appendChild(meta);
-      row.appendChild(main);
-      sec.appendChild(row);
-    });
-    return sec;
+    try {
+      var h = parseAlertTab(window.location.hash);
+      if (h) {
+        suppressHash = true;
+        history.replaceState(null, "", window.location.pathname + window.location.search);
+        suppressHash = false;
+      }
+    } catch (e) { /* rien */ }
   }
-  function render(results, urls) {
-    ensurePanel();
-    listEl.textContent = "";
-    var all = [];
-    APP_ORDER.forEach(function (app) {
-      (results[app] && results[app].items || []).forEach(function (a) { all.push(a); });
-    });
-    var actives = sortAlerts(all.filter(function (a) { return a.active; }));
-    var history = sortAlerts(all.filter(function (a) { return !a.active; }));
-    listEl.appendChild(el("h3", "draco-alertes-group", "Alertes actives"));
-    APP_ORDER.forEach(function (app) {
-      var items = actives.filter(function (a) { return a.app === app; });
-      if (results[app] && results[app].error) {
-        var sec = renderSection(APP_LABELS[app], [], results[app].error);
-        listEl.appendChild(sec);
-      } else if (app === "obsigate") {
-        listEl.appendChild(renderSection(APP_LABELS[app], [],
-          "ObsiGate n'expose aucune notification entrante consultable " +
-          "(ses canaux /api/notify sont des envois sortants, réservés aux administrateurs)."));
-      } else if (items.length) {
-        listEl.appendChild(renderSection(APP_LABELS[app], items, ""));
-      }
-    });
-    if (!actives.length) {
-      listEl.appendChild(el("p", "draco-alertes-empty", "Aucune alerte active dans les applications joignables."));
+  function onHashChange() {
+    if (suppressHash) return;
+    if (closingViaBack) { closingViaBack = false; return; }
+    var tab = parseAlertTab(window.location.hash);
+    if (tab) {
+      if (!panel || panel.style.display === "none") openPanel(tab);
+      else setTab(tab, false);
+    } else if (panel && panel.style.display !== "none") {
+      panelPushed = false;
+      panel.style.display = "none";
     }
-    listEl.appendChild(el("h3", "draco-alertes-group", "Historique"));
-    APP_ORDER.forEach(function (app) {
-      if (results[app] && results[app].error) return; /* déjà signalé ci-dessus */
-      if (app === "obsigate") {
-        var link = el("div", "draco-alertes-empty");
-        var a = el("a", "", "Ouvrir ObsiGate");
-        a.href = urls.obsigate;
-        link.appendChild(a);
-        var sec = el("section", "draco-alertes-section");
-        sec.appendChild(el("h3", "", "ObsiGate (0)"));
-        sec.appendChild(link);
-        listEl.appendChild(sec);
-        return;
-      }
-      var items = history.filter(function (x) { return x.app === app; });
-      listEl.appendChild(renderSection(APP_LABELS[app], items,
-        "Aucun historique disponible pour cette application."));
+  }
+  function onTabsKeydown(ev) {
+    var keys = ["ArrowLeft", "ArrowRight", "Home", "End"];
+    if (keys.indexOf(ev.key) === -1) return;
+    var btns = tabsEl.querySelectorAll(".draco-alertes-tab");
+    var idx = TABS.indexOf(currentTab);
+    if (ev.key === "ArrowLeft") idx = (idx + TABS.length - 1) % TABS.length;
+    else if (ev.key === "ArrowRight") idx = (idx + 1) % TABS.length;
+    else if (ev.key === "Home") idx = 0;
+    else if (ev.key === "End") idx = TABS.length - 1;
+    ev.preventDefault();
+    setTab(TABS[idx], true);
+    if (btns[idx] && btns[idx].focus) btns[idx].focus();
+  }
+  function renderTabs() {
+    if (!tabsEl || !currentData) return;
+    tabsEl.textContent = "";
+    var all = allItems(currentData.results);
+    var counts = countByTab(all, currentData.results);
+    TABS.forEach(function (tab) {
+      var b = el("button", "draco-alertes-tab",
+        TAB_LABELS[tab] + " (" + counts[tab] + ")");
+      b.type = "button";
+      b.setAttribute("role", "tab");
+      b.setAttribute("aria-selected", tab === currentTab ? "true" : "false");
+      b.tabIndex = tab === currentTab ? 0 : -1;
+      b.addEventListener("click", function () { setTab(tab, true); });
+      tabsEl.appendChild(b);
     });
   }
+  function renderRow(a) {
+    var row = el("div", "draco-alertes-item" + (a.active ? " is-active" : ""));
+    var main = el("div", "draco-alertes-main");
+    var link = el("a", "draco-alertes-title", a.title);
+    link.href = a.url;
+    main.appendChild(link);
+    if (a.detail) main.appendChild(el("div", "draco-alertes-detail", a.detail));
+    main.appendChild(el("div", "draco-alertes-meta", metaLine(a)));
+    row.appendChild(main);
+    return row;
+  }
+  function renderErrorRow(app, msg) {
+    var row = el("div", "draco-alertes-item is-error");
+    var main = el("div", "draco-alertes-main");
+    main.appendChild(el("div", "draco-alertes-title", APP_LABELS[app] + " — section en échec"));
+    main.appendChild(el("div", "draco-alertes-detail", msg));
+    main.appendChild(el("div", "draco-alertes-meta",
+      APP_LABELS[app] + " · section en échec — les autres sections restent consultables"));
+    row.appendChild(main);
+    return row;
+  }
+  function renderCurrent() {
+    if (!listEl || !currentData) return;
+    renderTabs();
+    var scope = scopeAlerts(allItems(currentData.results), currentTab, currentData.results);
+    var filtered = filterAlerts(scope.items, currentFilter);
+    var q = String(currentFilter || "").trim();
+    if (countEl) {
+      countEl.textContent = q
+        ? filtered.length + " résultat(s) sur " + scope.items.length + " dans cet onglet — filtre « " + q + " »"
+        : "";
+    }
+    listEl.textContent = "";
+    /* Onglet Console sans source : état vide honnête, jamais d'alertes
+     * inventées, avec le lien profond vers la console. */
+    if (currentTab === "console" && scope.consoleMissing) {
+      var sec = el("section", "draco-alertes-section");
+      sec.appendChild(el("h3", "", "Console Spark (0)"));
+      sec.appendChild(el("p", "draco-alertes-empty",
+        "Aucune alerte console — source indisponible : l'endpoint " +
+        "d'alertes console (agent-commun, autre chantier) n'est pas " +
+        "encore publié. Les missions en pause budget / accès requis " +
+        "et les approbations en attente apparaîtront ici, avec leurs " +
+        "états réels, dès sa livraison."));
+      var link = el("div", "draco-alertes-empty");
+      var a = el("a", "", "Ouvrir la Console Spark");
+      a.href = currentData.urls.agent || currentData.urls.console || "#";
+      link.appendChild(a);
+      sec.appendChild(link);
+      listEl.appendChild(sec);
+      scope.errors.forEach(function (e) { listEl.appendChild(renderErrorRow(e.app, e.error)); });
+      return;
+    }
+    if (currentTab === "obsigate" && !scope.items.length && !scope.errors.length) {
+      var secOg = el("section", "draco-alertes-section");
+      secOg.appendChild(el("h3", "", "ObsiGate (0)"));
+      secOg.appendChild(el("p", "draco-alertes-empty",
+        "ObsiGate n'expose aucune notification entrante consultable " +
+        "(ses canaux /api/notify sont des envois sortants, réservés aux administrateurs)."));
+      var linkOg = el("div", "draco-alertes-empty");
+      var aOg = el("a", "", "Ouvrir ObsiGate");
+      aOg.href = currentData.urls.obsigate;
+      linkOg.appendChild(aOg);
+      secOg.appendChild(linkOg);
+      listEl.appendChild(secOg);
+      return;
+    }
+    scope.errors.forEach(function (e) { listEl.appendChild(renderErrorRow(e.app, e.error)); });
+    if (!scope.items.length && !scope.errors.length) {
+      var empty = currentTab === "historique"
+        ? "Aucune alerte fermée dans les applications joignables."
+        : currentTab === "tout"
+          ? "Aucune alerte active dans les applications joignables."
+          : "Aucune alerte active pour " + TAB_LABELS[currentTab] + ".";
+      if (currentTab === "console") empty = "Aucune alerte console.";
+      listEl.appendChild(el("p", "draco-alertes-empty", empty));
+      return;
+    }
+    if (q && !filtered.length) {
+      listEl.appendChild(el("p", "draco-alertes-empty",
+        "Aucune alerte dans cet onglet pour ce filtre."));
+      return;
+    }
+    filtered.forEach(function (a) { listEl.appendChild(renderRow(a)); });
+  }
+  function setTab(tab, push) {
+    if (TABS.indexOf(tab) === -1) tab = "tout";
+    currentTab = tab;
+    renderCurrent();
+    if (push) {
+      try {
+        history.pushState(null, "", hashForTab(tab));
+        panelPushed = true;
+      } catch (e) { /* URL partageable : repli silencieux */ }
+    }
+  }
 
   function fetchJson(url, timeoutMs) {
     var ctrl = null, timer = null;
@@ -342,6 +639,7 @@
   }
   function loadAll() {
     var urls = resolveUrls(browserEnv());
+    var consoleUrl = consoleSourceUrl(browserEnv());
     var jobs = {
       flowdeck: fetchJson(urls.flowdeck + "api/notifications?limit=50")
         .then(function (p) { return { items: normalizeFlowdeck(urls.flowdeck, p) }; }),
@@ -350,6 +648,11 @@
       kanbante: fetchJson(urls.kanbante + "api/events?limit=100")
         .then(function (p) { return { items: normalizeKanbante(urls.kanbante, p) }; })
     };
+    if (consoleUrl) {
+      var agentBase = urls.agent || urls.console;
+      jobs.console = fetchJson(consoleUrl)
+        .then(function (p) { return { items: normalizeConsole(agentBase, p) }; });
+    }
     var keys = Object.keys(jobs);
     return Promise.all(keys.map(function (k) {
       return jobs[k].then(function (v) { return [k, v]; }).catch(function (e) {
@@ -361,6 +664,7 @@
     })).then(function (pairs) {
       var results = { obsigate: { items: [] } };
       pairs.forEach(function (kv) { results[kv[0]] = kv[1]; });
+      if (!consoleUrl) results.console = { items: [], sourceMissing: true };
       return { urls: urls, results: results };
     });
   }
@@ -380,28 +684,35 @@
   }
   function refreshBadge() {
     return loadAll().then(function (r) {
-      var all = [];
-      APP_ORDER.forEach(function (app) {
-        (r.results[app] && r.results[app].items || []).forEach(function (a) { all.push(a); });
-      });
-      setBadge(countActive(all));
-      return countActive(all);
+      var n = countActive(allItems(r.results));
+      setBadge(n);
+      return n;
     }).catch(function () { /* pastille optionnelle : la barre vit sans */ });
   }
-  function openPanel() {
+  function openPanel(initialTab) {
     ensurePanel();
     panel.style.display = "flex";
+    var tab = initialTab || parseAlertTab(window.location.hash) || "tout";
+    currentTab = tab;
+    currentFilter = "";
+    if (filterEl) filterEl.value = "";
     listEl.textContent = "";
     listEl.appendChild(el("p", "draco-alertes-empty", "Chargement des alertes…"));
+    if (tabsEl) tabsEl.textContent = "";
     loadAll().then(function (r) {
-      render(r.results, r.urls);
-      var all = [];
-      APP_ORDER.forEach(function (app) {
-        (r.results[app] && r.results[app].items || []).forEach(function (a) { all.push(a); });
-      });
-      setBadge(countActive(all));
+      currentData = r;
+      /* Ouverture par le bouton (pas de hash) : l'onglet entre dans
+       * l'URL pour être partageable ; ouverture par lien partagé : le
+       * hash est déjà le bon, on ne pousse pas d'entrée en double. */
+      var fromHash = parseAlertTab(window.location.hash);
+      if (!fromHash) {
+        try { history.pushState(null, "", hashForTab(tab)); panelPushed = true; } catch (e) { /* rien */ }
+      }
+      renderCurrent();
+      setBadge(countActive(allItems(r.results)));
     }).catch(function () {
-      render({ obsigate: { items: [] } }, resolveUrls(browserEnv()));
+      currentData = { urls: resolveUrls(browserEnv()), results: { obsigate: { items: [] }, console: { items: [], sourceMissing: true } } };
+      renderCurrent();
     });
   }
 
@@ -410,18 +721,29 @@
     _test: {
       resolveUrls: resolveUrls, normalizeFlowdeck: normalizeFlowdeck,
       normalizeTiktak: normalizeTiktak, normalizeKanbante: normalizeKanbante,
+      normalizeConsole: normalizeConsole, consoleSourceUrl: consoleSourceUrl,
       sortAlerts: sortAlerts, countActive: countActive,
-      isDevHost: isDevHost, DEFAULT_URLS: DEFAULT_URLS, DEV_URLS: DEV_URLS
+      filterAlerts: filterAlerts, scopeAlerts: scopeAlerts,
+      countByTab: countByTab, parseAlertTab: parseAlertTab,
+      hashForTab: hashForTab, displayState: displayState,
+      metaLine: metaLine, fmtDate: fmtDate,
+      isDevHost: isDevHost, DEFAULT_URLS: DEFAULT_URLS, DEV_URLS: DEV_URLS,
+      TABS: TABS, TAB_LABELS: TAB_LABELS, APP_LABELS: APP_LABELS
     }
   };
   global.DRACO_ALERTES = api;
   if (typeof module !== "undefined" && module.exports) module.exports = api._test;
 
-  /* Pastille au chargement (après les scripts defer de la barre). */
+  /* Pastille au chargement (après les scripts defer de la barre) ;
+   * un lien partagé #alertes=<onglet> ouvre directement le panneau
+   * sur cet onglet. */
   if (typeof document !== "undefined" && document.addEventListener) {
     document.addEventListener("DOMContentLoaded", function () {
       if (badgeTimer) clearTimeout(badgeTimer);
       badgeTimer = setTimeout(refreshBadge, 300);
+      var tab = parseAlertTab(window.location.hash);
+      if (tab) setTimeout(function () { openPanel(tab); }, 350);
     });
+    window.addEventListener("hashchange", onHashChange);
   }
 })(typeof window !== "undefined" ? window : globalThis);

frontend/draco-barre.css

@@ -192,5 +192,9 @@
   .draco-bar[data-current="obsigate"] .draco-apptab[data-app="obsigate"],
   .draco-bar[data-current="flowdeck"] .draco-apptab[data-app="flowdeck"],
   .draco-bar[data-current="tiktak"] .draco-apptab[data-app="tiktak"],
-  .draco-bar[data-current="kanbante"] .draco-apptab[data-app="kanbante"] { display: flex; }
+  .draco-bar[data-current="kanbante"] .draco-apptab[data-app="kanbante"],
+  /* Chantier 5 : sur la console elle-même (data-current="agent",
+     programme console #71), c'est l'onglet Console Spark qui reste
+     visible en mobile — les 4 hôtes gardent leur propre courant. */
+  .draco-bar[data-current="agent"] .draco-apptab[data-app="agent"] { display: flex; }
 }

frontend/draco-barre.js

@@ -51,9 +51,13 @@
  * 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.
+ * La clé spark ne correspond à aucun onglet de la barre : elle est
+ * résolue et exposée via DRACO_BAR.urls pour le panneau Spark
+ * (panneau-agent), qui suit le même contrat d'injection. La clé agent,
+ * elle, a un onglet depuis le chantier 5 (ordre : ObsiGate, Flowdeck,
+ * TikTak, Kanbante, Console Spark) : elle suit donc l'étape « href
+ * rendu » comme les autres onglets, en plus d'alimenter le menu de
+ * la marque et DRACO_BAR.urls.
  * Actions émises (data-act) : rail, palette, domaine (data-dom),
  * alertes, spark, rappel-entete. L'app intégratrice décide de chacune
  * (ouvrir la palette, le panneau Spark, changer de domaine…).
@@ -79,9 +83,10 @@
  * onglets présents dans la barre, puis une entrée « Console Spark »
  * (logo ✦, rôle « Agent commun ») APRÈS Kanbante, vers l'URL agent
  * résolue : 1) config explicite DRACO_BAR_CONFIG.urls.agent,
- * 2) dérivation -dev agent-dev sur hôte -dev, 3) défaut officiel
- * prod https://agent.dracodev.net/ (il n'y a pas d'onglet agent, donc
- * pas d'étape « href rendu »). AUCUN hôte spark-dev n'est inventé :
+ * 2) dérivation -dev agent-dev sur hôte -dev, 3) href rendu de
+ * l'onglet « Console Spark » (chantier 5, data-app="agent"),
+ * 4) défaut officiel prod https://agent.dracodev.net/.
+ * AUCUN hôte spark-dev n'est inventé :
  * la clé spark, elle, suit toujours son propre contrat (explicite >
  * href rendu > défaut prod) et ne sert qu'au panneau Spark.
  * Focus (correctif #70) — ouverture au clavier : Entrée sur la marque
@@ -329,6 +334,11 @@
     appsMenu.setAttribute("role", "menu");
     appsMenu.setAttribute("aria-label", "Applications");
     document.querySelectorAll(".draco-apptab").forEach(function (t) {
+      /* Chantier 5 : l'onglet agent (« Console Spark ») n'est PAS
+       * repris ici — l'entrée dédiée ci-dessous le représente déjà
+       * (après Kanbante, avec séparateur) ; sans ce saut, le menu
+       * listerait « Console Spark » deux fois. */
+      if (t.dataset.app === "agent") return;
       var a = document.createElement("a");
       a.className = "draco-apps-item";
       a.href = resolvedUrls[t.dataset.app] || t.getAttribute("href");

frontend/index.html

@@ -336,7 +336,11 @@
              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/draco-barre.css, /static/draco-barre.js. -->
+             CSS/JS : /static/draco-barre.css, /static/draco-barre.js.
+             Chantier 5 (fusion #69/#71, sans bump) : 5e onglet Console Spark
+             (data-app="agent", défaut prod ; la réécriture DRACO_URLS
+             couvre la clé "agent" comme les autres onglets), après Kanbante ;
+             l'entrée « Console Spark » du menu de la marque est conservée. -->
         <header class="draco-bar" data-current="obsigate">
             <div class="draco-bar-zone draco-bar-gauche">
                 <button type="button" class="draco-icon-btn" data-act="rail" aria-label="Barre latérale">☰</button>
@@ -362,6 +366,10 @@
                         <span class="draco-apptab-txt"><strong>Kanbante</strong><small>Kanban</small></span>
                         <span class="draco-badge" data-badge="kanbante" hidden>0</span>
                     </a>
+                    <a class="draco-apptab" data-app="agent" href="https://agent.dracodev.net/">
+                        <span class="draco-apptab-ico" style="--app:#c2437e">✦</span>
+                        <span class="draco-apptab-txt"><strong>Console Spark</strong><small>Agent commun</small></span>
+                    </a>
                 </nav>
             </div>
             <div class="draco-bar-zone draco-bar-centre">
@@ -432,7 +440,7 @@
                         if (b) b.click();
                         return;
                     }
-                    if (act === "palette") { var s = document.getElementById("search-input"); if (s) { s.focus(); s.scrollIntoView({ block: "center" }); } return; }
+                    if (act === "palette") { location.href = "/recherche"; return; }
                     /* Correctif fusion #70 : relais "menu" supprimé avec le bouton trois points de la barre (la console agent est dans le menu de la marque, entrée « Console Spark »). Le bouton natif #header-menu-btn d'ObsiGate lui-même est inchangé et reste utilisable depuis l'en-tête ObsiGate. */
                     if (act === "alertes") { if (window.DRACO_ALERTES) { window.DRACO_ALERTES.open(); } else { dire("Alertes unifiées : le module n'a pas pu se charger."); } return; }
                     if (act === "spark") {

frontend/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
+);

frontend/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; }

frontend/recherche.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Rechercher partout — ObsiGate</title>
+  <link rel="stylesheet" href="/static/recherche.css">
+  <style>
+    /* Navigation minimale (la barre complète vit dans index.html, la SPA). */
+    .rp-nav { display: flex; gap: 16px; padding: 12px 16px; font-size: .9rem; }
+    .rp-nav a { color: inherit; opacity: .8; }
+  </style>
+</head>
+<body>
+  <!-- Jetons {{URL_*}} remplacés par la route /recherche (même contrat
+       que le fragment de barre). Servie brute via /static, la page
+       retomberait sur les défauts prod (les jetons sont ignorés par
+       le JS) — jamais d'URL inventée. -->
+  <nav class="rp-nav">
+    <a href="{{URL_OBSIGATE}}">ObsiGate</a>
+    <a href="{{URL_FLOWDECK}}">Flowdeck</a>
+    <a href="{{URL_TIKTAK}}">TikTak</a>
+    <a href="{{URL_KANBANTE}}">Kanbante</a>
+  </nav>
+  <main class="rp-page" id="recherche" data-host="obsigate"
+        data-base-obsigate="{{URL_OBSIGATE}}"
+        data-base-flowdeck="{{URL_FLOWDECK}}"
+        data-base-tiktak="{{URL_TIKTAK}}"
+        data-base-kanbante="{{URL_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=""
+             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>
+  <script src="/static/js/recherche.js"></script>
+</body>
+</html>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsigate",
-  "version": "2.81.3",
+  "version": "2.81.4",
   "description": "**Porte d'entrée web ultra-léger pour vos vaults Obsidian** — Accédez, naviguez et recherchez dans toutes vos notes Obsidian depuis n'importe quel appareil via une interface web moderne et responsive.",
   "main": "patch.js",
   "directories": {

tests/frontend/draco-alertes.test.mjs

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 /**
- * ObsiGate — Alertes unifiées (Fusion #69, chantier 2).
+ * ObsiGate — Alertes unifiées (Fusion #69, chantier 2 + chantier 5).
  *
  * Tests du module partagé frontend/draco-alertes.js (logique pure,
- * sans DOM) + vérification du gabarit livré frontend/index.html :
- * le placeholder « Alertes unifiées : arrive avec la fédération »
- * a disparu et le module est chargé.
+ * sans DOM) + vérification du gabarit livré frontend/index.html.
+ * Copie vendangée byte-identique de Projets/dracodev-commons
+ * ui/alertes/ (chantier 5) — seul le chargement change (ESM ici).
+ * Le payload console n'est qu'un EXEMPLE DE FORMAT (voir README
+ * commons) : aucun endpoint console n'est publié sur agent-commun
+ * main au moment du chantier.
  *
  * Usage: node tests/frontend/draco-alertes.test.mjs
  */
@@ -21,56 +24,226 @@ const REPO_ROOT = path.resolve(__dirname, "..", "..");
 const require = createRequire(import.meta.url);
 const t = require(path.join(REPO_ROOT, "frontend", "draco-alertes.js"));
 
-test("resolveUrls: config explicite > hote -dev > href > defaut prod", () => {
-  assert.equal(
-    t.resolveUrls({ hostname: "og.dracodev.net", tabHrefs: {} }).tiktak,
-    "https://tiktak.dracodev.net/"
-  );
-  assert.equal(
-    t.resolveUrls({ hostname: "og-dev.dracodev.net", tabHrefs: {} }).flowdeck,
-    "https://flowdeck-dev.dracodev.net/"
-  );
-  assert.equal(
-    t.resolveUrls({
-      hostname: "og-dev.dracodev.net",
-      configUrls: { kanbante: "https://kanbante.dracodev.net/" },
-    }).kanbante,
-    "https://kanbante.dracodev.net/"
-  );
-  assert.equal(t.isDevHost("og-dev.dracodev.net.evil.com"), false);
+function sampleResults() {
+  return {
+    flowdeck: { items: t.normalizeFlowdeck("https://flowdeck.dracodev.net/", {
+      notifications: [
+        { id: 1, ntype: "mention", title: "Mention budget", message: "voir page", url: "/collections/3", is_read: 0, created_at: "2026-10-28T10:00:00" },
+        { id: 2, ntype: "reminder", title: "Rappel lu", message: "", url: "", is_read: 1, created_at: "2026-10-27T09:00:00" },
+      ], unread: 1,
+    }) },
+    tiktak: { items: t.normalizeTiktak("https://tiktak.dracodev.net/", [
+      { id: 7, kind: "reminder", title: "Rappel tâche", body: "tache", task_id: 42, is_read: 0, created_at: "2026-10-28T08:00:00" },
+      { id: 8, kind: "share", title: "Partage lu", body: "", task_id: null, is_read: 1, created_at: "2026-10-26T08:00:00" },
+    ]) },
+    kanbante: { items: t.normalizeKanbante("https://kanbante.dracodev.net/", {
+      events: [
+        { id: 9, repo_full_name: "Projets/fusion-trois-apps", issue_number: 69, event_type: "commented", from_column: "", to_column: "", created_at: "2026-10-28T11:50:00" },
+        { id: 10, repo_full_name: "Projets/fusion-trois-apps", issue_number: 69, event_type: "moved", from_column: "todo", to_column: "review", created_at: "2026-10-28T12:00:00" },
+      ],
+    }) },
+    obsigate: { items: [] },
+    console: { items: [], sourceMissing: true },
+  };
+}
+function allOf(results) {
+  const all = [];
+  for (const app of ["obsigate", "flowdeck", "tiktak", "kanbante", "console"]) {
+    (results[app] && results[app].items || []).forEach((a) => all.push(a));
+  }
+  return all;
+}
+
+test("ordre des onglets : Tout, apps, Console Spark, Historique", () => {
+  assert.deepEqual(t.TABS, ["tout", "obsigate", "flowdeck", "tiktak", "kanbante", "console", "historique"]);
+  assert.equal(t.TAB_LABELS.console, "Console Spark");
 });
 
-test("normalizeFlowdeck/TikTak/Kanbante: actifs = non lus, Kanbante jamais actif", () => {
-  const fd = t.normalizeFlowdeck("https://flowdeck.dracodev.net/", {
-    notifications: [
-      { id: 1, ntype: "mention", title: "Mention", message: "m", url: "/collections/3", is_read: 0, created_at: "2026-10-28T10:00:00" },
-    ],
-    unread: 1,
+test("resolveUrls: config explicite > hote -dev > href > defaut prod, agent inclus", () => {
+  const prod = t.resolveUrls({ hostname: "tiktak.dracodev.net", tabHrefs: {} });
+  assert.equal(prod.tiktak, "https://tiktak.dracodev.net/");
+  assert.equal(prod.agent, "https://agent.dracodev.net/");
+  const dev = t.resolveUrls({ hostname: "tiktak-dev.dracodev.net", tabHrefs: {} });
+  assert.equal(dev.flowdeck, "https://flowdeck-dev.dracodev.net/");
+  assert.equal(dev.obsigate, "https://og-dev.dracodev.net/");
+  assert.equal(dev.agent, "https://agent-dev.dracodev.net/");
+  const explicit = t.resolveUrls({
+    hostname: "tiktak-dev.dracodev.net",
+    configUrls: { flowdeck: "https://flowdeck.dracodev.net/" },
   });
-  assert.equal(fd[0].active, true);
-  assert.equal(fd[0].url, "https://flowdeck.dracodev.net/collections/3");
-  const tt = t.normalizeTiktak("https://tiktak.dracodev.net/", [
-    { id: 7, kind: "reminder", title: "Rappel", body: "", task_id: 42, is_read: 0, created_at: "2026-10-28T08:00:00" },
+  assert.equal(explicit.flowdeck, "https://flowdeck.dracodev.net/");
+  const href = t.resolveUrls({
+    hostname: "example.org",
+    tabHrefs: { kanbante: "https://kanbante-dev.dracodev.net/", agent: "https://agent.dracodev.net/" },
+  });
+  assert.equal(href.kanbante, "https://kanbante-dev.dracodev.net/");
+  assert.equal(href.agent, "https://agent.dracodev.net/");
+  const token = t.resolveUrls({ hostname: "x", tabHrefs: { tiktak: "{{URL_TIKTAK}}" } });
+  assert.equal(token.tiktak, "https://tiktak.dracodev.net/");
+  assert.equal(t.isDevHost("tiktak-dev.dracodev.net.evil.com"), false);
+  assert.equal(t.isDevHost("x-dev.dracodev.net"), true);
+});
+
+test("normalizeFlowdeck: non lues actives, lien = base + url", () => {
+  const items = t.normalizeFlowdeck("https://flowdeck.dracodev.net/", {
+    notifications: [
+      { id: 1, ntype: "mention", title: "Mention", message: "voir page", url: "/collections/3", is_read: 0, created_at: "2026-10-28T10:00:00" },
+      { id: 2, ntype: "reminder", title: "Rappel", message: "", url: "", is_read: 1, created_at: "2026-10-27T09:00:00" },
+    ], unread: 1,
+  });
+  assert.equal(items.length, 2);
+  assert.equal(items[0].active, true);
+  assert.equal(items[0].state, "active");
+  assert.equal(items[0].url, "https://flowdeck.dracodev.net/collections/3");
+  assert.equal(items[1].active, false);
+  assert.equal(items[1].url, "https://flowdeck.dracodev.net/");
+});
+
+test("normalizeTiktak: lien tache, sinon page notifications", () => {
+  const items = t.normalizeTiktak("https://tiktak.dracodev.net/", [
+    { id: 7, kind: "reminder", title: "Rappel", body: "tache", task_id: 42, is_read: 0, created_at: "2026-10-28T08:00:00" },
+    { id: 8, kind: "share", title: "Partage", body: "", task_id: null, is_read: 1, created_at: "2026-10-26T08:00:00" },
   ]);
-  assert.equal(tt[0].url, "https://tiktak.dracodev.net/?task=42");
-  const kb = t.normalizeKanbante("https://kanbante.dracodev.net/", {
+  assert.equal(items[0].url, "https://tiktak.dracodev.net/?task=42");
+  assert.equal(items[1].url, "https://tiktak.dracodev.net/notifications");
+  assert.equal(items[0].active, true);
+});
+
+test("normalizeKanbante: jamais actif (pas d'etat lu/non lu), lien board", () => {
+  const items = t.normalizeKanbante("https://kanbante.dracodev.net/", {
     events: [
       { id: 9, repo_full_name: "Projets/fusion-trois-apps", issue_number: 69, event_type: "commented", from_column: "", to_column: "", created_at: "2026-10-28T11:50:00" },
+      { id: 10, repo_full_name: "Projets/fusion-trois-apps", issue_number: 69, event_type: "moved", from_column: "todo", to_column: "review", created_at: "2026-10-28T12:00:00" },
     ],
   });
-  assert.equal(kb[0].active, false);
-  assert.equal(kb[0].url, "https://kanbante.dracodev.net/board/Projets/fusion-trois-apps");
-  assert.equal(t.countActive([...fd, ...tt, ...kb]), 2);
+  assert.equal(items.length, 2);
+  assert.ok(items.every((i) => i.active === false));
+  assert.equal(items[0].url, "https://kanbante.dracodev.net/board/Projets/fusion-trois-apps");
+  assert.match(items[0].title, /#69/);
 });
 
-test("sortAlerts: actives d'abord, date decroissante", () => {
-  const sorted = t.sortAlerts([
+test("sortAlerts + countActive: actives d'abord, date decroissante", () => {
+  const list = [
     { app: "tiktak", active: false, date: "2026-10-28T12:00:00" },
     { app: "flowdeck", active: true, date: "2026-10-26T12:00:00" },
     { app: "flowdeck", active: true, date: "2026-10-28T12:00:00" },
-  ]);
-  assert.equal(sorted[0].active, true);
+    { app: "kanbante", active: false, date: "" },
+  ];
+  const sorted = t.sortAlerts(list);
   assert.equal(sorted[0].date, "2026-10-28T12:00:00");
+  assert.equal(sorted[0].active, true);
+  assert.equal(sorted[1].date, "2026-10-26T12:00:00");
+  assert.equal(sorted[3].date, "");
+  assert.equal(t.countActive(list), 2);
+});
+
+test("scopeAlerts: Tout et onglets apps = actives seulement ; Historique = fermees seulement", () => {
+  const r = sampleResults();
+  const all = allOf(r);
+  const tout = t.scopeAlerts(all, "tout", r);
+  assert.equal(tout.items.length, 2);
+  assert.ok(tout.items.every((a) => a.active));
+  assert.equal(tout.items[0].date, "2026-10-28T10:00:00"); // date decroissante
+  const fd = t.scopeAlerts(all, "flowdeck", r);
+  assert.equal(fd.items.length, 1);
+  assert.equal(fd.items[0].app, "flowdeck");
+  const hist = t.scopeAlerts(all, "historique", r);
+  assert.equal(hist.items.length, 4); // 1 FD lue + 1 TK lue + 2 KB
+  assert.ok(hist.items.every((a) => !a.active));
+  const og = t.scopeAlerts(all, "obsigate", r);
+  assert.equal(og.items.length, 0);
+  const cs = t.scopeAlerts(all, "console", r);
+  assert.equal(cs.items.length, 0);
+  assert.equal(cs.consoleMissing, true);
+});
+
+test("scopeAlerts: une section en echec remonte aussi dans Historique (pas avalee)", () => {
+  const r = sampleResults();
+  r.flowdeck = { items: [], error: "Application injoignable depuis cet hôte (TypeError)." };
+  const hist = t.scopeAlerts(allOf(r), "historique", r);
+  assert.equal(hist.errors.length, 1);
+  assert.equal(hist.errors[0].app, "flowdeck");
+  const tout = t.scopeAlerts(allOf(r), "tout", r);
+  assert.equal(tout.errors.length, 1);
+});
+
+test("countByTab: compteurs par onglet sur l'echantillon", () => {
+  const r = sampleResults();
+  const c = t.countByTab(allOf(r), r);
+  assert.deepEqual(c, {
+    tout: 2, obsigate: 0, flowdeck: 1, tiktak: 1,
+    kanbante: 0, console: 0, historique: 4,
+  });
+});
+
+test("filterAlerts: titre + contexte, insensible a la casse, sans melanger actifs/historique", () => {
+  const r = sampleResults();
+  const all = allOf(r);
+  const tout = t.scopeAlerts(all, "tout", r).items;
+  assert.equal(t.filterAlerts(tout, "budget").length, 1);
+  assert.equal(t.filterAlerts(tout, "BUDGET").length, 1);
+  assert.equal(t.filterAlerts(tout, "voir page").length, 1); // contexte (detail)
+  assert.equal(t.filterAlerts(tout, "tache").length, 1);
+  // « Rappel lu » est une alerte fermee : absente de Tout meme filtree.
+  assert.equal(t.filterAlerts(tout, "Rappel lu").length, 0);
+  const hist = t.scopeAlerts(all, "historique", r).items;
+  assert.equal(t.filterAlerts(hist, "Rappel lu").length, 1);
+  assert.equal(t.filterAlerts(tout, "").length, tout.length);
+});
+
+test("presentation identique: meta Kanbante sans type brut anglais ; date illisible = sans date", () => {
+  const kb = t.normalizeKanbante("https://kanbante.dracodev.net/", {
+    events: [{ id: 1, repo_full_name: "R", issue_number: 1, event_type: "moved", from_column: "todo", to_column: "review", created_at: "2026-10-28T12:00:00" }],
+  })[0];
+  assert.ok(!t.metaLine(kb).includes("moved"));
+  assert.match(t.metaLine(kb), /Kanbante · .* · Déplacée/);
+  assert.equal(t.displayState({ active: true }), "Active");
+  assert.equal(t.displayState({ active: false, app: "flowdeck" }), "Lue");
+  const sansDate = { app: "tiktak", active: true, title: "x", detail: "", date: "nimporte-quoi", kind: "", url: "https://x/" };
+  assert.match(t.metaLine(sansDate), /sans date/);
+});
+
+test("hash URL: parse + round-trip, onglet inconnu rejete", () => {
+  assert.equal(t.parseAlertTab("#alertes=historique"), "historique");
+  assert.equal(t.parseAlertTab("#alertes=console"), "console");
+  assert.equal(t.parseAlertTab("#alertes"), "tout");
+  assert.equal(t.parseAlertTab("#autre"), null);
+  assert.equal(t.parseAlertTab("#alertes=nimporte"), null);
+  assert.equal(t.parseAlertTab(""), null);
+  for (const tab of t.TABS) assert.equal(t.parseAlertTab(t.hashForTab(tab)), tab);
+  assert.equal(t.hashForTab("nimporte"), "#alertes=tout");
+});
+
+test("normalizeConsole (FORMAT EXEMPLE): statuts reels -> actif/ferme, lien console par defaut", () => {
+  const items = t.normalizeConsole("https://agent.dracodev.net/", {
+    alerts: [
+      { id: "m1", title: "Mission en pause budget", detail: "budget épuisé", status: "pause_budget", created_at: "2026-10-28T09:00:00" },
+      { id: "m2", title: "Accès requis", detail: "jeton manquant", status: "acces_requis", created_at: "2026-10-28T09:30:00" },
+      { id: "a1", title: "Approbation en attente", status: "en_attente", url: "/approbations", created_at: "2026-10-28T10:00:00" },
+      { id: "m3", title: "Mission terminée", status: "terminee", created_at: "2026-10-27T10:00:00" },
+      { id: "m4", title: "Sans statut", created_at: "2026-10-27T11:00:00" },
+    ],
+  });
+  assert.equal(items.length, 5);
+  assert.equal(items[0].active, true);
+  assert.equal(items[1].active, true);
+  assert.equal(items[2].active, true);
+  assert.equal(items[2].url, "https://agent.dracodev.net/approbations");
+  assert.equal(items[3].active, false);
+  assert.equal(items[4].active, true); // statut inconnu : expose en active, jamais masque
+  assert.equal(items[0].url, "https://agent.dracodev.net/");
+  const r = sampleResults();
+  r.console = { items };
+  const c = t.countByTab(allOf(r), r);
+  assert.equal(c.console, 4);
+  assert.equal(c.tout, 6);
+  assert.equal(c.historique, 5);
+});
+
+test("consoleSourceUrl: null sans configuration (aucune URL devineee)", () => {
+  assert.equal(t.consoleSourceUrl({}), null);
+  assert.equal(t.consoleSourceUrl({ consoleUrl: "https://agent-dev.dracodev.net/api/alertes" }),
+    "https://agent-dev.dracodev.net/api/alertes");
 });
 
 test("index.html: placeholder Alertes disparu, module charge", () => {
@@ -80,3 +253,25 @@ test("index.html: placeholder Alertes disparu, module charge", () => {
   assert.equal(html.includes("/static/draco-alertes.css"), true);
   assert.equal(html.includes("DRACO_ALERTES.open()"), true);
 });
+
+test("index.html chantier 5: onglet Console Spark en dernier, apres Kanbante", () => {
+  const html = readFileSync(path.join(REPO_ROOT, "frontend", "index.html"), "utf8");
+  const nav = /<nav class="draco-apptabs"[^>]*>([\s\S]*?)<\/nav>/.exec(html)[1];
+  const apps = [...nav.matchAll(/data-app="([^"]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(apps, ["obsigate", "flowdeck", "tiktak", "kanbante", "agent"]);
+  assert.ok(nav.includes('data-app="agent" href="https://agent.dracodev.net/"'));
+  assert.ok(nav.includes("<strong>Console Spark</strong>"));
+  // La réécriture DRACO_URLS couvre la clé "agent" (même boucle que les autres onglets).
+  assert.ok(html.includes('window.DRACO_URLS[a.dataset.app]'));
+});
+
+test("draco-alertes.js/.css chantier 5: onglets, filtre, etat console honnete", () => {
+  const js = readFileSync(path.join(REPO_ROOT, "frontend", "draco-alertes.js"), "utf8");
+  assert.ok(js.includes("draco-alertes-tab"));
+  assert.ok(js.includes("historique"));
+  assert.ok(js.includes("source indisponible"));
+  assert.ok(js.includes("DRACO_ALERTES_CONSOLE_URL"));
+  const css = readFileSync(path.join(REPO_ROOT, "frontend", "draco-alertes.css"), "utf8");
+  assert.ok(css.includes(".draco-alertes-tab"));
+  assert.ok(css.includes(".draco-alertes-filtre"));
+});

tests/frontend/recherche.test.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * ObsiGate — tests de la logique pure de la page « Rechercher partout »
+ * (fusion #68), sans DOM ni jsdom : résolution des bases, liens
+ * profonds et normalisation des 4 formats d'API.
+ *
+ * Le fichier frontend/js/recherche.js est chargé en ESM (frontend/js
+ * est "type": "module") ; ses helpers sont exposés via
+ * globalThis.RecherchePartout. Usage : node tests/frontend/recherche.test.mjs
+ */
+import { strict as assert } from "node:assert";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import path from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const JS_FILE = path.resolve(__dirname, "..", "..", "frontend", "js", "recherche.js");
+
+await import(pathToFileURL(JS_FILE).href);
+const rp = globalThis.RecherchePartout;
+assert.ok(rp, "RecherchePartout exposé");
+
+let n = 0;
+const ok = (cond, label) => {
+  assert.ok(cond, label);
+  n += 1;
+};
+
+ok(rp.isDevHost("og-dev.dracodev.net") === true, "dev reconnu");
+ok(rp.isDevHost("x-dev.dracodev.net.evil") === false, "hôte piège rejeté");
+
+const b = rp.resolveBases({
+  host: "og-dev.dracodev.net",
+  explicit: { tiktak: "https://tiktak-perso.example/" },
+  barUrls: {},
+  tabHrefs: {},
+});
+ok(b.tiktak === "https://tiktak-perso.example/", "explicite prioritaire");
+ok(b.obsigate === "https://og-dev.dracodev.net/", "dev pour l'hôte courant");
+ok(b.kanbante === "https://kanbante-dev.dracodev.net/", "dev avant href");
+ok(
+  rp.searchPath("obsigate", "café") === "api/search?q=caf%C3%A9&vault=all&limit=8",
+  "path ObsiGate",
+);
+
+const 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[0].url === "https://og-dev.dracodev.net/#file=home-bruno:Notes%2FId%C3%A9e.md",
+  "lien profond ObsiGate",
+);
+ok(
+  rp.nativeSearchUrl("tiktak", "https://tiktak-dev.dracodev.net/", "q") ===
+    "https://tiktak-dev.dracodev.net/search?q=q",
+  "repli TikTak",
+);
+
+console.log(`recherche.test.mjs : ${n} assertions OK`);

tests/test_recherche_cors.py

@@ -0,0 +1,69 @@
+"""Tests de la recherche fédérée ObsiGate (fusion #68).
+
+Fonctions pures de backend/recherche_cors.py uniquement : aucune base,
+aucun serveur.
+"""
+
+from backend.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("og-dev.dracodev.net") is True
+    assert is_dev_host("og.dracodev.net") is False
+    assert is_dev_host("x-dev.dracodev.net.evil") is False
+    assert is_prod_host("og.dracodev.net") is True
+    assert is_prod_host("og-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("https://og-dev.dracodev.net/chemin") == "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():
+    assert "https://og-dev.dracodev.net" in sister_origins(
+        {}, request_host="og-dev.dracodev.net"
+    )
+    assert "https://og-dev.dracodev.net" not in sister_origins(
+        {}, request_host="og.dracodev.net"
+    )
+
+
+def test_cors_headers():
+    headers = cors_headers_for("https://tiktak-dev.dracodev.net", RESOLVED_DEV)
+    assert headers["Access-Control-Allow-Origin"] == "https://tiktak-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://flowdeck-dev.dracodev.net", RESOLVED_DEV)
+    assert headers["Access-Control-Allow-Methods"] == "GET, OPTIONS"
+    assert preflight_headers("https://evil.example", RESOLVED_DEV) is None