Recherche partout (#68, chantier 2+3) : onglets, Tout voir sur place, focus, mise en page

CHANGELOG.md

@@ -1,3 +1,9 @@
+## v7.84.2 (2026-10-28) — Programme Fusion : menu barre, alertes unifiées, recherche partout
+
+- **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/CORS bornées à `/api/notifications`.
+- **Rechercher partout (#68)** : page `/recherche` unifiée par application, liens profonds dans l'environnement courant (dérivation `-dev` respectée), draco + 401 sur `/api/search` (corrige la recherche sans périmètre sans session) ; la palette de la barre ouvre désormais `/recherche`.
+
 # Changelog - FlowDeck
 
 ## v7.84.1 (2026-10-28) — Barre d'apps v0.1.6 vendangée (dérivation -dev, menu •••, compte)

VERSION

@@ -1 +1 @@
-7.84.1
+7.84.2

app/main.py

@@ -216,7 +216,7 @@ def _lire_version() -> str:
 
 
 # Littéral de version synchronisé avec le fichier VERSION :
-# version="7.84.1"
+# version="7.84.2"
 # Patron historique des bumps (voir scripts/bump_version.py, qui cherche
 # ce littéral) et contrôle de tests/test_pwa_offline.py. La version
 # runtime reste lue dynamiquement depuis VERSION par _lire_version()
@@ -239,6 +239,18 @@ app.add_middleware(RateLimitMiddleware)
 _CORS_ORIGINS = sorted(
     {o.rstrip("/") for o in (settings.app_base_url or "").split() if o.startswith(("http://", "https://"))}
 )
+# Fusion #69 : le panneau Alertes unifiées lit /api/notifications
+# depuis les hôtes soeurs, avec credentials — leurs origines doivent
+# donc figurer dans allow_origins (résolution draco_urls : explicite
+# > hôte de la requête > dérivation > défaut officiel ; hors requête,
+# la configuration seule). Lecture seule (GET) ; les POST restent
+# soumis au CSRFMiddleware.
+from app.services import draco_urls as _draco_urls69
+_toutes69 = _draco_urls69.toutes()
+_CORS_ORIGINS = sorted(set(_CORS_ORIGINS) | {
+    _draco_urls69.origine(_toutes69[k])
+    for k in ("obsigate", "flowdeck", "tiktak", "kanbante")
+} - {""})
 # Hors prod : dev local + origines d'extension (Web Clipper, Bearer uniquement —
 # pas de cookie → `allow_credentials` ne s'applique pas à ces origines).
 app.add_middleware(
@@ -250,6 +262,13 @@ app.add_middleware(
     allow_credentials=True,
 )
 
+# Recherche partout (#68) : CORS bornée pour GET /api/search — ajoutée
+# après CORSMiddleware donc exécutée avant lui (dernier ajouté = le
+# plus externe) : les preflights OPTIONS sont répondus ici, avant
+# tout refus d'origine. La politique CORS globale est inchangée.
+from app.middleware.recherche_cors import RechercheCorsMiddleware
+
+app.add_middleware(RechercheCorsMiddleware)
 app.include_router(auth.router)
 app.include_router(sso_router)
 app.include_router(dashboard.router)

app/middleware/recherche_cors.py

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

app/middleware/security.py

@@ -139,7 +139,7 @@ class ContentSecurityPolicyMiddleware(BaseHTTPMiddleware):
         # l'agent connu en config ; défaut = nom officiel).
         # Même origine pour frame-src : la console du service est
         # encadrée en iframe par le panneau (surimpression v3).
-        "connect-src 'self' {agent} ws://{host} wss://{host}; "
+        "connect-src 'self' {agent} {sisters} ws://{host} wss://{host}; "
         "media-src 'self' blob:; "
         "frame-src 'self' {agent}; "
         "object-src 'none'; "
@@ -174,8 +174,17 @@ class ContentSecurityPolicyMiddleware(BaseHTTPMiddleware):
                           request.headers.get("host", ""))
             agent = re.sub(r"[^0-9A-Za-z.\-:/]", "",
                            draco_urls.origine(draco_urls.agent_url()))
+            # Fusion #69 : le panneau Alertes unifiées lit les API
+            # notifications des applications soeurs depuis cet hôte ;
+            # leurs origines rejoignent connect-src (même résolution
+            # draco_urls que les liens de la barre et frame-src).
+            _toutes69 = draco_urls.toutes()
+            sisters = " ".join(sorted({
+                draco_urls.origine(_toutes69[k])
+                for k in ("obsigate", "flowdeck", "tiktak", "kanbante")
+            } - {""}))
             response.headers[self.CSP_HEADER] = self.CSP_VALUE.format(
-                nonce=nonce, host=host, agent=agent
+                nonce=nonce, host=host, agent=agent, sisters=sisters
             )
         return response
 

app/routers/search.py

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

app/templates/_draco_bar.html

@@ -6,6 +6,7 @@
    v7.82.0 (dev/prod) : les href des onglets ne sont plus figés —
    l'hôte les injecte depuis sa config (draco_urls(), noms officiels
    par défaut, noms en -dev déclarés dans le .env de l'environnement). #}
+<link rel="stylesheet" href="/static/css/draco-alertes.css?v={{ asset_version }}">
 <header class="draco-bar" data-current="flowdeck">
     <div class="draco-bar-zone draco-bar-gauche">
         <button type="button" class="draco-icon-btn" data-act="rail" aria-label="Barre latérale">☰</button>
@@ -63,9 +64,10 @@
 <script nonce="{{ csp_nonce() }}">
     /* Configuration Flowdeck de la barre commune (Fusion ACC-1.1).
        Phase 1 : navigation entre apps et domaine mémorisé localement ;
-       le rail pilote le hamburger natif, les alertes ouvrent la cloche
-       native de la page ; la recherche fédérée et Spark arrivent avec
-       les phases suivantes du programme Fusion. */
+       le rail pilote le hamburger natif, les alertes ouvrent le
+       panneau draco-alertes.js (Fusion #69, agrégation à la demande,
+       pas une fédération temps réel ; la cloche native reste le
+       repli si le module ne charge pas). */
     window.DRACO_BAR_CONFIG = {
         current: "flowdeck",
         domain: (function () { try { return localStorage.getItem("draco_domain") || "pro"; } catch (e) { return "pro"; } })(),
@@ -81,11 +83,11 @@
             if (act === "domaine") { try { localStorage.setItem("draco_domain", el.dataset.dom); } catch (e) { } return; }
             if (act === "rail") { var h = document.querySelector(".hamburger-btn"); if (h) h.click(); return; }
             if (act === "alertes") {
-                var b = document.querySelector(".fd-notif-bell button");
-                if (b) { b.click(); } else { dire("Alertes unifiées : arrive avec la fédération (programme Fusion)."); }
+                if (window.DRACO_ALERTES) { window.DRACO_ALERTES.open(); }
+                else { var b = document.querySelector(".fd-notif-bell button"); if (b) { b.click(); } }
                 return;
             }
-            if (act === "palette") { dire("Recherche fédérée ⌘K : arrive avec la fédération (programme Fusion)."); return; }
+            if (act === "palette") { location.href = "/recherche"; return; }
             /* Correctif fusion #70 : action "menu" supprimée avec le bouton trois points (console agent dans le menu de la marque). Nonce CSP du script inchangé. */
             if (act === "spark") {
                 if (window.DRACO_PANNEAU) { window.DRACO_PANNEAU.toggle(); }
@@ -100,3 +102,4 @@
         }
     };
 </script>
+<script src="/static/js/draco-alertes.js?v={{ asset_version }}"></script>

app/templates/recherche.html

@@ -0,0 +1,53 @@
+{% extends "base.html" %}
+{% block title_prefix %}Rechercher partout{% endblock %}
+{% block content %}
+<link rel="stylesheet" href="/static/css/recherche.css">
+{# Console : pas de data-base-console ici — la route Flowdeck de /recherche
+   n'expose pas la base agent dans son contexte `bases` ; recherche.js
+   dérive donc la base console (hôte -dev -> agent-dev, sinon prod) ou
+   reprend le href d'un onglet de barre console/spark quand il existe.
+   Les 3 autres hôtes rendent data-base-console explicitement. #}
+<main class="rp-page" id="recherche" data-host="flowdeck"
+      data-base-obsigate="{{ bases.obsigate }}"
+      data-base-flowdeck="{{ bases.flowdeck }}"
+      data-base-tiktak="{{ bases.tiktak }}"
+      data-base-kanbante="{{ bases.kanbante }}">
+  <h1>Rechercher partout</h1>
+  <p class="rp-hint">Notes ObsiGate, pages Flowdeck, tâches TikTak, cartes Kanbante — dans l'environnement courant (dev reste dev). « / » ou Ctrl+K pour rechercher, ↑/↓ puis Entrée pour ouvrir un résultat. « Tout voir » bascule vers l'onglet de l'application, sans quitter la page.</p>
+  <div class="rp-form">
+    <input id="rp-q" class="rp-input" type="search" name="q" value="{{ q }}"
+           placeholder="Rechercher partout…" autocomplete="off" autofocus>
+  </div>
+  <nav class="rp-tabs" role="tablist" aria-label="Résultats par application">
+    <button type="button" class="rp-tab active" role="tab" aria-selected="true" data-rp-tab="all">Tout <span class="rp-tab-count"></span></button>
+    <button type="button" class="rp-tab" role="tab" aria-selected="false" tabindex="-1" data-rp-tab="obsigate">ObsiGate <span class="rp-tab-count"></span></button>
+    <button type="button" class="rp-tab" role="tab" aria-selected="false" tabindex="-1" data-rp-tab="flowdeck">Flowdeck <span class="rp-tab-count"></span></button>
+    <button type="button" class="rp-tab" role="tab" aria-selected="false" tabindex="-1" data-rp-tab="tiktak">TikTak <span class="rp-tab-count"></span></button>
+    <button type="button" class="rp-tab" role="tab" aria-selected="false" tabindex="-1" data-rp-tab="kanbante">Kanbante <span class="rp-tab-count"></span></button>
+    <button type="button" class="rp-tab" role="tab" aria-selected="false" tabindex="-1" data-rp-tab="console">Console Spark <span class="rp-tab-count"></span></button>
+  </nav>
+  <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>
+  <section class="rp-section" data-rp-section="console">
+    <div class="rp-head"><h2>Console Spark — discussions</h2><span class="rp-count"></span><a class="rp-all" href="#">Tout voir</a></div>
+    <div class="rp-body"><p class="rp-state">Tapez une recherche ci-dessus.</p></div>
+  </section>
+</main>
+{% endblock %}
+{% block scripts %}
+<script src="/static/js/recherche.js"></script>
+{% endblock %}

static/css/draco-alertes.css

@@ -0,0 +1,39 @@
+/* Alertes unifiées dracodev — Fusion #69. Styles neutres, variables
+ * d'hôte avec replis sombres (les 4 hôtes sont à dominante sombre). */
+.draco-alertes-overlay {
+  position: fixed; inset: 0; z-index: 30000;
+  display: none; align-items: flex-start; justify-content: center;
+  padding: 8vh 16px 16px;
+  background: rgb(0 0 0 / .55); overflow-y: auto;
+}
+.draco-alertes-box {
+  width: 720px; max-width: 100%;
+  background: var(--bg-primary, #1f1f1f);
+  color: var(--text, #eceee9);
+  border: 1px solid var(--border, #333);
+  border-radius: 14px; box-shadow: 0 16px 48px rgb(0 0 0 / .5);
+  padding: 16px 18px 18px;
+}
+.draco-alertes-head { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
+.draco-alertes-head h2 { margin: 0; font-size: 18px; }
+.draco-alertes-close {
+  border: 1px solid var(--border, #333); background: transparent;
+  color: inherit; border-radius: 8px; padding: 4px 10px; cursor: pointer;
+}
+.draco-alertes-note { font-size: 12.5px; color: var(--text-dim, #999); margin: 8px 0 14px; }
+.draco-alertes-group { font-size: 15px; margin: 18px 0 6px; }
+.draco-alertes-section h3 { font-size: 14px; margin: 12px 0 6px; }
+.draco-alertes-item {
+  border: 1px solid var(--border, #2a2a2a); border-radius: 10px;
+  padding: 9px 12px; margin: 6px 0;
+}
+.draco-alertes-item.is-active { border-color: #e8762c; }
+.draco-alertes-title { font-weight: 600; color: inherit; text-decoration: none; }
+.draco-alertes-title:hover { text-decoration: underline; }
+.draco-alertes-detail {
+  font-size: 13px; color: var(--text-dim, #bbb); margin-top: 2px;
+  display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden;
+}
+.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; }

static/css/recherche.css

@@ -0,0 +1,90 @@
+/* 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; }
+
+/* ---- Onglets (chantier 2+3) : mêmes onglets sur les 4 hôtes. ---- */
+.rp-tabs {
+  display: flex; gap: 4px; flex-wrap: wrap;
+  border-bottom: 1px solid #888; margin-bottom: 20px;
+}
+.rp-tab {
+  background: none; border: none; border-bottom: 2px solid transparent;
+  padding: 8px 10px; margin-bottom: -1px; font: inherit; cursor: pointer;
+  color: inherit; opacity: .7; white-space: nowrap;
+}
+.rp-tab:hover { opacity: 1; }
+.rp-tab.active { opacity: 1; border-bottom-color: #3b82f6; font-weight: 700; }
+.rp-tab:focus-visible { outline: 2px solid #3b82f6; outline-offset: 2px; }
+.rp-tab-count {
+  font-size: .8rem; font-weight: 700; background: rgba(127, 127, 127, .25);
+  border-radius: 999px; padding: 1px 7px; margin-left: 2px;
+}
+.rp-tab-count:empty { display: none; }
+.rp-section[hidden] { display: none; }
+.rp-all[hidden] { display: none; }
+
+/* ---- TikTak : la page sort de la colonne sidebar (chantier 2+3).
+ * Cause : recherche.html étend base.html sans layout_class, donc
+ * .rp-page (enfant direct de .layout) tombait en auto-placement dans
+ * la 2e colonne de la grille (largeur sidebar). La règle ci-dessous,
+ * gardée par l'ancêtre .layout (TikTak seul), l'étend de la colonne 2
+ * à la fin de la grille — juste à droite du rail d'icônes — sur toute
+ * la largeur disponible, sans toucher aux autres pages (elles ne
+ * portent pas .rp-page). En mobile (≤760 px, point de bascule TikTak),
+ * la grille n'a qu'une colonne : la page la prend entièrement. */
+.layout > .rp-page {
+  grid-column: 2 / -1; max-width: none; min-width: 0; overflow-y: auto;
+}
+@media (max-width: 760px) {
+  .layout > .rp-page { grid-column: 1 / -1; }
+}
+
+/* ---- ObsiGate : navigation statique de la page autonome (chantier
+ * 2+3). La page /recherche est servie hors SPA (route avant le
+ * catch-all) : elle reprend les classes de l'app (style.css :
+ * .app-container, .header, .main-body, .sidebar, .content-wrapper,
+ * .content-area) et cette navigation, calée sur les variables de
+ * l'app, en guise de sidebar. Les vaults dynamiques restent dans
+ * la SPA (voir le commentaire dans recherche.html). */
+.rp-og-nav { display: flex; flex-direction: column; gap: 4px; padding: 12px; }
+.rp-og-nav a {
+  display: block; padding: 8px 10px; border-radius: 8px;
+  text-decoration: none; color: inherit;
+}
+.rp-og-nav a:hover { background: rgba(127, 127, 127, .15); }
+.rp-og-nav a[aria-current="page"] {
+  background: rgba(127, 127, 127, .18); font-weight: 700;
+}
+.rp-og-note { opacity: .65; font-size: .85rem; padding: 8px 10px; margin: 8px 0 0; }

static/js/draco-alertes.js

@@ -0,0 +1,427 @@
+/* Alertes unifiées dracodev — Fusion #69 (chantier 2).
+ *
+ * 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é.
+ *
+ * Sources réelles (audit #69, 2026-10-28) :
+ *   - 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.
+ *   - TikTak : GET {base}/api/notifications
+ *     -> [{id, kind, title, body, task_id, is_read, created_at}] ;
+ *     active = is_read = 0 ; lien = base + "/?task=" + task_id, sinon
+ *     base + "/notifications".
+ *   - Kanbante : GET {base}/api/events?limit=100
+ *     -> { events: [{repo_full_name, issue_number, event_type,
+ *     from_column, to_column, created_at}] } ; AUCUN état lu/non lu
+ *     n'existe dans Kanbante, donc tout y est historique et rien n'y
+ *     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
+ *     ObsiGate le dit et renvoie vers l'accueil d'ObsiGate.
+ *
+ * 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] ;
+ *   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).
+ * 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.
+ *
+ * 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).
+ * Insertion des données : textContent uniquement, jamais innerHTML
+ * avec une valeur venue du serveur.
+ */
+(function (global) {
+  "use strict";
+
+  var DEFAULT_URLS = {
+    obsigate: "https://og.dracodev.net/",
+    flowdeck: "https://flowdeck.dracodev.net/",
+    tiktak: "https://tiktak.dracodev.net/",
+    kanbante: "https://kanbante.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/"
+  };
+  var APP_LABELS = {
+    obsigate: "ObsiGate", flowdeck: "Flowdeck",
+    tiktak: "TikTak", kanbante: "Kanbante"
+  };
+  var APP_ORDER = ["obsigate", "flowdeck", "tiktak", "kanbante"];
+  var EVENT_LABELS = {
+    created: "créée", moved: "déplacée", closed: "fermée",
+    reopened: "rouverte", commented: "commentée"
+  };
+
+  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";
+  }
+  function cleanUrl(u) {
+    if (!u || typeof u !== "string") return null;
+    if (u.indexOf("{{") !== -1) return null;
+    if (!u.replace(/\s/g, "")) return null;
+    return u;
+  }
+  function withSlash(u) {
+    return u.charAt(u.length - 1) !== "/" ? u + "/" : u;
+  }
+  function joinUrl(base, path) {
+    var b = withSlash(base);
+    if (!path) return b;
+    if (/^https?:\/\//.test(path)) return path;
+    return b + String(path).replace(/^\//, "");
+  }
+  function parseDate(s) {
+    if (!s) return null;
+    var t = new Date(String(s).indexOf("T") === -1 && String(s).indexOf("Z") === -1
+      ? String(s).replace(" ", "T") + "Z" : s);
+    return isNaN(t.getTime()) ? null : t;
+  }
+  function fmtDate(s) {
+    var t = parseDate(s);
+    if (!t) return s ? String(s).slice(0, 16) : "";
+    try { return t.toLocaleString("fr-FR"); } catch (e) { return t.toISOString().slice(0, 16); }
+  }
+
+  /* Résolution des bases. `env` permet les tests sans navigateur :
+   * { hostname, barUrls, configUrls, tabHrefs, dracoUrls }. */
+  function resolveUrls(env) {
+    env = env || {};
+    var hostname = env.hostname;
+    if (hostname === undefined) {
+      try { hostname = (global.location && global.location.hostname) || ""; } catch (e) { hostname = ""; }
+    }
+    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]);
+      if (!u && dev) u = DEV_URLS[app] || null;
+      if (!u) {
+        var href = null;
+        if (env.tabHrefs && env.tabHrefs[app]) href = 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) {
+        /* ObsiGate : window.DRACO_URLS injecté par le backend. */
+        try {
+          if (global.DRACO_URLS && global.DRACO_URLS[app]) u = cleanUrl(global.DRACO_URLS[app]);
+        } catch (e) { /* rien */ }
+      }
+      if (!u) u = DEFAULT_URLS[app];
+      urls[app] = withSlash(u);
+    });
+    return urls;
+  }
+  function browserEnv() {
+    var cfg = global.DRACO_BAR_CONFIG || {};
+    var bar = global.DRACO_BAR || {};
+    var tabs = {};
+    try {
+      if (typeof document !== "undefined" && document.querySelectorAll) {
+        var nodes = document.querySelectorAll(".draco-apptab[data-app]");
+        for (var i = 0; i < nodes.length; i++) {
+          tabs[nodes[i].getAttribute("data-app")] = nodes[i].getAttribute("href");
+        }
+      }
+    } catch (e) { /* rien */ }
+    return {
+      barUrls: bar.urls || null, configUrls: cfg.urls || null,
+      tabHrefs: tabs, dracoUrls: global.DRACO_URLS || null
+    };
+  }
+
+  function normalizeFlowdeck(base, payload) {
+    var list = (payload && payload.notifications) || [];
+    return list.map(function (n) {
+      return {
+        app: "flowdeck", id: n.id, title: n.title || "(sans titre)",
+        detail: n.message || "", date: n.created_at || "",
+        active: !n.is_read, state: n.is_read ? "lue" : "active",
+        kind: n.ntype || "", url: joinUrl(base, n.url || "")
+      };
+    });
+  }
+  function normalizeTiktak(base, payload) {
+    var list = Array.isArray(payload) ? payload : (payload && payload.notifications) || [];
+    return list.map(function (n) {
+      return {
+        app: "tiktak", id: n.id, title: n.title || "(sans titre)",
+        detail: n.body || "", date: n.created_at || "",
+        active: !n.is_read, state: n.is_read ? "lue" : "active",
+        kind: n.kind || "",
+        url: n.task_id ? withSlash(base) + "?task=" + n.task_id : joinUrl(base, "notifications")
+      };
+    });
+  }
+  function normalizeKanbante(base, payload) {
+    var list = (payload && payload.events) || [];
+    return list.map(function (e) {
+      var label = EVENT_LABELS[e.event_type] || e.event_type || "événement";
+      var detail = (e.from_column ? e.from_column + " → " : "") + (e.to_column || "");
+      return {
+        app: "kanbante", id: e.id,
+        title: (e.repo_full_name || "?") + " #" + e.issue_number + " — " + label,
+        detail: detail, date: e.created_at || "",
+        active: false, state: label, kind: e.event_type || "",
+        url: joinUrl(base, "board/" + (e.repo_full_name || ""))
+      };
+    });
+  }
+  /* Actives d'abord, puis date décroissante (sans date en dernier). */
+  function sortAlerts(list) {
+    return list.slice().sort(function (a, b) {
+      if (a.active !== b.active) return a.active ? -1 : 1;
+      var da = parseDate(a.date), db = parseDate(b.date);
+      if (da && db) return db - da;
+      if (da) return -1;
+      if (db) return 1;
+      return 0;
+    });
+  }
+  function countActive(list) {
+    var n = 0;
+    list.forEach(function (a) { if (a.active) n++; });
+    return n;
+  }
+
+  /* ---- Rendu (navigateur seulement) ---- */
+  var panel = null, listEl = null, badgeTimer = null;
+
+  function el(tag, cls, text) {
+    var d = document.createElement(tag);
+    if (cls) d.className = cls;
+    if (text !== undefined && text !== null) d.textContent = text;
+    return d;
+  }
+  function ensurePanel() {
+    if (panel) return panel;
+    var ov = el("div", "draco-alertes-overlay");
+    ov.setAttribute("role", "dialog");
+    ov.setAttribute("aria-label", "Alertes unifiées");
+    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);
+    head.appendChild(close);
+    box.appendChild(head);
+    box.appendChild(note);
+    listEl = el("div", "draco-alertes-list");
+    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();
+    });
+    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;
+    }
+    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;
+  }
+  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."));
+    }
+    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 fetchJson(url, timeoutMs) {
+    var ctrl = null, timer = null;
+    try {
+      if (typeof AbortController !== "undefined") {
+        ctrl = new AbortController();
+        timer = setTimeout(function () { ctrl.abort(); }, timeoutMs || 8000);
+      }
+    } catch (e) { ctrl = null; }
+    var opts = { credentials: "include" };
+    if (ctrl) opts.signal = ctrl.signal;
+    return fetch(url, opts).then(function (r) {
+      if (timer) clearTimeout(timer);
+      if (!r.ok) {
+        var err = new Error("HTTP " + r.status);
+        err.status = r.status;
+        throw err;
+      }
+      return r.json();
+    }).catch(function (e) {
+      if (timer) clearTimeout(timer);
+      throw e;
+    });
+  }
+  function loadAll() {
+    var urls = resolveUrls(browserEnv());
+    var jobs = {
+      flowdeck: fetchJson(urls.flowdeck + "api/notifications?limit=50")
+        .then(function (p) { return { items: normalizeFlowdeck(urls.flowdeck, p) }; }),
+      tiktak: fetchJson(urls.tiktak + "api/notifications")
+        .then(function (p) { return { items: normalizeTiktak(urls.tiktak, p) }; }),
+      kanbante: fetchJson(urls.kanbante + "api/events?limit=100")
+        .then(function (p) { return { items: normalizeKanbante(urls.kanbante, 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) {
+        var msg = (e && e.status === 401)
+          ? "Connexion requise sur " + APP_LABELS[k] + " : ouvrez sa page native pour vous y connecter, puis rouvrez ce panneau."
+          : "Application injoignable depuis cet hôte (" + (e && e.message ? e.message : "erreur réseau") + ").";
+        return [k, { items: [], error: msg }];
+      });
+    })).then(function (pairs) {
+      var results = { obsigate: { items: [] } };
+      pairs.forEach(function (kv) { results[kv[0]] = kv[1]; });
+      return { urls: urls, results: results };
+    });
+  }
+  function setBadge(n) {
+    try {
+      if (global.DRACO_BAR && typeof global.DRACO_BAR.setCounts === "function") {
+        global.DRACO_BAR.setCounts({ alertes: n });
+        return;
+      }
+    } catch (e) { /* repli ci-dessous */ }
+    try {
+      document.querySelectorAll('.draco-badge[data-badge="alertes"]').forEach(function (b) {
+        b.textContent = n;
+        b.hidden = !(n > 0);
+      });
+    } catch (e) { /* rien */ }
+  }
+  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);
+    }).catch(function () { /* pastille optionnelle : la barre vit sans */ });
+  }
+  function openPanel() {
+    ensurePanel();
+    panel.style.display = "flex";
+    listEl.textContent = "";
+    listEl.appendChild(el("p", "draco-alertes-empty", "Chargement des alertes…"));
+    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));
+    }).catch(function () {
+      render({ obsigate: { items: [] } }, resolveUrls(browserEnv()));
+    });
+  }
+
+  var api = {
+    open: openPanel, close: closePanel, refreshBadge: refreshBadge,
+    _test: {
+      resolveUrls: resolveUrls, normalizeFlowdeck: normalizeFlowdeck,
+      normalizeTiktak: normalizeTiktak, normalizeKanbante: normalizeKanbante,
+      sortAlerts: sortAlerts, countActive: countActive,
+      isDevHost: isDevHost, DEFAULT_URLS: DEFAULT_URLS, DEV_URLS: DEV_URLS
+    }
+  };
+  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). */
+  if (typeof document !== "undefined" && document.addEventListener) {
+    document.addEventListener("DOMContentLoaded", function () {
+      if (badgeTimer) clearTimeout(badgeTimer);
+      badgeTimer = setTimeout(refreshBadge, 300);
+    });
+  }
+})(typeof window !== "undefined" ? window : globalThis);

static/js/recherche.js

@@ -0,0 +1,992 @@
+/* Recherche partout — page de résultats unifiée (fusion-trois-apps #68,
+ * chantier 2+3 : onglets, « Tout voir », focus).
+ *
+ * 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.
+ *
+ * Présentation en onglets : Tout, ObsiGate, Flowdeck, TikTak, Kanbante,
+ * Console Spark. « Tout » = les 4 sections groupées, chaque liste
+ * tronquée à PER_APP_LIMIT ; un onglet application = tous les résultats
+ * de cette application (aucune troncature côté client — la requête
+ * ObsiGate part avec limit=FULL_LIMIT, les autres API renvoient leur
+ * jeu complet). « Tout voir » d'une section ne quitte plus la page :
+ * il bascule vers l'onglet de l'application (son href reste une URL
+ * partageable ?q=&tab= au cas où le JS ne tournerait pas).
+ * L'onglet actif vit dans l'URL (?tab=, absent = Tout) : partageable,
+ * et le retour arrière navigateur le restaure (popstate).
+ *
+ * Compteurs : chaque onglet affiche le nombre TOTAL de résultats de
+ * son application (pas le nombre tronqué affiché dans « Tout »),
+ * « … » pendant le chargement, « 0 » pour un vide honnête, rien pour
+ * une section en erreur/indisponible (pas de faux 0). L'onglet Tout
+ * affiche « … » tant qu'une section charge, sinon la somme des totaux
+ * connus (une section en erreur compte pour 0) ; il est vide si les
+ * 4 sections sont en erreur ou si aucune recherche n'a encore eu lieu.
+ * Une section injoignable ne casse jamais les autres.
+ *
+ * Focus : l'attribut autofocus seul ne survit pas au chargement des
+ * surcouches (barre, palette, app) — la page appelle donc focus()
+ * explicitement en fin d'init (plus un rappel rAF/timeout et un
+ * rappel pageshow). Cliquer la barre « Rechercher partout » (bouton
+ * data-act="palette") sur cette même page replace aussi le curseur
+ * dans la boîte ; « / » et Ctrl+K / ⌘K font de même, comme avant.
+ *
+ * Contrat d'API (audité, rien d'inventé) :
+ * - ObsiGate : GET {base}/api/search?q=&vault=all&limit=
+ *   -> { 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=
+ *   -> { 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).
+ * - Console Spark : AUCUN endpoint de recherche mergé au moment de
+ *   cette livraison (agent-commun : seule la PR #12 est ouverte, autre
+ *   programme — ce dépôt n'est pas touché ici). Le code tente quand
+ *   même l'appel conventionnel GET {base-console}/api/search?q= (même
+ *   convention que les autres hôtes ; chemin À CONFIRMER avec le
+ *   travailleur console dès que son endpoint atterrit) et, en cas
+ *   d'échec, de HTTP non-OK ou de format non reconnu, affiche
+ *   honnêtement « Console Spark : recherche indisponible pour
+ *   l'instant » — jamais de faux résultats, jamais de faux 0. La base
+ *   console vient, dans l'ordre, de data-base-console rendu par l'hôte,
+ *   de window.DRACO_URLS.agent (ObsiGate) / window.DRACO_AGENT_URL
+ *   (TikTak), de la dérivation -dev si l'hôte courant est -dev, du
+ *   href d'un onglet de barre data-app="console"/"spark" s'il existe,
+ *   sinon du défaut prod agent.dracodev.net. L'onglet console n'est
+ *   interrogé que lorsqu'il est affiché (ou quand une recherche a lieu
+ *   pendant qu'il est affiché) : « Tout » ne le contient pas, pour ne
+ *   pas polluer la vue groupée d'un message d'indisponibilité.
+ *
+ * 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 #68).
+ * 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.
+ * Le correctif CORS lui-même est chez un autre travailleur.
+ */
+(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 PROD_AGENT = "https://agent.dracodev.net/";
+  var DEV_AGENT = "https://agent-dev.dracodev.net/";
+  var CONSOLE_SEARCH_PATH = "api/search";
+  var APPS = [
+    { key: "obsigate", label: "ObsiGate" },
+    { key: "flowdeck", label: "Flowdeck" },
+    { key: "tiktak", label: "TikTak" },
+    { key: "kanbante", label: "Kanbante" },
+  ];
+  var CONSOLE_APP = { key: "console", label: "Console Spark" };
+  var TABS = ["all", "obsigate", "flowdeck", "tiktak", "kanbante", "console"];
+  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;
+  var FULL_LIMIT = 100;
+
+  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;
+  }
+
+  /* Base console : explicite > URL agent injectée par l'hôte >
+   * dérivation -dev > href d'onglet de barre console/spark > prod.
+   * opts : { host, explicit, agentUrl, tabHrefs:{} } */
+  function resolveConsoleBase(opts) {
+    opts = opts || {};
+    var u = cleanUrl(opts.explicit);
+    if (!u) u = cleanUrl(opts.agentUrl);
+    if (!u && isDevHost(opts.host)) u = DEV_AGENT;
+    if (!u)
+      u = cleanUrl(
+        opts.tabHrefs && (opts.tabHrefs.console || opts.tabHrefs.spark)
+      );
+    if (!u) u = PROD_AGENT;
+    return withSlash(u);
+  }
+
+  /* Onglet valide dans l'URL, sinon "all". */
+  function parseTab(v) {
+    return TABS.indexOf(v) !== -1 ? v : "all";
+  }
+
+  /* Sections visibles pour un onglet. « Tout » = les 4 sections
+   * groupées (vue #68) ; la console n'y figure pas (voir en-tête). */
+  function visibleKeys(tab) {
+    tab = parseTab(tab);
+    if (tab === "all") return APPS.map(function (a) { return a.key; });
+    return [tab];
+  }
+
+  /* Troncature d'affichage : liste complète dans l'onglet propre à
+   * l'application, PER_APP_LIMIT partout ailleurs (vue « Tout »). */
+  function pageItems(items, full) {
+    items = items || [];
+    return full ? items : items.slice(0, PER_APP_LIMIT);
+  }
+
+  /* ?q=&tab= partageable. tab "all" omis (c'est le défaut). */
+  function buildSearchUrl(q, tab) {
+    var parts = [];
+    if (q) parts.push("q=" + encodeURIComponent(q));
+    tab = parseTab(tab);
+    if (tab !== "all") parts.push("tab=" + encodeURIComponent(tab));
+    return parts.length ? "?" + parts.join("&") : "";
+  }
+
+  /* Libellés des compteurs d'onglets à partir des états :
+   * states : { key: { status, total } }.
+   * Chargement -> "…", ok/vide -> total ("0" honnête),
+   * erreur/indisponible/inactif -> "" (pas de faux 0).
+   * Tout : "…" tant qu'une section charge, sinon somme des totaux
+   * connus, "" si les 4 sections sont en erreur/inactives. */
+  function tabCounts(states) {
+    states = states || {};
+    var out = {};
+    function labelFor(key) {
+      var st = states[key] || {};
+      if (st.status === "loading") return "…";
+      if (st.status === "ok" || st.status === "empty") return String(st.total || 0);
+      return "";
+    }
+    var allLoading = false;
+    var allTotal = 0;
+    var allKnown = false;
+    APPS.forEach(function (app) {
+      var st = states[app.key] || {};
+      out[app.key] = labelFor(app.key);
+      if (st.status === "loading") allLoading = true;
+      if (st.status === "ok" || st.status === "empty") {
+        allKnown = true;
+        allTotal += st.total || 0;
+      }
+    });
+    out.console = labelFor("console");
+    out.all = allLoading ? "…" : allKnown ? String(allTotal) : "";
+    return out;
+  }
+
+  function searchPath(app, q, full) {
+    if (app === "obsigate") {
+      return (
+        "api/search?q=" +
+        encodeURIComponent(q) +
+        "&vault=all&limit=" +
+        (full ? FULL_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).
+   * full=true : aucune troncature (stockage complet) ; sinon PER_APP_LIMIT
+   * (comportement historique, conservé par défaut pour les tests). */
+  function normalize(app, data, base, q, full) {
+    data = data || {};
+    var limit = full ? null : PER_APP_LIMIT;
+    function cut(arr) {
+      return limit == null ? arr : arr.slice(0, limit);
+    }
+    if (app === "obsigate") {
+      return cut(data.results || []).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 cut(items).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 cut(data.tasks || []).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 cut(rows).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 [];
+  }
+
+  /* Normalisation console, défensive : accepte results/discussions/
+   * items. Un élément sans URL exploitable (http(s), /relatif, #ancre)
+   * garde url=null et sera rendu en <span>, pas en faux lien profond.
+   * Retourne { recognized, items } : recognized=false -> l'appelant
+   * affiche « indisponible », jamais un vide mensonger. */
+  function normalizeConsole(data, base) {
+    data = data || {};
+    var list = null;
+    if (Array.isArray(data.results)) list = data.results;
+    else if (Array.isArray(data.discussions)) list = data.discussions;
+    else if (Array.isArray(data.items)) list = data.items;
+    if (!list) return { recognized: false, items: [] };
+    var items = list.map(function (r) {
+      r = r || {};
+      var raw = r.url || r.href || r.link || "";
+      var url = null;
+      if (/^https?:\/\//.test(raw)) url = raw;
+      else if (raw.charAt(0) === "/" || raw.charAt(0) === "#") url = base + String(raw).replace(/^\//, "");
+      return {
+        title: r.title || r.name || r.subject || "Sans titre",
+        snippet: snippetOf(r.snippet || r.excerpt || r.preview || r.body || ""),
+        context: r.subtitle || r.source || r.type || "",
+        url: url,
+      };
+    });
+    return { recognized: true, items: items };
+  }
+
+  /* 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) {
+    if (key === "console") return CONSOLE_APP.label;
+    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,
+    resolveConsoleBase: resolveConsoleBase,
+    parseTab: parseTab,
+    visibleKeys: visibleKeys,
+    pageItems: pageItems,
+    buildSearchUrl: buildSearchUrl,
+    tabCounts: tabCounts,
+    searchPath: searchPath,
+    normalize: normalize,
+    normalizeConsole: normalizeConsole,
+    nativeSearchUrl: nativeSearchUrl,
+    PROD: PROD,
+    DEV: DEV,
+    PROD_AGENT: PROD_AGENT,
+    DEV_AGENT: DEV_AGENT,
+    CONSOLE_SEARCH_PATH: CONSOLE_SEARCH_PATH,
+    PER_APP_LIMIT: PER_APP_LIMIT,
+    FULL_LIMIT: FULL_LIMIT,
+  };
+  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, full) {
+    /* state : { status: "idle"|"loading"|"empty"|"error"|"ok"|"unavailable",
+     *   items (complets), message, q, base, app }.
+     * full=true (onglet propre à l'app) : tout afficher ; sinon
+     * PER_APP_LIMIT (vue « Tout »). Le compteur affiche le TOTAL. */
+    var body = section.querySelector(".rp-body");
+    var count = section.querySelector(".rp-count");
+    var toutVoir = section.querySelector(".rp-all");
+    if (toutVoir) {
+      try {
+        toutVoir.href =
+          global.location.pathname + buildSearchUrl(state.q, state.app);
+      } catch (e) {}
+      toutVoir.textContent = "Tout voir";
+      toutVoir.title = "Afficher tous les résultats de " + appLabel(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 === "unavailable") {
+      count.textContent = "";
+      body.innerHTML =
+        '<p class="rp-state">Console Spark : recherche indisponible pour l\'instant' +
+        (state.message ? " (" + esc(state.message) + ")" : "") +
+        ".</p>";
+      return;
+    }
+    if (state.status === "idle") {
+      count.textContent = "";
+      body.innerHTML =
+        '<p class="rp-state">Tapez une recherche ci-dessus.</p>';
+      return;
+    }
+    if (state.status === "empty") {
+      count.textContent = "0";
+      body.innerHTML =
+        '<p class="rp-state">Aucun résultat pour « ' + esc(state.q) + " ».</p>";
+      return;
+    }
+    var shown = pageItems(state.items, full);
+    count.textContent = String(state.items.length);
+    body.innerHTML = shown
+      .map(function (item) {
+        var inner =
+          '<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>"
+            : "");
+        if (item.url) {
+          return (
+            '<a class="rp-item" data-rp-link href="' + esc(item.url) + '">' + inner + "</a>"
+          );
+        }
+        return '<span class="rp-item">' + inner + "</span>";
+      })
+      .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 consoleBase = resolveConsoleBase({
+      host: global.location.hostname,
+      explicit: root.getAttribute("data-base-console"),
+      agentUrl:
+        (global.DRACO_URLS && global.DRACO_URLS.agent) || global.DRACO_AGENT_URL,
+      tabHrefs: tabHrefs,
+    });
+    var allKeys = APPS.map(function (a) { return a.key; }).concat(["console"]);
+    var sections = {};
+    allKeys.forEach(function (key) {
+      var el = document.querySelector('[data-rp-section="' + key + '"]');
+      if (el) sections[key] = el;
+    });
+    var tabButtons = {};
+    document.querySelectorAll("[data-rp-tab]").forEach(function (btn) {
+      tabButtons[btn.getAttribute("data-rp-tab")] = btn;
+    });
+    var tablist = document.querySelector(".rp-tabs");
+
+    /* États par application (+ console). total = items.length. */
+    var states = {};
+    allKeys.forEach(function (key) {
+      states[key] = {
+        status: "idle",
+        items: [],
+        message: "",
+        q: "",
+        base: key === "console" ? consoleBase : bases[key],
+        app: key,
+      };
+    });
+
+    var activeTab = "all";
+    var currentQ = "";
+    var runId = 0;
+    var consoleFetchedQ = null;
+    var debounceTimer = null;
+
+    function statesForCounts() {
+      var out = {};
+      allKeys.forEach(function (key) {
+        out[key] = { status: states[key].status, total: states[key].items.length };
+      });
+      return out;
+    }
+
+    function renderTabs() {
+      var counts = tabCounts(statesForCounts());
+      Object.keys(tabButtons).forEach(function (key) {
+        var btn = tabButtons[key];
+        var selected = key === activeTab;
+        btn.classList.toggle("active", selected);
+        btn.setAttribute("aria-selected", selected ? "true" : "false");
+        btn.tabIndex = selected ? 0 : -1;
+        var span = btn.querySelector(".rp-tab-count");
+        if (span) span.textContent = counts[key] || "";
+      });
+    }
+
+    /* Bascule d'onglet : visibilité des sections, re-rendu (plein dans
+     * l'onglet propre à l'app, tronqué dans « Tout »), compteurs.
+     * opts : { push (historique), focusTab }. */
+    function applyTab(tab, opts) {
+      opts = opts || {};
+      activeTab = parseTab(tab);
+      try {
+        root.setAttribute("data-rp-tab", activeTab);
+      } catch (e) {}
+      var visible = visibleKeys(activeTab);
+      allKeys.forEach(function (key) {
+        var sec = sections[key];
+        if (!sec) return;
+        var show = visible.indexOf(key) !== -1;
+        sec.hidden = !show;
+        if (show) renderSection(sec, states[key], activeTab === key);
+        var tv = sec.querySelector(".rp-all");
+        if (tv) tv.hidden = activeTab === key;
+      });
+      renderTabs();
+      if (opts.push) {
+        try {
+          global.history.pushState(
+            null,
+            "",
+            global.location.pathname + buildSearchUrl(currentQ, activeTab)
+          );
+        } catch (e) {}
+      }
+      if (opts.focusTab && tabButtons[activeTab]) {
+        try {
+          tabButtons[activeTab].focus();
+        } catch (e) {}
+      }
+    }
+
+    function setTab(tab, opts) {
+      applyTab(tab, opts);
+      /* La console n'est interrogée qu'une fois affichée. */
+      if (parseTab(tab) === "console" && currentQ && consoleFetchedQ !== currentQ) {
+        fetchConsole(currentQ, runId);
+      }
+    }
+
+    function fetchConsole(q, myRun) {
+      var sec = sections.console;
+      if (!sec) return;
+      consoleFetchedQ = q;
+      states.console = {
+        status: "loading",
+        items: [],
+        message: "",
+        q: q,
+        base: consoleBase,
+        app: "console",
+      };
+      renderSection(sec, states.console, true);
+      renderTabs();
+      var url = consoleBase + CONSOLE_SEARCH_PATH + "?q=" + encodeURIComponent(q);
+      fetchSection("console", 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) msg = "HTTP " + err.status;
+          else msg = "injoignable (CORS ou réseau)";
+          states.console = {
+            status: "unavailable",
+            items: [],
+            message: msg,
+            q: q,
+            base: consoleBase,
+            app: "console",
+          };
+        } else {
+          var norm = normalizeConsole(data, consoleBase);
+          if (!norm.recognized) {
+            states.console = {
+              status: "unavailable",
+              items: [],
+              message: "format inattendu",
+              q: q,
+              base: consoleBase,
+              app: "console",
+            };
+          } else {
+            states.console = {
+              status: norm.items.length ? "ok" : "empty",
+              items: norm.items,
+              message: "",
+              q: q,
+              base: consoleBase,
+              app: "console",
+            };
+          }
+        }
+        renderSection(sec, states.console, true);
+        renderTabs();
+      });
+    }
+
+    function runSearch(q) {
+      currentQ = q;
+      var myRun = ++runId;
+      if (!q) {
+        allKeys.forEach(function (key) {
+          var sec = sections[key];
+          if (!sec) return;
+          states[key] = {
+            status: "idle",
+            items: [],
+            message: "",
+            q: "",
+            base: key === "console" ? consoleBase : bases[key],
+            app: key,
+          };
+          renderSection(sec, states[key], activeTab === key);
+        });
+        consoleFetchedQ = null;
+        renderTabs();
+        return;
+      }
+      APPS.forEach(function (app) {
+        var sec = sections[app.key];
+        if (!sec) return;
+        states[app.key] = {
+          status: "loading",
+          items: [],
+          message: "",
+          q: q,
+          base: bases[app.key],
+          app: app.key,
+        };
+        renderSection(sec, states[app.key], activeTab === app.key);
+        var url;
+        if (app.key === hostApp) {
+          /* Même origine : pas de CORS, pas de CSP cross-origin. */
+          url = "/" + searchPath(app.key, q, true);
+        } else {
+          url = bases[app.key] + searchPath(app.key, q, true);
+        }
+        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)";
+            states[app.key] = {
+              status: "error",
+              items: [],
+              message: msg,
+              q: q,
+              base: bases[app.key],
+              app: app.key,
+            };
+          } else {
+            var items = normalize(app.key, data, bases[app.key], q, true);
+            states[app.key] = {
+              status: items.length ? "ok" : "empty",
+              items: items,
+              message: "",
+              q: q,
+              base: bases[app.key],
+              app: app.key,
+            };
+          }
+          renderSection(sec, states[app.key], activeTab === app.key);
+          renderTabs();
+        });
+      });
+      /* Console : seulement si son onglet est affiché ; sinon son
+       * compteur reste vide (pas de faux 0) jusqu'à son activation. */
+      if (activeTab === "console") {
+        fetchConsole(q, myRun);
+      } else {
+        states.console = {
+          status: "idle",
+          items: [],
+          message: "",
+          q: q,
+          base: consoleBase,
+          app: "console",
+        };
+        consoleFetchedQ = null;
+        renderTabs();
+      }
+    }
+
+    function scheduleSearch(q, immediate) {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      if (immediate) {
+        runSearch(q);
+        return;
+      }
+      debounceTimer = setTimeout(function () {
+        runSearch(q);
+      }, DEBOUNCE_MS);
+    }
+
+    function syncUrl(q) {
+      try {
+        global.history.replaceState(
+          null,
+          "",
+          global.location.pathname + buildSearchUrl(q, activeTab)
+        );
+      } catch (e) {}
+    }
+
+    function focusSearch() {
+      try {
+        input.focus({ preventScroll: true });
+      } catch (e) {
+        try {
+          input.focus();
+        } catch (e2) {}
+      }
+    }
+
+    function visibleLinks() {
+      return Array.prototype.slice
+        .call(document.querySelectorAll("[data-rp-link]"))
+        .filter(function (a) {
+          var s = a.closest ? a.closest("[data-rp-section]") : null;
+          return !s || !s.hidden;
+        });
+    }
+
+    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 = visibleLinks()[0];
+        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;
+        }
+        /* Sur un onglet, ↑/↓ ne déplacent pas les résultats : les
+         * flèches ←/→ du tablist s'en chargent (voir ci-dessous). */
+        if (target && target.closest && target.closest(".rp-tab")) return;
+        if (!typing && (e.key === "ArrowDown" || e.key === "ArrowUp")) {
+          moveFocus(e.key === "ArrowDown" ? 1 : -1, e);
+        }
+      },
+      true
+    );
+
+    /* « Tout voir » reste sur la page : bascule vers l'onglet. */
+    root.addEventListener("click", function (e) {
+      var all = e.target && e.target.closest ? e.target.closest(".rp-all") : null;
+      if (!all) return;
+      var sec = all.closest ? all.closest("[data-rp-section]") : null;
+      if (!sec) return;
+      e.preventDefault();
+      setTab(sec.getAttribute("data-rp-section"), { push: true, focusTab: true });
+    });
+
+    /* Clic sur la barre « Rechercher partout » (bouton
+     * data-act="palette") pendant qu'on est déjà sur la page :
+     * replacer le curseur dans la boîte au lieu de recharger. */
+    document.addEventListener("click", function (e) {
+      var p = e.target && e.target.closest ? e.target.closest('[data-act="palette"]') : null;
+      if (!p) return;
+      e.preventDefault();
+      focusSearch();
+      try {
+        input.select();
+      } catch (err) {}
+    });
+
+    /* Onglets : clic + clavier (←/→, Début/Fin). */
+    Object.keys(tabButtons).forEach(function (key) {
+      tabButtons[key].addEventListener("click", function () {
+        setTab(key, { push: true });
+      });
+    });
+    if (tablist) {
+      tablist.addEventListener("keydown", function (e) {
+        var order = TABS;
+        var idx = order.indexOf(activeTab);
+        var next = null;
+        if (e.key === "ArrowRight") next = order[(idx + 1) % order.length];
+        else if (e.key === "ArrowLeft")
+          next = order[(idx - 1 + order.length) % order.length];
+        else if (e.key === "Home") next = order[0];
+        else if (e.key === "End") next = order[order.length - 1];
+        if (!next) return;
+        e.preventDefault();
+        setTab(next, { push: true, focusTab: true });
+      });
+    }
+
+    /* Retour arrière navigateur : restaurer q + onglet. */
+    global.addEventListener("popstate", function () {
+      var params = new URLSearchParams(global.location.search);
+      var q = (params.get("q") || "").trim();
+      input.value = q;
+      applyTab(params.get("tab"));
+      runSearch(q);
+    });
+
+    function moveFocus(delta, e) {
+      var links = visibleLinks();
+      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();
+    var initialTab = parseTab(params.get("tab"));
+    if (initialQ) input.value = initialQ;
+    applyTab(initialTab);
+    runSearch(initialQ);
+
+    /* Focus explicite (voir en-tête) : l'attribut autofocus seul ne
+     * survit pas au chargement des surcouches. */
+    focusSearch();
+    try {
+      if (global.requestAnimationFrame) global.requestAnimationFrame(focusSearch);
+    } catch (e) {}
+    try {
+      setTimeout(focusSearch, 0);
+    } catch (e) {}
+    global.addEventListener("pageshow", function (e) {
+      if (e.persisted) focusSearch();
+    });
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})(
+  typeof window !== "undefined"
+    ? window
+    : typeof globalThis !== "undefined"
+      ? globalThis
+      : this
+);

tests/draco-alertes.test.js

@@ -0,0 +1,84 @@
+// Tests unitaires (node:test) du module partagé draco-alertes.js.
+// Exécutés dans la sandbox : node --test draco-alertes.test.js
+// Aucune donnée inventée : les payloads reprennent la forme exacte
+// des API réelles (Flowdeck /api/notifications, TikTak
+// /api/notifications, Kanbante /api/events).
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const t = require("../static/js/draco-alertes.js");
+
+test("resolveUrls: config explicite > hote -dev > href > defaut prod", () => {
+  const prod = t.resolveUrls({ hostname: "tiktak.dracodev.net", tabHrefs: {} });
+  assert.equal(prod.tiktak, "https://tiktak.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/");
+  const explicit = t.resolveUrls({
+    hostname: "tiktak-dev.dracodev.net",
+    configUrls: { flowdeck: "https://flowdeck.dracodev.net/" },
+  });
+  assert.equal(explicit.flowdeck, "https://flowdeck.dracodev.net/");
+  const href = t.resolveUrls({
+    hostname: "example.org",
+    tabHrefs: { kanbante: "https://kanbante-dev.dracodev.net/" },
+  });
+  assert.equal(href.kanbante, "https://kanbante-dev.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(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(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 + 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" },
+    { 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);
+});

tests/recherche.test.js

@@ -0,0 +1,150 @@
+/* Tests Node sans navigateur de recherche.js (logique pure).
+ * Usage : node recherche.test.js — sortie 0 si tout passe. */
+"use strict";
+const assert = require("node:assert/strict");
+const rp = require("../static/js/recherche.js");
+
+let n = 0;
+function ok(cond, label) {
+  assert.ok(cond, label);
+  n += 1;
+}
+
+/* esc */
+ok(rp.esc('<a href="x">&') === "&lt;a href=&quot;x&quot;&gt;&amp;", "esc échappe HTML");
+
+/* isDevHost : même règle que la barre v0.1.6 */
+ok(rp.isDevHost("tiktak-dev.dracodev.net") === true, "dev reconnu");
+ok(rp.isDevHost("tiktak.dracodev.net") === false, "prod non dev");
+ok(rp.isDevHost("x-dev.dracodev.net.evil") === false, "hôte piège rejeté");
+ok(rp.isDevHost("dev.dracodev.net") === false, "étiquette trop courte rejetée");
+ok(rp.isDevHost("TIKTAK-DEV.DRACODEV.NET") === true, "insensible à la casse");
+
+/* resolveBases : ordre explicite > barre > dev > href > prod */
+let b = rp.resolveBases({
+  host: "tiktak-dev.dracodev.net",
+  explicit: { obsigate: "https://og-perso.example/" },
+  barUrls: { flowdeck: "https://flowdeck-barre.example/" },
+  tabHrefs: { kanbante: "https://kanbante-href.example/" },
+});
+ok(b.obsigate === "https://og-perso.example/", "explicite prioritaire");
+ok(b.flowdeck === "https://flowdeck-barre.example/", "barre avant dev");
+ok(b.tiktak === "https://tiktak-dev.dracodev.net/", "dev pour l'hôte courant");
+ok(b.kanbante === "https://kanbante-dev.dracodev.net/", "dev avant href");
+b = rp.resolveBases({ host: "tiktak.dracodev.net", tabHrefs: { kanbante: "https://kanbante-href.example/" } });
+ok(b.kanbante === "https://kanbante-href.example/", "href en prod");
+ok(b.obsigate === "https://og.dracodev.net/", "défaut prod");
+b = rp.resolveBases({});
+ok(b.flowdeck === "https://flowdeck.dracodev.net/", "défaut prod sans hôte");
+
+/* searchPath */
+ok(rp.searchPath("obsigate", "café & thé") === "api/search?q=caf%C3%A9%20%26%20th%C3%A9&vault=all&limit=8", "path ObsiGate");
+ok(rp.searchPath("tiktak", "a b") === "api/search?q=a%20b", "path TikTak");
+
+/* normalize ObsiGate */
+let items = rp.normalize("obsigate", { results: [{ vault: "home-bruno", path: "Notes/Idée.md", title: "Idée", snippet: "extrait" }] }, "https://og-dev.dracodev.net/", "idée");
+ok(items.length === 1 && items[0].url === "https://og-dev.dracodev.net/#file=home-bruno:Notes%2FId%C3%A9e.md", "lien profond ObsiGate");
+ok(items[0].context === "home-bruno · Notes/Idée.md", "contexte ObsiGate");
+
+/* normalize Flowdeck */
+items = rp.normalize("flowdeck", { pages: [{ title: "P", excerpt: "ex", subtitle: "Espace", url: "/pages/42" }], collections: [{ title: "B", subtitle: "Database · Espace", url: "/db/7" }] }, "https://flowdeck-dev.dracodev.net/", "p");
+ok(items.length === 2 && items[0].url === "https://flowdeck-dev.dracodev.net/pages/42", "lien page Flowdeck");
+ok(items[1].url === "https://flowdeck-dev.dracodev.net/db/7", "lien base Flowdeck");
+
+/* normalize TikTak */
+items = rp.normalize("tiktak", { tasks: [{ id: 9, title: "Faire X", description: "d", status: "active", due_at: "2026-10-30 09:00:00" }] }, "https://tiktak-dev.dracodev.net/", "faire");
+ok(items[0].url === "https://tiktak-dev.dracodev.net/search?q=faire&task=9", "lien profond TikTak");
+ok(items[0].context === "Tâche · Active · échéance 2026-10-30", "contexte TikTak");
+
+/* normalize Kanbante */
+items = rp.normalize("kanbante", { groups: [{ full_name: "Projets/site", rows: [{ issue: { number: 12, title: "Bug", body: "corps" }, column: "in_progress" }] }] }, "https://kanbante-dev.dracodev.net/", "bug");
+ok(items[0].title === "#12 Bug" && items[0].url === "https://kanbante-dev.dracodev.net/board/Projets/site", "lien tableau Kanbante");
+ok(items[0].context === "Projets/site · En cours", "contexte Kanbante");
+
+/* nativeSearchUrl */
+ok(rp.nativeSearchUrl("tiktak", "https://tiktak-dev.dracodev.net/", "q") === "https://tiktak-dev.dracodev.net/search?q=q", "repli TikTak");
+ok(rp.nativeSearchUrl("obsigate", "https://og-dev.dracodev.net/", "q") === "https://og-dev.dracodev.net/", "repli ObsiGate = accueil (palette)");
+
+
+/* ---- Chantier 2+3 : onglets, compteurs, URL, console (logique pure) ---- */
+
+/* parseTab */
+ok(rp.parseTab("obsigate") === "obsigate", "onglet valide conservé");
+ok(rp.parseTab("console") === "console", "onglet console valide");
+ok(rp.parseTab("bidon") === "all", "onglet inconnu -> Tout");
+ok(rp.parseTab(undefined) === "all", "onglet absent -> Tout");
+
+/* visibleKeys : Tout = les 4 sections groupées, sans la console */
+ok(JSON.stringify(rp.visibleKeys("all")) === JSON.stringify(["obsigate", "flowdeck", "tiktak", "kanbante"]), "Tout = 4 sections, pas la console");
+ok(JSON.stringify(rp.visibleKeys("tiktak")) === JSON.stringify(["tiktak"]), "onglet app = sa seule section");
+ok(JSON.stringify(rp.visibleKeys("console")) === JSON.stringify(["console"]), "onglet console = sa seule section");
+ok(JSON.stringify(rp.visibleKeys("bidon")) === JSON.stringify(["obsigate", "flowdeck", "tiktak", "kanbante"]), "onglet inconnu -> Tout");
+
+/* pageItems : troncature Tout (8), complet dans l'onglet de l'app */
+let douze = Array.from({ length: 12 }, (_, i) => ({ title: "T" + i }));
+ok(rp.pageItems(douze, false).length === 8, "vue Tout tronquée à 8");
+ok(rp.pageItems(douze, true).length === 12, "onglet app sans troncature");
+
+/* tabCounts : "…" en chargement, total sinon, "" en erreur (pas de faux 0) */
+let c = rp.tabCounts({
+  obsigate: { status: "loading", total: 0 },
+  flowdeck: { status: "ok", total: 3 },
+  tiktak: { status: "empty", total: 0 },
+  kanbante: { status: "error", total: 0 },
+  console: { status: "idle", total: 0 },
+});
+ok(c.obsigate === "…", "compteur … pendant le chargement");
+ok(c.flowdeck === "3" && c.tiktak === "0", "compteur total, vide honnête à 0");
+ok(c.kanbante === "" && c.console === "", "erreur/inactif : pas de faux 0");
+ok(c.all === "…", "Tout = … tant qu'une section charge");
+c = rp.tabCounts({
+  obsigate: { status: "ok", total: 5 },
+  flowdeck: { status: "ok", total: 2 },
+  tiktak: { status: "empty", total: 0 },
+  kanbante: { status: "error", total: 0 },
+  console: { status: "ok", total: 4 },
+});
+ok(c.all === "7", "Tout = somme des totaux connus");
+ok(c.console === "4", "compteur console");
+c = rp.tabCounts({
+  obsigate: { status: "error", total: 0 },
+  flowdeck: { status: "error", total: 0 },
+  tiktak: { status: "error", total: 0 },
+  kanbante: { status: "error", total: 0 },
+  console: { status: "idle", total: 0 },
+});
+ok(c.all === "", "Tout vide si les 4 sections sont en erreur");
+
+/* buildSearchUrl : état onglet partageable */
+ok(rp.buildSearchUrl("café", "tiktak") === "?q=caf%C3%A9&tab=tiktak", "URL q+onglet");
+ok(rp.buildSearchUrl("x", "all") === "?q=x", "URL Tout sans param tab");
+ok(rp.buildSearchUrl("", "all") === "", "URL vide sans recherche ni onglet");
+ok(rp.buildSearchUrl("", "console") === "?tab=console", "URL onglet seul");
+
+/* searchPath complet (onglet) vs tronqué (Tout) */
+ok(rp.searchPath("obsigate", "café", true) === "api/search?q=caf%C3%A9&vault=all&limit=100", "path ObsiGate complet (100)");
+ok(rp.searchPath("obsigate", "café") === "api/search?q=caf%C3%A9&vault=all&limit=8", "path ObsiGate Tout (8)");
+
+/* normalize complet vs tronqué */
+let taches12 = Array.from({ length: 12 }, (_, i) => ({ id: i + 1, title: "T" + i, status: "active" }));
+ok(rp.normalize("tiktak", { tasks: taches12 }, "https://tiktak-dev.dracodev.net/", "t", true).length === 12, "normalize complet");
+ok(rp.normalize("tiktak", { tasks: taches12 }, "https://tiktak-dev.dracodev.net/", "t").length === 8, "normalize tronqué par défaut");
+
+/* normalizeConsole : formes tolérées, pas de faux lien, format inconnu signalé */
+let nc = rp.normalizeConsole({ results: [{ title: "D", url: "https://agent.dracodev.net/console/1", snippet: "s" }] }, "https://agent.dracodev.net/");
+ok(nc.recognized === true && nc.items[0].url === "https://agent.dracodev.net/console/1", "console : URL absolue conservée");
+nc = rp.normalizeConsole({ discussions: [{ name: "Conv", href: "/discussions/9" }] }, "https://agent-dev.dracodev.net/");
+ok(nc.recognized === true && nc.items[0].url === "https://agent-dev.dracodev.net/discussions/9", "console : URL relative préfixée");
+nc = rp.normalizeConsole({ items: [{ title: "Sans lien", id: 7 }] }, "https://agent.dracodev.net/");
+ok(nc.recognized === true && nc.items[0].url === null, "console : sans URL -> pas de faux lien");
+nc = rp.normalizeConsole({ autre: [] }, "https://agent.dracodev.net/");
+ok(nc.recognized === false, "console : format inconnu -> non reconnu (indisponible, pas vide)");
+
+/* resolveConsoleBase : explicite > agent injecté > dev > href barre > prod */
+ok(rp.resolveConsoleBase({ explicit: "https://agent-perso.example/", agentUrl: "https://agent-autre.example/" }) === "https://agent-perso.example/", "console : explicite prioritaire");
+ok(rp.resolveConsoleBase({ agentUrl: "https://agent-injecte.example/" }) === "https://agent-injecte.example/", "console : agent injecté par l'hôte");
+ok(rp.resolveConsoleBase({ host: "tiktak-dev.dracodev.net" }) === "https://agent-dev.dracodev.net/", "console : dérivation -dev");
+ok(rp.resolveConsoleBase({ host: "x.example", tabHrefs: { console: "https://console-perso.example/" } }) === "https://console-perso.example/", "console : href onglet barre");
+ok(rp.resolveConsoleBase({}) === "https://agent.dracodev.net/", "console : défaut prod");
+
+console.log("recherche.test.js : " + n + " assertions OK");

tests/test_draco_alertes.py

@@ -0,0 +1,63 @@
+"""Fusion #69 — Alertes unifiées (chantier 2, Flowdeck).
+
+Source réelle de Flowdeck : GET /api/notifications (non lues =
+actives, `url` relative pour le lien profond), déjà exposée et
+inchangée ici. Couverts : placeholder Alertes disparu, module servi,
+CSP connect-src avec les origines soeurs, CORS (origines soeurs
+ajoutées à allow_origins ; tiers sans en-tête).
+"""
+
+SOEURS = ("https://og.dracodev.net", "https://flowdeck.dracodev.net",
+          "https://tiktak.dracodev.net", "https://kanbante.dracodev.net")
+
+
+def test_barre_alertes_sans_placeholder_et_module_servi(client):
+    # Les pages applicatives authentifiées ne sont pas atteignables
+    # telles quelles dans la sandbox (l'écran de connexion est servi
+    # pour "/" comme pour "/dashboard") : on vérifie donc le gabarit
+    # livré lui-même, plus les fichiers statiques servis.
+    from pathlib import Path
+
+    gabarit = Path("app/templates/_draco_bar.html").read_text()
+    assert "Alertes unifiées : arrive avec la fédération" not in gabarit
+    assert "draco-alertes.js" in gabarit
+    assert "draco-alertes.css" in gabarit
+    assert "DRACO_ALERTES.open()" in gabarit
+    js = client.get("/static/js/draco-alertes.js")
+    assert js.status_code == 200
+    assert "DRACO_ALERTES" in js.text
+    assert "api/notifications" in js.text
+    css = client.get("/static/css/draco-alertes.css")
+    assert css.status_code == 200
+    assert "draco-alertes-overlay" in css.text
+
+
+def test_csp_connect_src_contient_les_soeurs(client):
+    # La CSP est posée sur toute réponse HTML, y compris l'écran de
+    # connexion servi ici : elle prouve les origines soeurs en
+    # connect-src pour les pages de l'hôte.
+    r = client.get("/")
+    csp = r.headers.get("content-security-policy", "")
+    assert "connect-src" in csp
+    for origine in SOEURS:
+        assert origine in csp, csp
+
+
+def test_notifications_api_et_cors_soeur(client):
+    r = client.get("/api/notifications")
+    assert r.status_code == 200
+    body = r.json()
+    assert isinstance(body["notifications"], list)
+    assert "unread" in body
+    r2 = client.options("/api/notifications",
+                        headers={"Origin": "https://tiktak.dracodev.net",
+                                 "Access-Control-Request-Method": "GET"})
+    assert r2.headers.get("access-control-allow-origin") == "https://tiktak.dracodev.net"
+    assert r2.headers.get("access-control-allow-credentials") == "true"
+    r3 = client.get("/api/notifications",
+                    headers={"Origin": "https://tiktak.dracodev.net"})
+    assert r3.headers.get("access-control-allow-origin") == "https://tiktak.dracodev.net"
+    r4 = client.options("/api/notifications",
+                        headers={"Origin": "https://evil.example",
+                                 "Access-Control-Request-Method": "GET"})
+    assert "access-control-allow-origin" not in r4.headers

tests/test_recherche.py

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