Rebase chantier 5 sur main post-#37/#38 : tests/test_draco_alertes.py (contenu #39 intact)

Rebase chantier 5 sur main post-#37/#38 : tests/draco-alertes.test.js (contenu #39 intact)
Rebase chantier 5 sur main post-#37/#38 : static/js/draco-barre.js (contenu #39 intact)
2026-10-28 14:27:38 -04:00 · 2026-10-28 14:27:35 -04:00 · 2026-10-28 14:27:32 -04:00 · 2026-10-28 14:27:29 -04:00 · 2026-10-28 14:27:27 -04:00 · 2026-10-28 14:27:24 -04:00
51 changed files with 6652 additions and 162 deletions
@@ -0,0 +1,27 @@
+# Kanbante — exemple d'environnement (copier en .env, jamais versionné)
+# Infrastructure (un seul Gitea pour dev et prod, hors renommage)
+GITEA_URL=https://git.dracodev.net
+GITEA_TOKEN=
+# Authentification locale
+KANBANTE_AUTH_USER=
+KANBANTE_AUTH_PASSWORD=
+KANBANTE_REQUIRE_AUTH=0
+# Noms publics dracodev — défauts = noms OFFICIELS (prod).
+# Environnement dev : déclarer ici les noms en -dev, sans toucher au code.
+KANBANTE_PUBLIC_URL=https://kanbante.dracodev.net
+DRACO_SSO_URL=https://og.dracodev.net
+DRACO_FLOWDECK_URL=https://flowdeck.dracodev.net
+DRACO_TIKTAK_URL=https://tiktak.dracodev.net
+AGENT_URL=https://agent.dracodev.net
+# Exemples dev (à décommenter sur l'hôte dev) :
+# KANBANTE_PUBLIC_URL=https://kanbante-dev.dracodev.net
+# DRACO_SSO_URL=https://og-dev.dracodev.net
+# DRACO_FLOWDECK_URL=https://flowdeck-dev.dracodev.net
+# DRACO_TIKTAK_URL=https://tiktak-dev.dracodev.net
+# AGENT_URL=https://agent-dev.dracodev.net
+# Journal d'événements du service d'agents (signé HMAC)
+# AGENT_EVENEMENTS_URL=  # vide = dérivé de AGENT_URL (/api/v1/evenements)
+AGENT_EVENEMENTS_CLE=
+# Pont SSO draco_session (émis par ObsiGate ; vide = inerte)
+DRACO_SESSION_SECRET=
+DRACO_SSO_MACHINE_KEY=
@@ -1,5 +1,338 @@
+## 0.37.3 — 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 ; CORS bornée à `/api/events`.
+- **Rechercher partout (#68)** : page `/recherche` unifiée par application, liens profonds dans l'environnement courant (dérivation `-dev` respectée), nouvel endpoint JSON `/api/search` ; la palette de la barre ouvre désormais `/recherche`.
+
 # Changelog

+## 0.37.2 — 2026-10-28 — Barre d'apps v0.1.6 vendangée (dérivation -dev, menu •••, compte)
+
+- **Barre d'apps** : vendange de `dracodev-commons` v0.1.6 — dérivation `-dev` par l'hôte courant, menu « ••• » par défaut, menu compte fonctionnel, spark sans dérivation inventée.
+
+## 0.37.1 — 2026-10-26
+
+### Ajouté — version du service d'agents dans le panneau Spark (mode sidebar)
+
+Carte fusion #64. Le pied du panneau Spark (`static/js/draco-panneau.js`)
+affiche désormais la ligne discrète et permanente « Service d'agents
+vX », comme la console pleine page. La version est lue **en direct**
+dans la santé du service (`GET /healthz` de l'origine que le panneau
+connaît déjà), à l'ouverture du panneau, avec cache de session — jamais
+une valeur codée en dur ; service injoignable ou panneau non configuré
+= rien d'affiché, aucune erreur visible.
+
+## 0.37.0 — 2026-10-26
+
+### Ajouté — tri « En attente de revue » sur le dashboard
+
+Demande de Bruno : pouvoir ordonner les projets — section
+**Épinglés** en tête — par ce qui attend sa validation.
+
+- Nouveau critère dans le sélecteur de tri du dashboard,
+  en première place après « Par défaut » : **🔍 En attente
+  de revue ↓** — les projets s'ordonnent par le nombre de
+  cartes dans la colonne de validation (clé `review` de
+  l'espace), décroissant.
+- Le compteur était déjà calculé pour les chips de
+  progression des cartes : il est maintenant exposé en
+  `data-review` sur chaque carte projet et consommé par le
+  moteur de tri partagé — le critère s'applique à **toutes
+  les grilles** (Épinglés, Actifs, Inactifs, Archivés),
+  avec ou sans regroupement par propriétaire, et la
+  préférence est mémorisée comme les autres tris.
+- Les critères existants (activité Gitea, activité kanban,
+  issues ouvertes, nom) sont inchangés.
+
+### Corrigé — sens des tris numériques du dashboard
+
+Le contrôle en navigateur réel a révélé que le tri
+« Issues ouvertes ↓ » triait en réalité **croissant**
+depuis son introduction : le comparateur partagé inversait
+les clés numériques. Les modes numériques (`open` et le
+nouveau `review`) trient maintenant en soustraction de
+clés — le plus grand compteur en premier, comme l'annonce
+le « ↓ ». Vérifié sur les données réelles : Épinglés
+ordonnés 196, 95, 32, 5, 4 en attente de revue.
+
+
+## 0.36.0 — 2026-10-26
+
+### Ajouté — outil MCP `move_issue` (suivi de la vague H3 du service d'agents)
+
+Le service d'agents sait proposer et appliquer des déplacements
+de cartes par approbation (`kanbante.move_card`), mais le serveur
+MCP de Kanbante n'exposait en écriture que `create_issue` et
+`add_comment` : un déplacement approuvé aurait échoué faute
+d'outil. Le trou est fermé.
+
+- **Nouvel outil `move_issue`** (paramètres `owner`, `repo`,
+  `number`, `column`) : déplace une carte vers une autre colonne
+  en réutilisant le service de déplacement de l'interface
+  (`_do_move_card`, extrait de `POST /api/move` sans changement
+  de comportement) — board local, journal des événements
+  (source « mcp »), émission vers le journal du service
+  d'agents et miroir d'étiquette.
+- **Étiquette kanban remplacée, les autres préservées** : le
+  déplacement retire l'ancienne étiquette `kanban:*` reconnue et
+  pose celle de la colonne cible ; les étiquettes libres de
+  l'issue (ex. « bug ») ne sont jamais touchées.
+- **Colonne souple** : la clé (`review`), l'étiquette de forge
+  (`kanban:review`, alias d'espace compris) et le libellé
+  français affiché (« Révision », « À faire », « En cours »…)
+  sont acceptés ; les libellés viennent de la définition des
+  colonnes de l'espace, pas d'une table figée.
+- **Garde doctrine** : la cible `done` (« Terminé ») est
+  **refusée avant toute écriture**, avec une erreur explicite —
+  Terminé appartient à Bruno dans son interface, les agents
+  s'arrêtent en Révision.
+- **Erreurs propres** : colonne inconnue (avec la liste des
+  colonnes valides), dépôt ou issue inconnu, pull request
+  refusée comme n'étant pas une carte.
+- Même garde que les autres outils /mcp (session, Basic ou
+  jeton d'API `kbt_`).
+
+## 0.35.0 — 2026-10-26
+
+### Ajouté — jalons en écriture depuis la page Projet (#26)
+
+Seconde et dernière carte du backlog de la feuille de
+route « Gestion de projets » : les jalons n'étaient que lus
+dans Kanbante, ils s'écrivent maintenant — la forge reste
+la source de vérité, rien n'est stocké localement.
+
+- **Créer** un jalon (titre, description et échéance
+  optionnelles) depuis la page Projet, formulaire
+  « ➕ Nouveau jalon ».
+- **Modifier** titre et échéance d'un jalon ouvert
+  (formulaire déplié par jalon ; échéance vidée = échéance
+  retirée, par un `null` explicite côté forge).
+- **Fermer** un jalon, avec confirmation (ses issues
+  restent ouvertes).
+- Écritures dans la forge via son API (`POST/PATCH
+  .../milestones`), CSRF vérifié, échéance invalide
+  refusée proprement **avant** toute écriture ; le board
+  filtré et le bandeau de progression reflètent le nouveau
+  jalon au chargement suivant, sans redémarrage.
+- Échéance envoyée à **midi UTC** : Gitea renvoie les dates
+  dans le fuseau de son instance — à minuit UTC, l'échéance
+  affichée reculait d'un jour (attrapé au smoke réel).
+- Hors périmètre (assumé par l'issue) : supprimer un jalon,
+  réassigner les issues entre jalons.
+
+
+## 0.34.0 — 2026-10-26
+
+### Ajouté — vue « En vol partout » /inflight (issue #24)
+
+Dernière carte du backlog de la feuille de route « Gestion
+de projets », première du classement big picture (pilotage
+quotidien des agents avant gestion de projet).
+
+- **Page /inflight** : tout l'encours (colonnes en vol de
+  l'espace — En cours, QA, Révision par défaut) **tous
+  projets actifs confondus, regroupé par colonne** — là où
+  /focus groupe par projet et /my par assignation.
+- Chaque carte : projet (lien board), titre, étiquettes,
+  assigné, et **âge dans la colonne** (badge ⏳, teinté
+  selon les seuils d'ancienneté) — les groupes sont **triés
+  par âge décroissant** : les plus vieilles cartes, le vrai
+  signal, en premier.
+- En-tête : total en vol + compteurs par colonne ;
+  **limite WIP globale** affichée quand des projets en
+  définissent (somme par colonne).
+- Entrées : menu latéral **Pilotage → 🛩️ En vol** et
+  palette Ctrl+K. Rafraîchissement doux par le SSE
+  `/api/stream` comme les autres vues (fermer une issue la
+  retire au rechargement).
+- Réutilise le pipeline du Focus (`_collect_focus_groups`,
+  `_card_ages`) : aucun appel forge supplémentaire.
+
+
+## 0.33.0 — 2026-10-26
+
+### Ajouté — filtrage professionnel sur « Mes issues » (/my)
+
+Demande de Bruno : retrouver vite une issue parmi toutes
+celles qui lui sont assignées (467 ouvertes au moment du
+test réel).
+
+- **Barre de filtres** en carte, dans la langue visuelle du
+  compositeur 0.31.1 : recherche texte plein champ
+  (titre, projet, #numéro, étiquettes — insensible aux
+  accents et à la casse, raccourci « / », Échap pour
+  effacer), listes **Projet** et **Étiquette** avec
+  compteurs, **chips de colonnes** colorées avec compteurs
+  (multi-sélection), **tri** (activité récente, plus
+  anciennes, titre, projet).
+- **Performance** : filtrage 100 % côté client sur des
+  attributs précalculés côté serveur — aucun aller-retour
+  réseau par frappe, application en requestAnimationFrame.
+  Compteur en direct (« 24 sur 467 issues »), compteurs de
+  section mis à jour, état vide propre avec réinitialisation
+  en un clic.
+- **Persistance** : projet, colonnes, étiquette et tri sont
+  retenus en localStorage d'une visite à l'autre (la
+  recherche texte reste éphémère) ; bouton « Réinitialiser
+  les filtres » dès qu'un filtre est actif.
+
+
+## 0.32.2 — 2026-10-25
+
+### Corrigé — console du panneau morte et liens pas tous en dev : résolution par requête
+
+Sur kanbante-dev, le mode console du panneau était une page morte
+et les liens inter-apps n'étaient pas tous en dev. Couche fautive
+trouvée dans `app/config.py` : la dérivation de la 0.32.1 ne
+couvrait que les URL sœurs depuis `AGENT_EVENEMENTS_URL` — jamais
+`agent_url` lui-même. Sur la dev, où seul le journal est déclaré
+en `-dev`, le panneau recevait donc le défaut prod
+`https://agent.dracodev.net` : iframe de console pointant un agent
+prod pas encore installé, donc injoignable. Et aucune résolution
+ne tenait compte de la requête : sans variable d'environnement,
+un hôte public en `-dev` retombait entièrement sur la prod.
+Enfin, aucune CSP n'existait : l'origine de l'agent n'était
+énoncée nulle part.
+
+- **Résolution par requête** (`resoudre_urls_draco` dans
+  `app/config.py`, consommée par `render()` dans `app/main.py`)
+  pour tout ce qui est rendu à une requête — liens de la barre
+  (`draco_urls`), source de l'iframe du panneau
+  (`DRACO_PANNEAU_CONFIG.api`) et origine agent de la CSP — dans
+  l'ordre : 1) la variable explicite de l'installation,
+  prioritaire et inchangée (`DRACO_SSO_URL` pour ObsiGate,
+  `DRACO_FLOWDECK_URL`, `DRACO_TIKTAK_URL`,
+  `KANBANTE_PUBLIC_URL` pour Kanbante elle-même, `AGENT_URL`
+  pour l'agent) ; 2) l'hôte public de la requête, motif fermé
+  `^(og|flowdeck|tiktak|kanbante|agent)<SUFFIXE>\.dracodev\.net$`
+  (suffixe optionnel : vide en prod, `-dev` en dev), appliqué à
+  toutes les sœurs et à l'agent — jamais de suffixe inventé
+  depuis un hôte arbitraire ; hors motif (LAN, IP), étape
+  suivante ; 3) la dérivation par les adresses de l'agent connues
+  en configuration, **élargie** : URL d'événements **ou** base du
+  service, selon ce que l'installation déclare ; 4) le défaut
+  officiel.
+- **Base de l'agent dérivée** (contextes sans requête aussi) :
+  sans `AGENT_URL` explicite, si l'adresse connue de l'agent
+  (événements ou base) suit `agent<SUFFIXE>.dracodev.net`,
+  `agent_url` devient `https://agent<SUFFIXE>.dracodev.net` au
+  lieu de rester au défaut prod.
+- **CSP nouvelle** : chaque page rendue énonce
+  `Content-Security-Policy: frame-src 'self' <origine agent>` —
+  exactement l'origine résolue pour cette même réponse, celle de
+  l'iframe de la console (seule iframe de l'application).
+- Les contextes sans requête gardent la résolution par
+  configuration, inchangée sinon. Aucun SSO ajouté : Kanbante
+  n'en a pas par conception ; périmètre limité à ses liens et à
+  son panneau.
+- Tests : requête `Host: kanbante-dev.dracodev.net` sans aucune
+  variable → barre, iframe et CSP entièrement en `-dev` ; hôte
+  prod → noms officiels ; hôte LAN → repli configuration/défauts ;
+  explicite gagne sur l'hôte ; base de l'agent dérivée du seul
+  journal et dérivation élargie à la base du service ; contextes
+  sans requête inchangés. Suite complète : 278 tests réussis.
+- **Déploiement** : cette version part avec le prochain
+  redéploiement Docker (la 0.32.1 n'a jamais été redéployée) —
+  preuve en direct **en attente du redéploiement Docker de
+  Bruno**, la version vivante sur kanbante-dev reste l'ancienne.
+
+## 0.32.1 — 2026-10-25
+
+### Corrigé — URL sœurs de la barre dérivées de l'environnement de l'agent
+
+Sur la dev, le menu inter-apps pointait vers les noms **prod**
+des apps sœurs : seul `AGENT_EVENEMENTS_URL` y est posé (hôte
+`agent-dev.dracodev.net`), et chaque URL sœur retombait sur son
+défaut officiel faute de variable explicite — il aurait fallu
+déclarer quatre variables de plus dans le `.env` dev.
+
+- **Résolution des URL sœurs** dans `app/config.py` (les
+  gabarits et le JS de la barre consomment `draco_urls`
+  inchangé), dans l'ordre : 1) la variable explicite —
+  `DRACO_SSO_URL` (ObsiGate), `DRACO_FLOWDECK_URL`,
+  `DRACO_TIKTAK_URL`, `KANBANTE_PUBLIC_URL` (Kanbante
+  elle-même) — prioritaire, contrat inchangé ; 2) **dérivation
+  d'environnement** depuis l'origine de l'agent telle que
+  l'app la connaît déjà (`AGENT_EVENEMENTS_URL`) : si son
+  hôte est de la forme `agent<SUFFIXE>.dracodev.net`
+  (suffixe vide ou, typiquement, `-dev`), l'URL sœur devient
+  `https://<slug><SUFFIXE>.dracodev.net` (slugs : `og`,
+  `flowdeck`, `tiktak`, `kanbante`) ; hôte hors motif (autre
+  domaine, LAN, IP) = **aucune dérivation**, jamais de lien
+  deviné ; 3) le défaut officiel (prod), comme avant.
+- L'URL Gitea ne change pas.
+- Tests : avec le seul `AGENT_EVENEMENTS_URL` en `-dev`, les
+  quatre URL sœurs servies sont en `-dev` ; une URL explicite
+  gagne sur la dérivation ; hôte d'agent hors motif et aucun
+  environnement posé restent aux défauts officiels
+  (non-régression).
+
+
+## 0.32.0 — 2026-10-25
+
+### Refactor — noms publics dracodev par configuration (dev/prod)
+
+Aucun nom public dracodev n'est plus codé en dur dans le code
+vivant (gabarits, JS statique) : tout passe par `app/config.py`,
+dont les défauts sont les noms **officiels** (prod). L'environnement
+dev déclare ses noms en `-dev` dans son `.env`, sans toucher au code.
+
+- **Nouvelles variables** : `KANBANTE_PUBLIC_URL` (propre URL
+  publique : lien de la barre + `return_to` SSO), `DRACO_FLOWDECK_URL`
+  et `DRACO_TIKTAK_URL` (liens de la barre commune ; le lien ObsiGate
+  réutilise `DRACO_SSO_URL`, déjà existant), `AGENT_URL` (panneau
+  Spark/console). `AGENT_EVENEMENTS_URL` se dérive désormais de
+  `AGENT_URL` quand il n'est pas posé explicitement (l'override
+  compose existant garde la priorité).
+- **Barre commune** (`_draco_bar.html`) : les quatre liens d'apps
+  viennent de `draco_urls` injecté par `render()` ; le panneau
+  reçoit l'adresse du service via `window.DRACO_PANNEAU_CONFIG`
+  injecté avant `draco-panneau.js` (chargé avec le cache-busting
+  existant `?v={{ version }}`). `draco-panneau.js` ne contient plus
+  aucun nom : sans injection, il se déclare non configuré.
+- **`login.html`** : le lien « Se connecter avec ObsiGate (SSO) »
+  est construit depuis la configuration (`sso_authorize_url`).
+  Note : ce lien SSO livré de longue date (Fusion #27) contredit le
+  document d'installation dev affirmant « pas de SSO par conception »
+  pour Kanbante — comportement existant conservé tel quel, juste
+  rendu configurable ; la contradiction documentaire est signalée,
+  pas tranchée ici.
+- `git.dracodev.net` inchangé : infrastructure (un seul Gitea,
+  `GITEA_URL` / `KANBANTE_GITEA_URL` côté sync), hors renommage dev/prod.
+- Tests barre/SSO mis en cohérence via la configuration (défauts
+  officiels + variantes `-dev`), `.env.example` créé, README et
+  `docker-compose.yml` documentent chaque variable touchée.
+
+
+## 0.31.1 — 2026-10-23
+
+### Corrigé — compositeur de création refait
+
+Retour de Bruno sur la 0.31.0 : la barre de création
+n'était ni élégante ni professionnelle, et le bouton
+« ＋ Description » pouvait rester sans effet (écouteur
+JavaScript non enregistré selon l'état du cache ou des
+scripts de la page).
+
+- **Compositeur en carte** : en-tête « Nouvelle issue »
+  avec la colonne d'arrivée (« arrive dans 📥 Backlog »,
+  nom personnalisé de l'espace respecté), champ titre
+  pleine largeur avec anneau de focus, bouton primaire
+  « Créer l'issue ».
+- **Description en `<details>` natif** : « Ajouter une
+  description ▾ » déplie la zone texte sans aucun
+  JavaScript — impossible à casser par un script en
+  erreur ou un fichier en cache. Aide intégrée (Markdown,
+  Ctrl+Entrée pour créer, actif aussi depuis le titre).
+- **Assets du board versionnés** (`?v=<version>` sur le
+  CSS et board.js du board) : un redéploiement invalide
+  le cache navigateur au lieu de servir un mélange
+  d'anciennes et nouvelles pièces.
+- Vérifié en navigateur réel (Chromium) sur le vrai
+  board : captures fermé/ouvert contrôlées visuellement,
+  clic sur le libellé, zone visible et éditable.
+
+
 ## 0.31.0 — 2026-10-23

 ### Ajouté — description éditable, pièces jointes, clic fiable
@@ -111,6 +111,12 @@ sudo systemctl enable --now docker
 |---|---|---|
 | `GITEA_URL` | `https://git.dracodev.net` | Instance Gitea |
 | `GITEA_TOKEN` | *(vide)* | Jeton API Gitea — **portée conseillée : lecture + écriture des issues, sur un compte dédié, pas un jeton admin**. Sans jeton : contenu public seulement |
+| `KANBANTE_PUBLIC_URL` | `https://kanbante.dracodev.net` | Propre URL publique de Kanbante (lien de la barre commune, `return_to` du lien SSO) — noms publics par configuration : défauts = noms officiels (prod), la dev déclare ses noms en `-dev` (ex. `https://kanbante-dev.dracodev.net`) |
+| `DRACO_SSO_URL` | `https://og.dracodev.net` | Base d'ObsiGate, émettrice SSO (lien de barre ObsiGate, révocations, lien de connexion SSO) |
+| `DRACO_FLOWDECK_URL` / `DRACO_TIKTAK_URL` | `https://flowdeck.dracodev.net` / `https://tiktak.dracodev.net` | Liens Flowdeck / TikTak de la barre commune |
+| `AGENT_URL` | `https://agent.dracodev.net` | Base du service d'agents (panneau Spark + console, adresse injectée au JS par l'hôte) — sans variable explicite, dérivée de l'hôte d'`AGENT_EVENEMENTS_URL` s'il suit `agent<SUFFIXE>.dracodev.net` ; à chaque requête, l'hôte public (motif fermé `*.dracodev.net`) détermine l'environnement des URL rendues sauf variable explicite (0.32.2) |
+| `AGENT_EVENEMENTS_URL` | *(dérivé de `AGENT_URL`)* | Journal d'événements du service d'agents ; ne se pose que pour surcharger la dérivation `<AGENT_URL>/api/v1/evenements` |
+| `AGENT_EVENEMENTS_CLE` | *(vide)* | Clé HMAC signant les événements émis vers ce journal ; vide = émission désactivée |
 | `KANBANTE_DB_PATH` | `~/.kanbante/kanbante.db` | Base SQLite locale (en Docker : `/data/kanbante.db`) |
 | `KANBANTE_AUTH_USER` / `KANBANTE_AUTH_PASSWORD` | *(vide)* | Active l'authentification dès que les deux sont définis : écran de connexion + session signée pour les navigateurs ; l'en-tête Basic reste accepté pour les scripts |
 | `KANBANTE_REQUIRE_AUTH` | `0` | `1` = l'app refuse de servir (503) si l'auth n'est pas configurée |
@@ -0,0 +1,341 @@
+"""Client de distribution du coffre de secrets ObsiGate (Phase 4, issue ObsiGate #22).
+
+Patron imposé par la spec « Coffre de secrets ObsiGate » §12, appliqué ici
+sans variante :
+
+- Kanbante ne stocke QUE des références ``coffre:<slug>/<nom>``, jamais une
+  valeur distribuée ;
+- à chaque usage, le SERVEUR Kanbante appelle
+  ``POST /api/coffres/distribuer`` d'ObsiGate avec le jeton consommateur
+  Kanbante (distinct du jeton MCP de notes et de la session SSO) et un
+  contexte obligatoire, utilise la valeur en mémoire, puis l'oublie ;
+- aucun cache de valeur, aucune persistance, aucun log de la valeur ;
+- octroi révoqué -> échec explicite orientant vers ObsiGate, sans repli
+  sur une ancienne valeur ;
+- ObsiGate indisponible -> échec propre, sans continuer avec une valeur
+  en cache (il ne doit pas y en avoir).
+
+Configuration (variables d'environnement, jamais versionnées) :
+- ``KANBANTE_OBSIGATE_URL`` : base d'ObsiGate, ex. ``https://og.dracodev.net``
+- ``KANBANTE_COFFRE_CONSOMMATEUR_TOKEN`` : jeton du consommateur
+  « kanbante » enregistré dans ObsiGate (jeton révocable, hash + jti
+  côté ObsiGate ; il n'est jamais renvoyé au client ni journalisé).
+- ``KANBANTE_COFFRE_TIMEOUT`` : délai en secondes (défaut 10).
+
+Ce module ne dépend que de ``httpx`` (déjà dépendance du projet) et de
+la bibliothèque standard, pour rester testable avec un faux endpoint
+(``httpx.MockTransport``) sans instance ObsiGate réelle.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from contextlib import asynccontextmanager, contextmanager
+from dataclasses import dataclass
+
+import httpx
+
+logger = logging.getLogger("kanbante.coffre")
+
+PREFIXE_REFERENCE = "coffre:"
+CHEMIN_DISTRIBUER = "/api/coffres/distribuer"
+TIMEOUT_DEFAUT = 10.0
+
+# Messages explicites, orientant vers ObsiGate. Ils ne contiennent jamais
+# la valeur distribuée, ni le jeton consommateur.
+_MESSAGES_DETAIL = {
+    "consommateur_invalide": (
+        "Consommateur Kanbante invalide dans ObsiGate : "
+        "vérifier le jeton consommateur Kanbante dans ObsiGate."
+    ),
+    "consommateur_revoque": (
+        "Consommateur Kanbante révoqué dans ObsiGate : "
+        "ré-accorder l'accès du consommateur Kanbante dans ObsiGate."
+    ),
+    "octroi_absent": (
+        "Aucun octroi actif pour cette référence dans ObsiGate : "
+        "créer l'octroi pour le consommateur Kanbante dans ObsiGate."
+    ),
+    "octroi_revoque": (
+        "Accès révoqué dans ObsiGate pour cette référence : "
+        "ré-accorder l'octroi dans ObsiGate, puis réessayer."
+    ),
+    "octroi_expire": (
+        "Octroi expiré dans ObsiGate pour cette référence : "
+        "renouveler l'octroi dans ObsiGate, puis réessayer."
+    ),
+    "secret_expire": (
+        "Secret expiré dans ObsiGate : "
+        "renouveler le secret dans ObsiGate, puis réessayer."
+    ),
+    "reference_invalide": (
+        "Référence invalide (format attendu coffre:<slug>/<nom>)."
+    ),
+    "contexte_manquant": (
+        "Contexte de distribution manquant : "
+        "un contexte (type + identifiant) est obligatoire côté ObsiGate."
+    ),
+    "kek_absente": "ObsiGate indisponible : clé de chiffrement absente côté ObsiGate.",
+    "crypto_indisponible": "ObsiGate indisponible : chiffrement indisponible côté ObsiGate.",
+}
+
+
+class CoffreErreur(Exception):
+    """Erreur de distribution, sans jamais exposer une valeur secrète."""
+
+
+class CoffreReferenceInvalide(CoffreErreur):
+    """La référence ne respecte pas le format ``coffre:<slug>/<nom>``."""
+
+
+class CoffreContexteManquant(CoffreErreur):
+    """Le contexte de distribution (type + identifiant) est obligatoire."""
+
+
+class CoffreNonConfigure(CoffreErreur):
+    """ObsiGate ou le jeton consommateur Kanbante n'est pas configuré."""
+
+
+class CoffreAccesRefuse(CoffreErreur):
+    """ObsiGate a refusé la distribution (octroi/consommateur/secret).
+
+    Aucun repli sur une ancienne valeur n'est autorisé : l'appelant doit
+    échouer proprement avec ce message.
+    """
+
+
+class CoffreIndisponible(CoffreErreur):
+    """ObsiGate est injoignable ou a répondu sans valeur utilisable."""
+
+
+@dataclass(frozen=True)
+class CoffreConfig:
+    """Configuration du consommateur Kanbante côté ObsiGate."""
+
+    base_url: str
+    jeton_consommateur: str
+    timeout: float = TIMEOUT_DEFAUT
+
+    @property
+    def url_distribuer(self) -> str:
+        return self.base_url.rstrip("/") + CHEMIN_DISTRIBUER
+
+
+def config_depuis_env() -> CoffreConfig:
+    """Construit la configuration depuis l'environnement.
+
+    Lève : CoffreNonConfigure si la base ou le jeton est absent.
+    Le jeton n'est jamais journalisé, même en cas d'erreur.
+    """
+    base_url = os.getenv("KANBANTE_OBSIGATE_URL", "").strip()
+    jeton = os.getenv("KANBANTE_COFFRE_CONSOMMATEUR_TOKEN", "").strip()
+    try:
+        timeout = float(os.getenv("KANBANTE_COFFRE_TIMEOUT", "") or TIMEOUT_DEFAUT)
+    except ValueError:
+        timeout = TIMEOUT_DEFAUT
+    if not base_url or not jeton:
+        raise CoffreNonConfigure(
+            "Consommateur coffre Kanbante non configuré : définir "
+            "KANBANTE_OBSIGATE_URL et KANBANTE_COFFRE_CONSOMMATEUR_TOKEN."
+        )
+    return CoffreConfig(base_url=base_url, jeton_consommateur=jeton, timeout=timeout)
+
+
+def est_reference(valeur: str | None) -> bool:
+    """Vrai si ``valeur`` est une référence coffre (et non une valeur brute)."""
+    if not valeur:
+        return False
+    try:
+        parse_reference(valeur)
+    except CoffreReferenceInvalide:
+        return False
+    return True
+
+
+def parse_reference(reference: str) -> tuple[str, str]:
+    """Valide ``coffre:<slug>/<nom>`` et retourne ``(slug, nom)``.
+
+    Lève : CoffreReferenceInvalide si le format est incorrect.
+    La validation reste volontairement permissive sur les caractères
+    (ObsiGate reste l'autorité de validation) : préfixe, un « / »,
+    slug et nom non vides, aucun espace.
+    """
+    reference = (reference or "").strip()
+    if not reference.startswith(PREFIXE_REFERENCE):
+        raise CoffreReferenceInvalide(
+            "Référence invalide (format attendu coffre:<slug>/<nom>)."
+        )
+    reste = reference[len(PREFIXE_REFERENCE):]
+    if "/" not in reste or any(c.isspace() for c in reference):
+        raise CoffreReferenceInvalide(
+            "Référence invalide (format attendu coffre:<slug>/<nom>)."
+        )
+    slug, nom = reste.split("/", 1)
+    if not slug or not nom or "/" in nom:
+        raise CoffreReferenceInvalide(
+            "Référence invalide (format attendu coffre:<slug>/<nom>)."
+        )
+    return slug, nom
+
+
+def _valider_contexte(contexte_type: str, contexte_id: str) -> None:
+    if not (contexte_type or "").strip() or not (contexte_id or "").strip():
+        raise CoffreContexteManquant(
+            "Contexte de distribution manquant : un contexte "
+            "(type + identifiant) est obligatoire."
+        )
+
+
+def _message_erreur(statut: int, detail: str) -> CoffreErreur:
+    """Mappe une réponse d'erreur ObsiGate vers une erreur typée.
+
+    Les statuts 401/403/410 signalent un refus d'accès (octroi,
+    consommateur ou secret) : jamais de repli. Les autres erreurs
+    (400 de format, 503, réponse sans valeur) sont des indisponibilités
+    ou des erreurs de configuration, également sans repli.
+    """
+    message = _MESSAGES_DETAIL.get(detail)
+    if statut in (401, 403, 410) or detail in (
+        "octroi_absent",
+        "octroi_revoque",
+        "octroi_expire",
+        "consommateur_invalide",
+        "consommateur_revoque",
+        "secret_expire",
+    ):
+        return CoffreAccesRefuse(message or f"Distribution refusée par ObsiGate ({detail}).")
+    if detail == "reference_invalide":
+        return CoffreReferenceInvalide(message or "Référence invalide.")
+    if detail == "contexte_manquant":
+        return CoffreContexteManquant(message or "Contexte manquant.")
+    return CoffreIndisponible(
+        message or f"ObsiGate indisponible (statut {statut})."
+    )
+
+
+def _traiter_reponse(reponse: httpx.Response, reference: str) -> str:
+    """Extrait la valeur d'une réponse de distribution, ou lève.
+
+    La valeur extraite n'est jamais journalisée ; seuls la référence,
+    le contexte et le statut le sont.
+    """
+    if reponse.status_code == 200:
+        try:
+            valeur = reponse.json().get("valeur")
+        except ValueError:
+            valeur = None
+        if isinstance(valeur, str) and valeur:
+            logger.info("distribution coffre ok (reference=%s)", reference)
+            return valeur
+        raise CoffreIndisponible(
+            "ObsiGate a répondu sans valeur distribuable."
+        )
+    try:
+        detail = str(reponse.json().get("detail") or "")
+    except ValueError:
+        detail = ""
+    logger.warning(
+        "distribution coffre refusee (reference=%s, statut=%d, detail=%s)",
+        reference,
+        reponse.status_code,
+        detail,
+    )
+    raise _message_erreur(reponse.status_code, detail)
+
+
+def _corps_requete(reference: str, contexte_type: str, contexte_id: str) -> dict:
+    return {
+        "reference": reference,
+        "contexte_type": contexte_type,
+        "contexte_id": contexte_id,
+    }
+
+
+def distribuer(
+    reference: str,
+    contexte_type: str,
+    contexte_id: str,
+    config: CoffreConfig | None = None,
+    transport: httpx.BaseTransport | None = None,
+) -> str:
+    """Distribue une valeur ObsiGate, en mémoire seulement.
+
+    L'appelant doit utiliser la valeur immédiatement (appel sortant,
+    vérification HMAC) puis la laisser sortir de portée : ce module ne
+    la persiste ni ne la met en cache, et ne la journalise jamais.
+    """
+    parse_reference(reference)
+    _valider_contexte(contexte_type, contexte_id)
+    cfg = config or config_depuis_env()
+    try:
+        with httpx.Client(timeout=cfg.timeout, transport=transport) as client:
+            reponse = client.post(
+                cfg.url_distribuer,
+                json=_corps_requete(reference, contexte_type, contexte_id),
+                headers={"Authorization": f"Bearer {cfg.jeton_consommateur}"},
+            )
+    except httpx.HTTPError as exc:
+        raise CoffreIndisponible(
+            "ObsiGate injoignable pour la distribution : "
+            "vérifier qu'ObsiGate est disponible, puis réessayer."
+        ) from exc
+    return _traiter_reponse(reponse, reference)
+
+
+async def distribuer_async(
+    reference: str,
+    contexte_type: str,
+    contexte_id: str,
+    config: CoffreConfig | None = None,
+    transport: httpx.AsyncBaseTransport | None = None,
+) -> str:
+    """Variante asynchrone de :func:`distribuer` (mêmes garanties)."""
+    parse_reference(reference)
+    _valider_contexte(contexte_type, contexte_id)
+    cfg = config or config_depuis_env()
+    try:
+        async with httpx.AsyncClient(timeout=cfg.timeout, transport=transport) as client:
+            reponse = await client.post(
+                cfg.url_distribuer,
+                json=_corps_requete(reference, contexte_type, contexte_id),
+                headers={"Authorization": f"Bearer {cfg.jeton_consommateur}"},
+            )
+    except httpx.HTTPError as exc:
+        raise CoffreIndisponible(
+            "ObsiGate injoignable pour la distribution : "
+            "vérifier qu'ObsiGate est disponible, puis réessayer."
+        ) from exc
+    return _traiter_reponse(reponse, reference)
+
+
+@contextmanager
+def usage_distribue(reference: str, contexte_type: str, contexte_id: str,
+                     config: CoffreConfig | None = None,
+                     transport: httpx.BaseTransport | None = None):
+    """Distribue une valeur pour un seul usage, dans le bloc ``with``.
+
+    La valeur ne doit pas sortir du bloc (ni être stockée, ni journalisée,
+    ni retournée) : à la sortie, l'appelant ne conserve que le résultat
+    de l'usage, jamais la valeur elle-même.
+    """
+    valeur = distribuer(reference, contexte_type, contexte_id,
+                        config=config, transport=transport)
+    try:
+        yield valeur
+    finally:
+        valeur = ""
+
+
+@asynccontextmanager
+async def usage_distribue_async(reference: str, contexte_type: str,
+                                contexte_id: str,
+                                config: CoffreConfig | None = None,
+                                transport: httpx.AsyncBaseTransport | None = None):
+    """Variante asynchrone de :func:`usage_distribue`."""
+    valeur = await distribuer_async(reference, contexte_type, contexte_id,
+                                    config=config, transport=transport)
+    try:
+        yield valeur
+    finally:
+        valeur = ""
@@ -96,10 +96,72 @@ Environment variables:
    KANBANTE_ZOMBIE_DAYS         Days without any activity after
                                 which an open card is a "zombie"
                                 on /health (issue #9). Default 30.
+    AGENT_URL                    Base URL of the agent service
+                                 (panneau Spark + console). Default
+                                 (official/prod name)
+                                 https://agent.dracodev.net — the dev
+                                 environment declares its ``-dev`` name
+                                 here (e.g. https://agent-dev.dracodev.net).
+                                 Sans variable explicite, la base est
+                                 aussi dérivée de l'hôte de
+                                 AGENT_EVENEMENTS_URL quand il suit le
+                                 motif ``agent<SUFFIXE>.dracodev.net``
+                                 (0.32.2 : sinon le panneau pointait le
+                                 défaut prod alors que le journal était
+                                 en dev — console morte sur la dev).
    AGENT_EVENEMENTS_URL         Journal endpoint of the agent
                                 service (Lot 2, contract ACC-0.2)
                                 receiving this app's signed events.
-                                 Default https://agent.dracodev.net/api/v1/evenements.
+                                 Default: derived from AGENT_URL
+                                 (``<AGENT_URL>/api/v1/evenements``).
+                                 Son hôte sert aussi de source à la
+                                 dérivation d'environnement des URL
+                                 sœurs ci-dessous (voir
+                                 ``_url_soeur_draco``), au même titre
+                                 que la base du service (AGENT_URL) —
+                                 dérivation élargie en 0.32.2.
+    KANBANTE_PUBLIC_URL          This app's own public base URL
+                                 (barre commune self-link, SSO
+                                 ``return_to``). Default (official)
+                                 https://kanbante.dracodev.net.
+    DRACO_FLOWDECK_URL           Public base URL of Flowdeck for the
+                                 common app bar. Default (official)
+                                 https://flowdeck.dracodev.net.
+    DRACO_TIKTAK_URL             Public base URL of TikTak for the
+                                 common app bar. Default (official)
+                                 https://tiktak.dracodev.net.
+                                 ObsiGate's bar link reuses DRACO_SSO_URL
+                                 (the SSO emitter IS ObsiGate).
+                                 Résolution d'une URL rendue à une
+                                 requête (barre, panneau, CSP), dans
+                                 l'ordre (voir ``resoudre_urls_draco``,
+                                 0.32.2) : 1) la variable explicite
+                                 ci-dessus (prioritaire, contrat
+                                 inchangé) ; 2) l'hôte public de la
+                                 requête, motif fermé
+                                 ``(og|flowdeck|tiktak|kanbante|agent)
+                                 <SUFFIXE>.dracodev.net`` (suffixe vide
+                                 en prod, ``-dev`` en dev) appliqué à
+                                 toutes les sœurs et à l'agent — jamais
+                                 de suffixe inventé depuis un hôte
+                                 arbitraire ; 3) dérivation depuis les
+                                 adresses de l'agent connues en
+                                 configuration (AGENT_EVENEMENTS_URL
+                                 ou AGENT_URL) — si cet hôte est
+                                 ``agent<SUFFIXE>.dracodev.net``,
+                                 l'URL sœur devient
+                                 ``https://<slug><SUFFIXE>.
+                                 dracodev.net`` (slugs : og, flowdeck,
+                                 tiktak, kanbante, agent) ; hôte hors
+                                 motif (autre domaine, LAN, IP) =
+                                 aucune dérivation, jamais de lien
+                                 deviné ; 4) le défaut officiel (prod).
+                                 Les contextes sans requête gardent la
+                                 résolution par configuration (étapes
+                                 1, 3 et 4), inchangée sinon.
+                                 No public dracodev name is hard-coded
+                                 outside these defaults: dev/prod differ
+                                 only by environment, never by code.
    AGENT_EVENEMENTS_CLE         Kanbante's own HMAC key signing the
                                 events it emits to that journal (the
                                 service knows it as the "kanbante"
@@ -108,12 +170,14 @@ Environment variables:
 """

 import os
+import re
 from dataclasses import dataclass
 from pathlib import Path
+from urllib.parse import urlparse

 BASE_DIR = Path(__file__).resolve().parent.parent

-APP_VERSION = "0.31.0"
+APP_VERSION = "0.37.3"


 def _env_bool(name: str, default: bool) -> bool:
@@ -149,6 +213,144 @@ def _env_wip_limits(name: str) -> dict[str, int]:
    return limits


+# ── Résolution d'environnement des URL publiques dracodev ──
+# 0.32.1 : sur la dev, seul AGENT_EVENEMENTS_URL est posé (hôte
+# agent-dev.dracodev.net) : les URL sœurs retombaient donc sur leurs
+# défauts prod dans la barre commune. La dérivation depuis l'hôte de
+# l'agent évite de devoir déclarer quatre variables de plus.
+# 0.32.2 — couche fautive corrigée : cette dérivation ne couvrait
+# que les URL sœurs, jamais ``agent_url`` lui-même — le panneau
+# recevait donc le défaut prod (agent injoignable, la prod n'étant
+# pas installée) et la console était une page morte sur la dev.
+# Et aucune résolution ne tenait compte de la requête : un hôte
+# public en ``-dev`` sans aucune variable retombait sur la prod.
+# Désormais, pour tout ce qui est rendu à une requête (liens de la
+# barre / DRACO_URLS, source de l'iframe du panneau, origine agent
+# de la CSP) : 1) variable explicite ; 2) hôte public de la
+# requête (motif fermé ci-dessous) ; 3) dérivation par les adresses
+# de l'agent connues en configuration — URL d'événements OU base
+# du service (élargie en 0.32.2) ; 4) défaut officiel.
+_MOTIF_HOTE_AGENT = re.compile(r"agent([a-z0-9-]*)\.dracodev\.net")
+_MOTIF_HOTE_PUBLIC = re.compile(
+    r"(?:og|flowdeck|tiktak|kanbante|agent)([a-z0-9-]*)\.dracodev\.net"
+)
+
+
+def _suffixe_depuis_hote(hote: str, motif: re.Pattern) -> str | None:
+    """Suffixe d'environnement porté par un hôte nu, ou ``None``.
+
+    Retourne le suffixe (``""`` pour le nom officiel, ``"-dev"``
+    pour la dev) si l'hôte suit le motif fermé ; ``None`` hors
+    motif (autre domaine, LAN, IP…) — aucune dérivation alors,
+    jamais de suffixe inventé depuis un hôte arbitraire.
+    """
+    correspondance = motif.fullmatch(hote.strip().lower())
+    return correspondance.group(1) if correspondance else None
+
+
+def _suffixe_environnement_agent(url_agent: str) -> str | None:
+    """Suffixe lu sur l'hôte d'une adresse connue de l'agent.
+
+    Vaut pour l'URL d'événements comme pour la base du service :
+    si son hôte est ``agent<SUFFIXE>.dracodev.net``, le suffixe
+    est retourné ; ``None`` hors motif.
+    """
+    try:
+        hote = urlparse(url_agent).hostname or ""
+    except ValueError:
+        return None
+    return _suffixe_depuis_hote(hote, _MOTIF_HOTE_AGENT)
+
+
+def suffixe_environnement_requete(hote_requete: str | None) -> str | None:
+    """Suffixe lu sur l'hôte public de la requête entrante.
+
+    Motif fermé ``^(og|flowdeck|tiktak|kanbante|agent)<SUFFIXE>
+    \\.dracodev\\.net$`` (suffixe optionnel : vide en prod,
+    ``-dev`` en dev) ; un port éventuel est toléré et retiré.
+    Hors motif (LAN, IP, autre domaine) : ``None`` — l'appelant
+    retombe alors sur la configuration, jamais sur un suffixe
+    deviné.
+    """
+    if not hote_requete:
+        return None
+    hote = hote_requete.strip().lower()
+    if hote.startswith("["):  # littéral IPv6 : jamais dans le motif
+        return None
+    hote = hote.split(":", 1)[0]
+    return _suffixe_depuis_hote(hote, _MOTIF_HOTE_PUBLIC)
+
+
+def _url_soeur_draco(
+    nom_env: str, slug: str, defaut: str, suffixe: str | None
+) -> str:
+    """Résout l'URL publique d'une app sœur de la barre commune.
+
+    1) ``nom_env`` explicite — prioritaire, contrat inchangé ;
+    2) dérivation d'environnement : ``https://<slug><suffixe>.
+    dracodev.net`` quand l'hôte de l'agent suit le motif ;
+    3) défaut officiel (prod), comme avant.
+    """
+    explicite = os.getenv(nom_env)
+    if explicite:
+        return explicite.rstrip("/")
+    if suffixe is not None:
+        return f"https://{slug}{suffixe}.dracodev.net"
+    return defaut
+
+
+@dataclass(frozen=True)
+class UrlsDraco:
+    """URL publiques dracodev résolues pour un rendu ou un contexte."""
+
+    sso_url: str  # ObsiGate (lien de barre ; explicite = DRACO_SSO_URL)
+    flowdeck_url: str
+    tiktak_url: str
+    public_url: str  # Kanbante elle-même (KANBANTE_PUBLIC_URL)
+    agent_url: str  # base du service d'agents (panneau + CSP)
+
+
+def resoudre_urls_draco(
+    hote_requete: str | None = None, base: "Settings | None" = None
+) -> UrlsDraco:
+    """Résout les URL publiques pour un rendu à une requête.
+
+    Ordre, par URL : 1) la variable explicite de l'installation —
+    prioritaire, inchangée (``DRACO_SSO_URL`` pour ObsiGate,
+    ``KANBANTE_PUBLIC_URL`` pour Kanbante elle-même, ``AGENT_URL``
+    pour l'agent) ; 2) l'hôte public de la requête, s'il suit le
+    motif fermé dracodev : son suffixe d'environnement (``-dev``,
+    vide en prod) s'applique à toutes les sœurs et à l'agent ;
+    3) à défaut, la valeur de configuration ``base`` (défaut :
+    ``_env_settings()``), qui porte déjà la dérivation par les
+    adresses de l'agent connues (événements ou base du service)
+    puis le défaut officiel — c'est aussi la résolution des
+    contextes sans requête, inchangée.
+    """
+    if base is None:
+        base = _env_settings()
+    suffixe_hote = suffixe_environnement_requete(hote_requete)
+
+    def resoudre(nom_env: str, slug: str, valeur_base: str) -> str:
+        if os.getenv(nom_env):
+            return valeur_base  # explicite : déjà résolue dans base
+        if suffixe_hote is not None:
+            return f"https://{slug}{suffixe_hote}.dracodev.net"
+        return valeur_base
+
+    return UrlsDraco(
+        sso_url=resoudre("DRACO_SSO_URL", "og", base.sso_url),
+        flowdeck_url=resoudre(
+            "DRACO_FLOWDECK_URL", "flowdeck", base.flowdeck_url
+        ),
+        tiktak_url=resoudre("DRACO_TIKTAK_URL", "tiktak", base.tiktak_url),
+        public_url=resoudre(
+            "KANBANTE_PUBLIC_URL", "kanbante", base.public_url
+        ),
+        agent_url=resoudre("AGENT_URL", "agent", base.agent_url),
+    )
+
+
@dataclass(frozen=True)
 class Settings:
    gitea_url: str = "https://git.dracodev.net"
@@ -188,6 +390,10 @@ class Settings:
    draco_secret_prev: str = ""
    sso_machine_key: str = ""
    sso_url: str = "https://og.dracodev.net"
+    public_url: str = "https://kanbante.dracodev.net"
+    flowdeck_url: str = "https://flowdeck.dracodev.net"
+    tiktak_url: str = "https://tiktak.dracodev.net"
+    agent_url: str = "https://agent.dracodev.net"
    archive_suggest_days: int = 180
    agent_evenements_url: str = "https://agent.dracodev.net/api/v1/evenements"
    agent_evenements_cle: str = ""
@@ -205,6 +411,29 @@ def get_settings() -> Settings:

 def _env_settings() -> Settings:
    """Build settings from the current environment only."""
+    agent_url_explicite = os.getenv("AGENT_URL")
+    agent_url = (
+        agent_url_explicite or "https://agent.dracodev.net"
+    ).rstrip("/")
+    agent_evenements_url = (
+        os.getenv("AGENT_EVENEMENTS_URL")
+        or f"{agent_url}/api/v1/evenements"
+    ).rstrip("/")
+    # Origines de l'agent telles que l'app les connaît déjà : elles
+    # portent le suffixe d'environnement (-dev…) repris par les URL
+    # sœurs dépourvues de variable explicite. Dérivation élargie
+    # (0.32.2) : l'URL d'événements d'abord, puis la base du service
+    # elle-même — selon ce que l'installation déclare.
+    suffixe_agent = _suffixe_environnement_agent(agent_evenements_url)
+    if suffixe_agent is None:
+        suffixe_agent = _suffixe_environnement_agent(agent_url)
+    # Base du service dérivée à son tour (0.32.2) : sans AGENT_URL
+    # explicite, si l'adresse connue de l'agent est en ``-dev``, le
+    # panneau et la console doivent viser cette même origine —
+    # auparavant agent_url restait au défaut prod, d'où la console
+    # morte sur la dev alors que le journal était bien en dev.
+    if not agent_url_explicite and suffixe_agent is not None:
+        agent_url = f"https://agent{suffixe_agent}.dracodev.net"
    return Settings(
        gitea_url=os.getenv("GITEA_URL", "https://git.dracodev.net").rstrip("/"),
        gitea_token=os.getenv("GITEA_TOKEN", ""),
@@ -247,12 +476,30 @@ def _env_settings() -> Settings:
        draco_secret=os.getenv("DRACO_SESSION_SECRET", ""),
        draco_secret_prev=os.getenv("DRACO_SESSION_SECRET_PREV", ""),
        sso_machine_key=os.getenv("DRACO_SSO_MACHINE_KEY", ""),
-        sso_url=os.getenv("DRACO_SSO_URL", "https://og.dracodev.net").rstrip("/"),
+        sso_url=_url_soeur_draco(
+            "DRACO_SSO_URL", "og", "https://og.dracodev.net", suffixe_agent
+        ),
+        public_url=_url_soeur_draco(
+            "KANBANTE_PUBLIC_URL",
+            "kanbante",
+            "https://kanbante.dracodev.net",
+            suffixe_agent,
+        ),
+        flowdeck_url=_url_soeur_draco(
+            "DRACO_FLOWDECK_URL",
+            "flowdeck",
+            "https://flowdeck.dracodev.net",
+            suffixe_agent,
+        ),
+        tiktak_url=_url_soeur_draco(
+            "DRACO_TIKTAK_URL",
+            "tiktak",
+            "https://tiktak.dracodev.net",
+            suffixe_agent,
+        ),
+        agent_url=agent_url,
        archive_suggest_days=_env_int("KANBANTE_ARCHIVE_SUGGEST_DAYS", 180),
-        agent_evenements_url=os.getenv(
-            "AGENT_EVENEMENTS_URL",
-            "https://agent.dracodev.net/api/v1/evenements",
-        ).rstrip("/"),
+        agent_evenements_url=agent_evenements_url,
        agent_evenements_cle=os.getenv("AGENT_EVENEMENTS_CLE", ""),
    )

@@ -17,6 +17,8 @@ import logging

 import httpx

+from app.config import APP_VERSION
+
 logger = logging.getLogger("kanbante.digest")

 MCP_PROTOCOL_VERSION = "2024-11-05"
@@ -143,7 +145,7 @@ async def _mcp_session(client: httpx.AsyncClient, url: str, token: str) -> None:
        {
            "protocolVersion": MCP_PROTOCOL_VERSION,
            "capabilities": {},
-            "clientInfo": {"name": "kanbante", "version": "0.31.0"},
+            "clientInfo": {"name": "kanbante", "version": APP_VERSION},
        },
        req_id=1,
    )
@@ -477,6 +477,59 @@ class GiteaClient:
            ),
        )

+    async def create_milestone(
+        self,
+        owner: str,
+        repo: str,
+        title: str,
+        description: str = "",
+        due_on: str | None = None,
+    ) -> dict:
+        """Create a milestone on the forge (issue #26)."""
+        payload: dict = {"title": title, "description": description}
+        if due_on:
+            payload["due_on"] = due_on
+        r = await self.client.post(
+            f"/repos/{owner}/{repo}/milestones", json=payload
+        )
+        r.raise_for_status()
+        self._cache_clear()
+        return r.json()
+
+    async def update_milestone(
+        self,
+        owner: str,
+        repo: str,
+        milestone_id: int,
+        title: str | None = None,
+        description: str | None = None,
+        due_on: str | None = None,
+        clear_due: bool = False,
+        state: str | None = None,
+    ) -> dict:
+        """Patch a milestone (title, due date, state) — #26.
+
+        due_on=None + clear_due=False leaves the date alone;
+        clear_due=True sends an explicit null (Gitea clears it).
+        """
+        payload: dict = {}
+        if title is not None:
+            payload["title"] = title
+        if description is not None:
+            payload["description"] = description
+        if clear_due:
+            payload["due_on"] = None
+        elif due_on:
+            payload["due_on"] = due_on
+        if state is not None:
+            payload["state"] = state
+        r = await self.client.patch(
+            f"/repos/{owner}/{repo}/milestones/{milestone_id}", json=payload
+        )
+        r.raise_for_status()
+        self._cache_clear()
+        return r.json()
+
    async def list_starred(self) -> list[dict]:
        """Repos starred by the token user (issue #20: pinning rides
        on Gitea stars — the forge stays the source of truth)."""
@@ -23,6 +23,7 @@ import logging
 import re
 import secrets
 import time
+import unicodedata
 from contextlib import asynccontextmanager
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -41,7 +42,7 @@ from fastapi.staticfiles import StaticFiles
 from jinja2 import Environment, FileSystemLoader, select_autoescape
 from starlette.middleware.base import BaseHTTPMiddleware

-from app.config import APP_VERSION, get_settings
+from app.config import APP_VERSION, get_settings, resoudre_urls_draco
 from app.gitea_client import GiteaClient
 from app import code_links as code_links_service
 from app import digest as digest_service
@@ -51,6 +52,7 @@ from app import forecast as forecast_service
 from app import rules as rules_service
 from app import sprint as sprint_service
 from app import connections as connections_service
+from app import coffre_client
 from app import board_columns as bcols
 from app.briefing import (
    format_briefing_text,
@@ -388,6 +390,19 @@ class AuthMiddleware(BaseHTTPMiddleware):
        if (path.startswith("/mcp") or path.startswith("/api/")) \
                and _bearer_user(request) is not None:
            return await call_next(request)
+        # Recherche partout (#68) : /api/search accepte aussi le jeton
+        # SSO draco_session (mono-utilisateur : un jeton valide désigne
+        # l'opérateur), comme les API de recherche des sœurs. Les
+        # preflights OPTIONS ne portent jamais de cookies : ils sont
+        # répondus par RechercheCorsMiddleware avant d'arriver ici.
+        if path == "/api/search":
+            try:
+                from app import draco
+
+                if draco.claims_for(request) is not None:
+                    return await call_next(request)
+            except Exception:
+                pass
        # API consumers get a plain 401 (no browser prompt, no
        # redirect they cannot follow); browsers get the login page.
        if path.startswith("/api/") or "text/html" not in request.headers.get(
@@ -403,9 +418,69 @@ class AuthMiddleware(BaseHTTPMiddleware):
        return RedirectResponse(f"/login?next={quote(target, safe='')}", status_code=303)


+class DracoAlertesCorsMiddleware(BaseHTTPMiddleware):
+    """CORS Fusion #69, limité à GET /api/events.
+
+    Le panneau Alertes unifiées lit ce journal depuis les autres
+    hôtes dracodev, avec credentials. Seules les origines des
+    applications soeurs (résolues comme les liens de la barre :
+    explicite > hôte de la requête > dérivation > défaut officiel,
+    via resoudre_urls_draco()) reçoivent Access-Control-Allow-Origin.
+    Le preflight OPTIONS ne porte aucune donnée et ne contourne
+    aucune authentification : le GET reste soumis à AuthMiddleware
+    (session ou jeton). Toute autre origine ou route traverse sans
+    en-tête CORS — le navigateur bloque alors la lecture, comme
+    avant. Aucune CSP connect-src n'est à ouvrir ici : Kanbante
+    n'énonce que frame-src (console Spark).
+    """
+
+    async def dispatch(self, request, call_next):
+        if request.url.path != "/api/events":
+            return await call_next(request)
+        from app.config import resoudre_urls_draco
+        from app.recherche import DEV_ORIGINS, PROD_ORIGINS, origin_of
+
+        urls = resoudre_urls_draco(request.headers.get("host"))
+        # Correctif CORS alertes (fusion #69, 2026-10-28) : comme
+        # pour /api/search, les origines sœurs prod ET dev sont
+        # listées explicitement — l'ancienne allowlist (environnement
+        # résolu seul) refusait les pages de l'autre environnement.
+        soeurs = ({origin_of(u) for u in (urls.sso_url, urls.flowdeck_url,
+                                          urls.tiktak_url, urls.public_url)}
+                  | set(PROD_ORIGINS) | set(DEV_ORIGINS)) - {None}
+        origine = request.headers.get("origin", "")
+        if origine not in soeurs:
+            return await call_next(request)
+        headers = {
+            "Access-Control-Allow-Origin": origine,
+            "Access-Control-Allow-Credentials": "true",
+            "Vary": "Origin",
+        }
+        if request.method == "OPTIONS":
+            headers.update({
+                "Access-Control-Allow-Methods": "GET",
+                "Access-Control-Allow-Headers": "Content-Type",
+                "Access-Control-Max-Age": "600",
+            })
+            return JSONResponse({}, status_code=200, headers=headers)
+        response = await call_next(request)
+        response.headers.update(headers)
+        return response
+
+
 app.add_middleware(AuthMiddleware)


+# Recherche partout (#68) : CORS bornée pour GET /api/search — ajouté
+# après AuthMiddleware donc exécuté avant lui (dernier ajouté = le
+# plus externe) : les preflights OPTIONS sont répondus ici, avant
+# tout refus d'authentification.
+from app.recherche import RechercheCorsMiddleware
+
+app.add_middleware(RechercheCorsMiddleware)
+app.add_middleware(DracoAlertesCorsMiddleware)
+
+
 def _safe_next(raw: str) -> str:
    """Only local paths may be a post-login destination."""
    if raw.startswith("/") and not raw.startswith("//") and "://" not in raw:
@@ -1148,6 +1223,12 @@ async def admin_create_connection(
        return RedirectResponse(
            "/admin/connections?err=Nom+et+URL+requis", status_code=303
        )
+    if hook_secret.startswith("coffre:") and not coffre_client.est_reference(hook_secret):
+        return RedirectResponse(
+            "/admin/connections?err=R%C3%A9f%C3%A9rence+coffre+invalide"
+            "+%28format+coffre%3A%3Cslug%3E%2F%3Cnom%3E%29",
+            status_code=303,
+        )
    slug = _unique_slug(_slugify(name), "connections")
    conn_id = models.create_connection(
        slug=slug,
@@ -1192,6 +1273,12 @@ async def admin_update_connection(
    if token:
        fields["token_encrypted"] = forge_crypto.encrypt_token(token)
    if hook_secret:
+        if hook_secret.startswith("coffre:") and not coffre_client.est_reference(hook_secret):
+            return RedirectResponse(
+                "/admin/connections?err=R%C3%A9f%C3%A9rence+coffre+invalide"
+                "+%28format+coffre%3A%3Cslug%3E%2F%3Cnom%3E%29",
+                status_code=303,
+            )
        fields["webhook_secret"] = hook_secret
    if fields:
        models.update_connection(conn_id, **fields)
@@ -2118,6 +2205,7 @@ _NAV_BY_TEMPLATE = {
    "capture.html": "capture",
    "digest.html": "digest",
    "forecast.html": "forecast",
+    "inflight.html": "inflight",
    "rules.html": "rules",
    "health.html": "health",
    "health_project.html": "health",
@@ -2145,6 +2233,31 @@ def render(
        token = secrets.token_urlsafe(32)
    context.setdefault("csrf_token", token)
    context.setdefault("version", APP_VERSION)
+    # Noms publics dracodev par configuration (dev/prod, 0.32.0) :
+    # aucun nom public n'est codé en dur dans les gabarits ni dans le
+    # JS statique — tout vient de app.config (défauts = noms
+    # officiels/prod ; la dev déclare ses noms en ``-dev`` par .env).
+    # Résolution par requête (0.32.2) : les URL rendues suivent
+    # l'hôte public de la requête quand aucune variable explicite
+    # ne les fixe (voir resoudre_urls_draco) — barre, panneau et
+    # CSP de cette même réponse consomment la même résolution.
+    _pub = get_settings()
+    _urls = resoudre_urls_draco(request.headers.get("host"), base=_pub)
+    context.setdefault(
+        "draco_urls",
+        {
+            "obsigate": _urls.sso_url,
+            "flowdeck": _urls.flowdeck_url,
+            "tiktak": _urls.tiktak_url,
+            "kanbante": _urls.public_url,
+        },
+    )
+    context.setdefault("agent_url", _urls.agent_url)
+    context.setdefault(
+        "sso_authorize_url",
+        f"{_urls.sso_url}/sso/authorize?return_to="
+        f"{quote(_urls.public_url + '/auth/draco', safe='')}",
+    )
    # Fusion ACC-1 : initiale de l'opérateur pour la barre d'apps commune.
    context.setdefault(
        "draco_avatar", (get_settings().auth_user or "K")[:1].upper()
@@ -2174,6 +2287,15 @@ def render(
        context.setdefault("user_workspaces", [])
    html = _tpl_env.get_template(name).render(**context)
    response = HTMLResponse(html, status_code=status_code)
+    # CSP du panneau (0.32.2) : la seule iframe de l'app est la
+    # console Spark, chargée depuis l'origine de l'agent résolue
+    # pour CETTE requête — la même que celle injectée au panneau
+    # (DRACO_PANNEAU_CONFIG), jamais une autre. Aucune CSP
+    # n'existait auparavant : l'origine de l'agent n'était énoncée
+    # nulle part.
+    response.headers["Content-Security-Policy"] = (
+        f"frame-src 'self' {_urls.agent_url}"
+    )
    if generated:
        response.set_cookie(CSRF_COOKIE, token, samesite="lax", httponly=True)
    return response
@@ -3112,7 +3234,10 @@ async def project_page(request: Request, owner: str, repo: str):
        est = forecast_service.estimate(opened, weekly)
        milestones.append(
            {
+                "id": m.get("id"),
                "title": m.get("title", ""),
+                "description": m.get("description") or "",
+                "due_iso": due_date.isoformat() if due_date else "",
                "total": total,
                "closed": closed,
                "open": opened,
@@ -3996,6 +4121,88 @@ async def focus(request: Request):
    )


+async def _collect_inflight(ws_repos, ws_id: int) -> dict:
+    """The work in flight, grouped BY COLUMN (issue #24).
+
+    Reuses the Focus pipeline (per-project groups of cards in
+    the workspace's in-flight columns), then pivots: one group
+    per column, cards sorted by age in column, oldest first —
+    the oldest cards are the signal. Ages come from the same
+    _card_ages pipeline as the board.
+    """
+    per_repo = await _collect_focus_groups(ws_repos, ws_id)
+    columns: dict[str, list[dict]] = {
+        key: [] for key in bcols.focus_keys(ws_id)
+    }
+    for group in per_repo:
+        full_name = group["full_name"]
+        cid = group.get("conn_id", registry.default_id)
+        open_issues = [c["issue"] for c in group["cards"]]
+        board = get_board_state(
+            full_name, workspace_id=ws_id, connection_id=cid
+        )
+        ages = _card_ages(
+            full_name, open_issues, board,
+            workspace_id=ws_id, connection_id=cid,
+        )
+        for card in group["cards"]:
+            age = ages.get(card["issue"]["number"]) or {}
+            columns.setdefault(card["column"], []).append(
+                {
+                    "issue": card["issue"],
+                    "repo": full_name,
+                    "column": card["column"],
+                    "age_days": age.get("days", 0),
+                    "age_since": age.get("since", ""),
+                }
+            )
+    groups = []
+    total = 0
+    for key in bcols.keys(ws_id):
+        cards = columns.get(key)
+        if not cards:
+            continue
+        cards.sort(key=lambda c: (-c["age_days"], c["repo"], c["issue"]["number"]))
+        groups.append({"column": key, "cards": cards})
+        total += len(cards)
+    for key, cards in columns.items():
+        if key not in {g["column"] for g in groups} and cards:
+            cards.sort(key=lambda c: (-c["age_days"], c["repo"], c["issue"]["number"]))
+            groups.append({"column": key, "cards": cards})
+            total += len(cards)
+    # Limites WIP globales lisibles : somme, par colonne, des
+    # limites définies dans les projets (0.33.0 : lecture seule).
+    settings = get_settings()
+    wip_globals: dict[str, int] = {}
+    for _repo, limits in (settings.wip_limits or {}).items():
+        for col, limit in (limits or {}).items():
+            try:
+                wip_globals[col] = wip_globals.get(col, 0) + int(limit)
+            except (TypeError, ValueError):
+                continue
+    wip_globals = {c: v for c, v in wip_globals.items() if v > 0}
+    return {"groups": groups, "total": total, "wip_globals": wip_globals}
+
+
+@app.get("/inflight", response_class=HTMLResponse)
+async def inflight(request: Request):
+    """Everything in flight, all projects, grouped by column (#24)."""
+    workspace, _role = _current_workspace(request)
+    ws_id = workspace["id"] if workspace else 1
+    ws_repos, _ws = await _workspace_repos(request)
+    data = await _collect_inflight(ws_repos, ws_id)
+    return render(
+        request,
+        "inflight.html",
+        groups=data["groups"],
+        total=data["total"],
+        wip_globals=data["wip_globals"],
+        column_labels=bcols.names(ws_id),
+        column_colors=bcols.colors(ws_id),
+        aging_days=get_settings().aging_days,
+    )
+
+
 def _group_issue_results(issues: list[dict]) -> list[dict]:
    """Group search results by repo, annotated with the board column."""
    by_repo: dict[str, list[dict]] = {}
@@ -4177,6 +4384,51 @@ async def search_page(request: Request, q: str = ""):
    )


+@app.get("/recherche", response_class=HTMLResponse)
+async def recherche_page(request: Request, q: str = ""):
+    """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. La page /search native reste inchangée.
+    """
+    return render(request, "recherche.html", q=q.strip())
+
+
+@app.get("/api/search")
+async def recherche_api(request: Request, q: str = "", limit: int = 20):
+    """Recherche JSON pour la page « Rechercher partout » (fusion #68).
+
+    Même source que la page /search : recherche Gitea (titres + corps,
+    tous états, tous projets du workspace), groupée par dépôt avec la
+    colonne du tableau. Auth : voir AuthMiddleware (session, Basic,
+    jeton API, ou jeton SSO draco_session pour ce chemin). Les corps
+    sont tronqués à 160 caractères ; seuls les champs utiles sont
+    exposés (voir app/recherche.py).
+    """
+    from app.recherche import groupes_vers_json
+
+    q = q.strip()
+    limit = max(1, min(limit, 50))
+    if not q:
+        return {"query": q, "groups": [], "total": 0}
+    workspace, _role = _current_workspace(request)
+    conn_ids = (
+        models.workspace_connection_ids(workspace["id"])
+        if workspace
+        else [registry.default_id]
+    )
+    results: list[dict] = []
+    for cid in conn_ids:
+        try:
+            found = await _forge_client(cid).search_issues(q=q, state="all")
+            results.extend(found)
+        except Exception as exc:
+            logger.debug("search failed for conn %s: %s", cid, exc)
+    groups = _group_issue_results(results)
+    data, total = groupes_vers_json(groups, limit)
+    return {"query": q, "groups": data, "total": total}
+
+
@app.get("/my", response_class=HTMLResponse)
 async def my_issues(request: Request):
    """Open issues assigned to the token owner, per connection."""
@@ -4211,17 +4463,181 @@ async def my_issues(request: Request):
                logger.debug("search failed for /my (conn %s): %s", cid, exc)
    total = len(results)
    groups = _group_issue_results(results)
+    # Facettes de filtrage (0.33.0) : compteurs calculés une
+    # fois côté serveur ; le filtrage lui-même est instantané
+    # côté client, sur des attributs data-* des lignes.
+    names = _ws_names(request)
+    order = _ws_keys(request)
+    repo_facets = [
+        {"full_name": g["full_name"], "count": len(g["rows"])}
+        for g in groups
+    ]
+    col_counts: dict[str, int] = {}
+    label_counts: dict[str, int] = {}
+    for g in groups:
+        for row in g["rows"]:
+            col_counts[row["column"]] = col_counts.get(row["column"], 0) + 1
+            for label in row["issue"].get("labels") or []:
+                name = label.get("name") or ""
+                if name:
+                    label_counts[name] = label_counts.get(name, 0) + 1
+    column_facets = [
+        {"key": key, "count": col_counts[key]}
+        for key in order
+        if key in col_counts
+    ] + [
+        {"key": key, "count": count}
+        for key, count in col_counts.items()
+        if key not in order
+    ]
+    label_facets = [
+        {"name": name, "count": label_counts[name]}
+        for name in sorted(label_counts, key=str.lower)
+    ]
    return render(
        request,
        "my.html",
        user=user,
        groups=groups,
        total=total,
-        column_labels=_ws_names(request),
+        column_labels=names,
        column_colors=_ws_colors(request),
+        repo_facets=repo_facets,
+        column_facets=column_facets,
+        label_facets=label_facets,
    )


+def _milestone_due_iso(due: str) -> tuple[str | None, bool]:
+    """Validate a YYYY-MM-DD form date -> (ISO instant, ok)."""
+    due = (due or "").strip()
+    if not due:
+        return None, True
+    try:
+        parsed = datetime.strptime(due, "%Y-%m-%d")
+    except ValueError:
+        return None, False
+    # Midi UTC, pas minuit : Gitea renvoie l'échéance dans le
+    # fuseau de son instance (Toronto = UTC-5) — à minuit UTC,
+    # la date affichée reculait d'un jour (attrapé en réel).
+    return parsed.strftime("%Y-%m-%dT12:00:00Z"), True
+
+
+@app.post("/api/repos/{owner}/{repo}/milestones")
+async def api_milestone_create(
+    request: Request,
+    owner: str,
+    repo: str,
+    title: str = Form(""),
+    description: str = Form(""),
+    due_on: str = Form(""),
+    csrf_token: str = Form(""),
+):
+    """Create a milestone on the forge (issue #26)."""
+    if not _csrf_valid(request, csrf_token):
+        return _csrf_error()
+    title = title.strip()
+    if not title or len(title) > 255:
+        return JSONResponse(
+            {"ok": False, "error": "Titre requis (255 caractères max)"},
+            status_code=400,
+        )
+    due_iso, ok = _milestone_due_iso(due_on)
+    if not ok:
+        return JSONResponse(
+            {"ok": False, "error": "Échéance invalide (format AAAA-MM-JJ)"},
+            status_code=400,
+        )
+    client, _cid, _ws = await _resolve_board_scope(request, owner, repo)
+    try:
+        milestone = await client.create_milestone(
+            owner, repo, title, description.strip(), due_iso
+        )
+    except httpx.HTTPStatusError as exc:
+        return JSONResponse(
+            {"ok": False, "error": f"La forge répond {exc.response.status_code}"},
+            status_code=502,
+        )
+    return JSONResponse(
+        {"ok": True, "milestone": {
+            "id": milestone.get("id"),
+            "title": milestone.get("title"),
+            "due_on": milestone.get("due_on"),
+        }},
+        status_code=201,
+    )
+
+
+@app.post("/api/repos/{owner}/{repo}/milestones/{milestone_id}/update")
+async def api_milestone_update(
+    request: Request,
+    owner: str,
+    repo: str,
+    milestone_id: int,
+    title: str = Form(""),
+    due_on: str = Form(""),
+    csrf_token: str = Form(""),
+):
+    """Edit a milestone's title / due date (issue #26).
+
+    An empty due date CLEARS the milestone's deadline.
+    """
+    if not _csrf_valid(request, csrf_token):
+        return _csrf_error()
+    title = title.strip()
+    if not title or len(title) > 255:
+        return JSONResponse(
+            {"ok": False, "error": "Titre requis (255 caractères max)"},
+            status_code=400,
+        )
+    due_iso, ok = _milestone_due_iso(due_on)
+    if not ok:
+        return JSONResponse(
+            {"ok": False, "error": "Échéance invalide (format AAAA-MM-JJ)"},
+            status_code=400,
+        )
+    client, _cid, _ws = await _resolve_board_scope(request, owner, repo)
+    try:
+        milestone = await client.update_milestone(
+            owner, repo, milestone_id, title=title,
+            due_on=due_iso, clear_due=due_iso is None,
+        )
+    except httpx.HTTPStatusError as exc:
+        return JSONResponse(
+            {"ok": False, "error": f"La forge répond {exc.response.status_code}"},
+            status_code=502,
+        )
+    return {"ok": True, "milestone": {
+        "id": milestone.get("id"),
+        "title": milestone.get("title"),
+        "due_on": milestone.get("due_on"),
+    }}
+
+
+@app.post("/api/repos/{owner}/{repo}/milestones/{milestone_id}/close")
+async def api_milestone_close(
+    request: Request,
+    owner: str,
+    repo: str,
+    milestone_id: int,
+    csrf_token: str = Form(""),
+):
+    """Close a milestone on the forge (issue #26)."""
+    if not _csrf_valid(request, csrf_token):
+        return _csrf_error()
+    client, _cid, _ws = await _resolve_board_scope(request, owner, repo)
+    try:
+        await client.update_milestone(
+            owner, repo, milestone_id, state="closed"
+        )
+    except httpx.HTTPStatusError as exc:
+        return JSONResponse(
+            {"ok": False, "error": f"La forge répond {exc.response.status_code}"},
+            status_code=502,
+        )
+    return {"ok": True}
+
+
 # ── Briefing ───────────────────────────────────────────────

 async def _briefing_data() -> dict:
@@ -4594,7 +5010,50 @@ async def _handle_forge_webhook(request: Request, conn_row):
    settings = get_settings()
    raw = await request.body()
    kind = conn_row["kind"] if conn_row else "gitea"
-    secret = (conn_row or {}).get("webhook_secret") or settings.webhook_secret
+    # Secret webhook : une référence coffre:<slug>/<nom> stockée dans
+    # forge_connections.webhook_secret est distribuée à chaque webhook
+    # (Phase 4, issue ObsiGate #22), utilisée en mémoire pour ce seul
+    # HMAC, puis oubliée. Aucun repli : si la distribution échoue
+    # (octroi révoqué, ObsiGate indisponible ou consommateur non
+    # configuré), le webhook échoue proprement avec un message explicite
+    # orientant vers ObsiGate, sans retomber sur le secret d'environnement
+    # ni sur une ancienne valeur (il n'y en a pas de stockée).
+    # Les valeurs historiques en clair et le repli environnement restent
+    # inchangés (compatibilité) tant qu'aucune référence n'est saisie.
+    stocke = (conn_row or {}).get("webhook_secret") or ""
+    if coffre_client.est_reference(stocke):
+        try:
+            secret = await coffre_client.distribuer_async(
+                stocke,
+                contexte_type="webhook",
+                contexte_id=(conn_row or {}).get("slug") or "gitea",
+            )
+        except coffre_client.CoffreAccesRefuse as exc:
+            return JSONResponse(
+                {
+                    "ok": False,
+                    "error": "Accès révoqué ou refusé dans ObsiGate : "
+                    "ré-accorder l'octroi du secret webhook pour le "
+                    "consommateur Kanbante dans ObsiGate, puis renvoyer "
+                    "le webhook.",
+                    "detail": str(exc),
+                },
+                status_code=401,
+            )
+        except coffre_client.CoffreErreur as exc:
+            return JSONResponse(
+                {
+                    "ok": False,
+                    "error": "ObsiGate indisponible ou consommateur Kanbante "
+                    "non configuré : impossible de vérifier ce webhook "
+                    "sans distribuer son secret. Vérifier ObsiGate, puis "
+                    "renvoyer le webhook.",
+                    "detail": str(exc),
+                },
+                status_code=503,
+            )
+    else:
+        secret = stocke or settings.webhook_secret
    if secret:
        if kind == "github":
            signature = request.headers.get("x-hub-signature-256", "")
@@ -5118,38 +5577,34 @@ async def activity(request: Request):

 # ── Routes: API ────────────────────────────────────────────

-@app.post("/api/move")
-async def api_move(
-    request: Request,
-    repo_full_name: str = Form(...),
-    issue_number: int = Form(...),
-    to_column: str = Form(...),
-    from_column: str = Form(""),
-    to_order: str = Form(""),
-    from_order: str = Form(""),
-    csrf_token: str = Form(""),
-):
-    """Move an issue to a new column and persist the resulting order.
+async def _do_move_card(
+    repo_full_name: str,
+    issue_number: int,
+    to_column: str,
+    *,
+    from_column: str = "",
+    to_order: str = "",
+    from_order: str = "",
+    client,
+    conn_id: int,
+    ws_id: int,
+    source: str = "ui",
+) -> dict:
+    """Déplacement effectif d'une carte, une fois la portée résolue.

-    With KANBANTE_SYNC_GITEA enabled (default), moving to "done" closes
-    the issue in Gitea and moving out of "done" reopens it. A failed
-    write-back is reported in the response (gitea_sync="failed") instead
-    of failing the move itself.
+    Board local (placement + ordres), journal des événements,
+    write-back Gitea (fermeture en entrant dans « done »,
+    réouverture en en sortant — échecs rapportés, jamais
+    bloquants) et miroir de l'étiquette kanban:* de la colonne
+    (les autres étiquettes de l'issue sont préservées).
+
+    Partagé par POST /api/move (interface, source « ui ») et par
+    l'outil MCP move_issue (source « mcp ») — même patron que
+    _do_capture pour la création. L'outil MCP refuse la colonne
+    « done » en amont : y entrer ferme l'issue, et Terminé
+    appartient à Bruno dans son interface.
    """
-    if not _csrf_valid(request, csrf_token):
-        return _csrf_error()
-    parts = _split_full_name(repo_full_name)
-    if parts is None:
-        return JSONResponse(
-            {"ok": False, "error": "Invalid repo_full_name"}, status_code=400
-        )
-    owner, repo = parts
-    client, conn_id, ws_id = await _resolve_board_scope(request, owner, repo)
-    if to_column not in bcols.keys(ws_id):
-        return JSONResponse(
-            {"ok": False, "error": "Invalid column"}, status_code=400
-        )
-
+    owner, repo = _split_full_name(repo_full_name)
    move_issue(
        repo_full_name, issue_number, to_column,
        workspace_id=ws_id, connection_id=conn_id,
@@ -5175,7 +5630,7 @@ async def api_move(
    if from_column != to_column:
        log_event(
            repo_full_name, issue_number, "moved",
-            from_column or None, to_column,
+            from_column or None, to_column, source=source,
            workspace_id=ws_id, connection_id=conn_id,
        )
        # Émission Lot 2 (journal du service d'agents) : le titre
@@ -5189,7 +5644,7 @@ async def api_move(
                titre_carte = ""
        _emettre_changement_colonne(
            repo_full_name, issue_number, from_column or None, to_column,
-            "ui", title=titre_carte,
+            source, title=titre_carte,
        )

    result: dict = {"ok": True, "gitea_sync": "skipped"}
@@ -5201,14 +5656,14 @@ async def api_move(
                result["gitea_sync"] = "closed"
                log_event(
                    repo_full_name, issue_number, "closed", to_column="done",
-                    workspace_id=ws_id, connection_id=conn_id,
+                    source=source, workspace_id=ws_id, connection_id=conn_id,
                )
            elif from_column == "done":
                await client.set_issue_state(owner, repo, issue_number, "open")
                result["gitea_sync"] = "reopened"
                log_event(
                    repo_full_name, issue_number, "reopened",
-                    from_column="done", to_column=to_column,
+                    from_column="done", to_column=to_column, source=source,
                    workspace_id=ws_id, connection_id=conn_id,
                )
        except httpx.HTTPError as exc:
@@ -5254,6 +5709,46 @@ async def api_move(
    return result


+@app.post("/api/move")
+async def api_move(
+    request: Request,
+    repo_full_name: str = Form(...),
+    issue_number: int = Form(...),
+    to_column: str = Form(...),
+    from_column: str = Form(""),
+    to_order: str = Form(""),
+    from_order: str = Form(""),
+    csrf_token: str = Form(""),
+):
+    """Move an issue to a new column and persist the resulting order.
+
+    With KANBANTE_SYNC_GITEA enabled (default), moving to "done" closes
+    the issue in Gitea and moving out of "done" reopens it. A failed
+    write-back is reported in the response (gitea_sync="failed") instead
+    of failing the move itself.
+    """
+    if not _csrf_valid(request, csrf_token):
+        return _csrf_error()
+    parts = _split_full_name(repo_full_name)
+    if parts is None:
+        return JSONResponse(
+            {"ok": False, "error": "Invalid repo_full_name"}, status_code=400
+        )
+    owner, repo = parts
+    client, conn_id, ws_id = await _resolve_board_scope(request, owner, repo)
+    if to_column not in bcols.keys(ws_id):
+        return JSONResponse(
+            {"ok": False, "error": "Invalid column"}, status_code=400
+        )
+
+    return await _do_move_card(
+        repo_full_name, issue_number, to_column,
+        from_column=from_column, to_order=to_order,
+        from_order=from_order, client=client, conn_id=conn_id,
+        ws_id=ws_id, source="ui",
+    )
+
+
@app.post("/api/issues")
 async def api_create_issue(
    request: Request,
@@ -5952,9 +6447,10 @@ async def api_toggle_issue_label(

 # ── MCP server (tools over JSON-RPC) ───────────────────────
 # Lectures depuis la 0.5.0 ; écritures minimales (create_issue,
-# add_comment) depuis la 0.26.0, gardées par la même authentification
-# que tout /mcp (session, Basic ou jeton d'API kbt_ — voir le
-# middleware : un jeton n'ouvre jamais l'interface web).
+# add_comment) depuis la 0.26.0, move_issue depuis la 0.36.0,
+# gardées par la même authentification que tout /mcp (session,
+# Basic ou jeton d'API kbt_ — voir le middleware : un jeton
+# n'ouvre jamais l'interface web).

 MCP_TOOLS = [
    {
@@ -6053,15 +6549,77 @@ MCP_TOOLS = [
            "required": ["owner", "repo", "number", "body"],
        },
    },
+    {
+        "name": "move_issue",
+        "description": "Move a card (issue) to another board column. "
+        "column accepts the column key (backlog, todo, in_progress, "
+        "qa, review), the forge label (kanban:review) or the French "
+        "display label (« À faire », « En cours », « Révision »…). "
+        "The kanban:* label on the issue is replaced; its other "
+        "labels are preserved. Moving to done (« Terminé ») is "
+        "REFUSED: that column belongs to the human owner — agents "
+        "stop at review. Write tool — same /mcp authentication as "
+        "the reads (kbt_ API token, session or Basic).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "owner": {"type": "string"},
+                "repo": {"type": "string"},
+                "number": {"type": "integer"},
+                "column": {"type": "string"},
+            },
+            "required": ["owner", "repo", "number", "column"],
+        },
+    },
 ]


+def _plier_libelle_colonne(valeur: str) -> str:
+    """Plie un libellé de colonne pour comparaison tolérante :
+    minuscules, accents retirés, emoji et ponctuation éliminés,
+    séparateurs unifiés en espaces (« in_progress »,
+    « in-progress » et « In progress » se rejoignent)."""
+    texte = unicodedata.normalize("NFKD", valeur or "")
+    texte = "".join(c for c in texte if not unicodedata.combining(c))
+    return re.sub(r"[^a-z0-9]+", " ", texte.lower()).strip()
+
+
+def _normaliser_colonne_mcp(brut: str, ws_id: int) -> str:
+    """Résout la colonne visée par l'outil MCP move_issue.
+
+    Accepte la clé (« review »), l'étiquette de forge
+    (« kanban:review », alias d'espace compris) et le libellé
+    français affiché (« Révision », « À faire »…) — les noms
+    d'affichage viennent de la définition des colonnes de
+    l'espace, pas d'une table figée. Lève ValueError, avec la
+    liste des colonnes valides, si rien ne correspond.
+    """
+    candidats: dict[str, str] = {}
+    for colonne in bcols.get_columns(ws_id):
+        cle = colonne["key"]
+        candidats[_plier_libelle_colonne(cle)] = cle
+        candidats[_plier_libelle_colonne(colonne.get("name") or "")] = cle
+        if colonne.get("label"):
+            candidats[_plier_libelle_colonne(colonne["label"])] = cle
+    for etiquette, cle in bcols.label_lookup(ws_id).items():
+        candidats[_plier_libelle_colonne(etiquette)] = cle
+    candidats["to do"] = "todo"
+    visee = _plier_libelle_colonne(brut)
+    if visee in candidats:
+        return candidats[visee]
+    valides = ", ".join(bcols.keys(ws_id))
+    raise ValueError(
+        f"Colonne inconnue : « {brut} ». Colonnes valides : {valides}."
+    )
+
+
 async def _mcp_call_tool(name: str, args: dict) -> str:
    """Execute one MCP tool and return text content.

-    Reads hit the forge's read API; the two write tools
-    (create_issue, add_comment) reuse the existing creation /
-    comment services — never a reimplemented forge call.
+    Reads hit the forge's read API; the write tools reuse the
+    existing services (creation via _do_capture, comment via the
+    forge client, move via _do_move_card) — never a reimplemented
+    forge call.
    """
    if name == "list_projects":
        repos = await gitea.search_repos()
@@ -6182,6 +6740,65 @@ async def _mcp_call_tool(name: str, args: dict) -> str:
            },
            ensure_ascii=False,
        )
+    if name == "move_issue":
+        owner, repo = args["owner"], args["repo"]
+        number = int(args["number"])
+        full_name = f"{owner}/{repo}"
+        client, conn_id = await _client_for_repo(full_name)
+        ws_id = next(
+            (
+                ws["id"]
+                for ws in models.list_workspaces()
+                if conn_id in models.workspace_connection_ids(ws["id"])
+            ),
+            1,
+        )
+        target = _normaliser_colonne_mcp(str(args.get("column") or ""), ws_id)
+        if target == "done":
+            # Garde doctrine : Terminé appartient à Bruno dans son
+            # interface — refus avant toute écriture (entrer dans
+            # « done » fermerait l'issue côté forge).
+            raise ValueError(
+                "Colonne refusée : « Terminé » (done) appartient à "
+                "Bruno — les agents s'arrêtent en Révision (review)."
+            )
+        try:
+            issue = await client.get_issue(owner, repo, number)
+        except httpx.HTTPStatusError as exc:
+            if exc.response is not None and exc.response.status_code == 404:
+                raise ValueError(
+                    f"Dépôt ou issue inconnu : {full_name}#{number}"
+                ) from exc
+            raise
+        if issue.get("pull_request"):
+            raise ValueError(
+                f"{full_name}#{number} est une pull request, pas une carte."
+            )
+        placement: dict[int, str] = {}
+        for col_name, cards in get_board_state(full_name).items():
+            for card in cards:
+                placement[card["issue_number"]] = col_name
+        from_column = placement.get(number)
+        if from_column is None:
+            from_column = (
+                "done" if issue.get("state") == "closed" else "backlog"
+            )
+        result = await _do_move_card(
+            full_name, number, target,
+            from_column=from_column,
+            client=client, conn_id=conn_id, ws_id=ws_id, source="mcp",
+        )
+        return json.dumps(
+            {
+                "repo_full_name": full_name,
+                "number": number,
+                "title": issue.get("title", ""),
+                "from_column": from_column,
+                "column": target,
+                **result,
+            },
+            ensure_ascii=False,
+        )
    raise ValueError(f"Unknown tool: {name}")


@@ -6193,7 +6810,7 @@ async def mcp_info():
        "version": APP_VERSION,
        "transport": "streamable-http (JSON-RPC 2.0 over POST)",
        "read_only": False,
-        "write_tools": ["create_issue", "add_comment"],
+        "write_tools": ["create_issue", "add_comment", "move_issue"],
        "tools": [t["name"] for t in MCP_TOOLS],
    }

@@ -6202,8 +6819,9 @@ async def mcp_info():
 async def mcp_endpoint(request: Request):
    """Minimal MCP server: initialize / tools/list / tools/call / ping.

-    Reads since 0.5.0; since 0.26.0, two minimal write tools
-    (create_issue, add_comment) for the agent service, guarded by
+    Reads since 0.5.0; since 0.26.0, minimal write tools
+    (create_issue, add_comment — move_issue since 0.36.0) for the
+    agent service, guarded by
    the same /mcp authentication as the reads (session, Basic or
    kbt_ API token — a token never unlocks the web UI).
    """
@@ -6414,3 +7032,4 @@ async def readiness():
        },
        status_code=200 if ready else 503,
    )
+
@@ -0,0 +1,225 @@
+"""Recherche fédérée (fusion-trois-apps #68) : JSON de recherche,
+CORS bornée et conversion des groupes d'issues.
+
+Ce module ne dépend d'aucun autre module applicatif à l'import (les
+résolveurs sont appelés paresseusement) : les fonctions pures sont
+testables sans base ni serveur.
+
+- ``GET /api/search`` (route dans ``app/main.py``) réutilise la
+  recherche Gitea de la page ``/search`` (titres + corps, tous états,
+  tous projets du workspace) et la regroupe par dépôt.
+- La CORS bornée n'autorise que ``GET /api/search``, et seulement
+  pour les origines sœurs officielles **prod ET dev, listées
+  explicitement** (``PROD_ORIGINS | DEV_ORIGINS``), **plus** les
+  origines résolues par ``app.config`` — jamais ``*``. Correctif
+  2026-10-28 (fusion #68/#69, matrice constatée par Bruno) :
+  l'ancienne allowlist ne contenait que l'environnement résolu
+  (prod OU dev), donc une page de l'autre environnement voyait sa
+  section afficher « Injoignable depuis cet hôte (CORS ou réseau) ».
+  Le middleware est un ASGI pur :
+  il répond lui-même aux preflights OPTIONS (qui ne portent jamais
+  de cookies, donc qu'``AuthMiddleware`` refuserait sinon) et ajoute
+  les en-têtes aux réponses de recherche, sans toucher aux autres
+  routes.
+"""
+
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+SEARCH_PATH = "/api/search"
+_SNIPPET_LEN = 160
+
+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 du dictionnaire rendu par render() (app/main.py).
+_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()
+    if not h.endswith(".dracodev.net"):
+        return False
+    first = h.split(".")[0]
+    return len(first) > 4 and 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 ``draco_urls`` rendu par ``render()``.
+    Sans argument, le résolveur est appelé (import paresseux) avec
+    l'hôte de la requête quand il est connu — ce middleware s'exécute
+    avant tout poseur de contexte d'hôte, et sans lui la résolution
+    retomberait sur la configuration seule et raterait l'environnement
+    ``-dev`` ; en cas d'échec, repli sur prod + dev officiels
+    (premier parti uniquement).
+    """
+    if resolved is None:
+        try:
+            from app.config import get_settings, resoudre_urls_draco
+
+            urls = resoudre_urls_draco(hote_requete=request_host, base=get_settings())
+            resolved = {
+                "obsigate": urls.sso_url,
+                "flowdeck": urls.flowdeck_url,
+                "tiktak": urls.tiktak_url,
+                "kanbante": urls.public_url,
+            }
+        except Exception:
+            return PROD_ORIGINS | DEV_ORIGINS
+    origins = set()
+    for key in _SOEUR_KEYS:
+        origin = origin_of((resolved or {}).get(key))
+        if origin:
+            origins.add(origin)
+    # Correctif 2026-10-28 : prod ET dev toujours, quelle que soit
+    # la résolution — ``resolved`` n'ajoute que des origines de
+    # configuration sans jamais retirer une origine officielle.
+    return frozenset(origins) | PROD_ORIGINS | DEV_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
+
+
+def groupes_vers_json(groups, limit: int = 20):
+    """Convertit la sortie de ``_group_issue_results`` en JSON public.
+
+    Seuls les champs utiles sont exposés (numéro, titre, état, corps
+    tronqué à 160 caractères, labels, colonne). Retourne
+    ``(groupes, total)`` où ``total`` est le nombre de lignes
+    retournées (plafonné à ``limit``).
+    """
+    out: list[dict] = []
+    total = 0
+    restant = max(1, min(int(limit), 50))
+    for group in groups or []:
+        rows: list[dict] = []
+        for row in (group or {}).get("rows", []) or []:
+            if restant <= 0:
+                break
+            issue = (row or {}).get("issue", {}) or {}
+            labels = []
+            for label in issue.get("labels") or []:
+                if isinstance(label, dict):
+                    labels.append({"name": label.get("name"), "color": label.get("color")})
+            rows.append({
+                "issue": {
+                    "number": issue.get("number"),
+                    "title": issue.get("title"),
+                    "state": issue.get("state"),
+                    "body": (issue.get("body") or "")[:_SNIPPET_LEN],
+                    "labels": labels,
+                },
+                "column": (row or {}).get("column"),
+            })
+            restant -= 1
+            total += 1
+        if rows:
+            out.append({"full_name": (group or {}).get("full_name"), "rows": rows})
+        if restant <= 0:
+            break
+    return out, total
+
+
+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("host", "") or headers_in.get("x-forwarded-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:
+                body = b""
+                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": body})
+                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)
@@ -1,12 +1,19 @@
 {# Barre d'apps commune dracodev — Fusion ACC-1 (issue kanbante#28).
-   Snippet FIGÉ vendangé depuis Projets/dracodev-commons v0.1.4
-   (ui/barre-apps/) : ne pas modifier la structure ici ; toute évolution
-   passe par une nouvelle version de commons.
+   Snippet vendangé depuis Projets/dracodev-commons v0.1.6
+   (ui/barre-apps/) : structure inchangée ; seule adaptation locale
+   (0.32.0, dev/prod) = les URL des apps et l'adresse du service
+   d'agents sont INJECTÉES par l'hôte depuis app.config
+   (draco_urls / agent_url, défauts = noms officiels) — aucun nom
+   public codé en dur dans ce gabarit ni dans draco-panneau.js.
+   Chantier 5 (fusion #69/#71, sans bump) : 5e onglet Console Spark
+   (data-app="agent", agent_url), après Kanbante ; l'entrée
+   « Console Spark » du menu de la marque est conservée.
   CSS/JS : /static/css/draco-barre.css, /static/js/draco-barre.js.
   Inclus par _header.html (toutes les pages applicatives ; ni le
   wallboard ni l'écran de connexion, volontaires). #}
 <link rel="stylesheet" href="/static/css/draco-barre.css?v={{ version }}">
 <link rel="stylesheet" href="/static/css/draco-panneau.css?v={{ version }}">
+<link rel="stylesheet" href="/static/css/draco-alertes.css?v={{ version }}">
 <script>document.body.classList.add('has-draco-bar');</script>
 <header class="draco-bar" data-current="kanbante">
    <div class="draco-bar-zone draco-bar-gauche">
@@ -15,24 +22,28 @@
            <span class="draco-brand-mark">✦</span><span class="draco-brand-name">dracodev</span>
        </a>
        <nav class="draco-apptabs" aria-label="Applications">
-            <a class="draco-apptab" data-app="obsigate" href="https://og.dracodev.net/">
+            <a class="draco-apptab" data-app="obsigate" href="{{ draco_urls.obsigate }}/">
                <span class="draco-apptab-ico" style="--app:#7a5af5">▤</span>
                <span class="draco-apptab-txt"><strong>ObsiGate</strong><small>Notes</small></span>
            </a>
-            <a class="draco-apptab" data-app="flowdeck" href="https://flowdeck.dracodev.net/">
+            <a class="draco-apptab" data-app="flowdeck" href="{{ draco_urls.flowdeck }}/">
                <span class="draco-apptab-ico" style="--app:#2f6fed">▦</span>
                <span class="draco-apptab-txt"><strong>Flowdeck</strong><small>Projets</small></span>
            </a>
-            <a class="draco-apptab" data-app="tiktak" href="https://tiktak.dracodev.net/">
+            <a class="draco-apptab" data-app="tiktak" href="{{ draco_urls.tiktak }}/">
                <span class="draco-apptab-ico" style="--app:#e8762c">✓</span>
                <span class="draco-apptab-txt"><strong>TikTak</strong><small>Tâches</small></span>
                <span class="draco-badge" data-badge="tiktak" hidden>0</span>
            </a>
-            <a class="draco-apptab" data-app="kanbante" href="https://kanbante.dracodev.net/">
+            <a class="draco-apptab" data-app="kanbante" href="{{ draco_urls.kanbante }}/">
                <span class="draco-apptab-ico" style="--app:#0d9488">▥</span>
                <span class="draco-apptab-txt"><strong>Kanbante</strong><small>Kanban</small></span>
                <span class="draco-badge" data-badge="kanbante" hidden>0</span>
            </a>
+            <a class="draco-apptab" data-app="agent" href="{{ agent_url }}/">
+                <span class="draco-apptab-ico" style="--app:#c2437e">✦</span>
+                <span class="draco-apptab-txt"><strong>Console Spark</strong><small>Agent commun</small></span>
+            </a>
        </nav>
    </div>
    <div class="draco-bar-zone draco-bar-centre">
@@ -58,8 +69,7 @@
            <span class="draco-spark-ico">✦</span><span class="draco-spark-txt">Spark</span>
            <span class="draco-badge" data-badge="spark" hidden>0</span>
        </button>
-        <button type="button" class="draco-icon-btn" data-act="menu" aria-label="Plus d'actions" aria-haspopup="menu">•••</button>
-        <span class="draco-avatar" title="Opérateur Kanbante">{{ draco_avatar }}</span>
+        <button type="button" class="draco-avatar" data-act="compte" aria-label="Compte" aria-haspopup="menu" aria-expanded="false" title="Opérateur Kanbante">{{ draco_avatar }}</button>
    </div>
 </header>
 <div class="draco-bar-rappel" data-act="rappel-entete" hidden>✦ dracodev — afficher l'en-tête</div>
@@ -68,10 +78,19 @@
       Phase 1 : navigation entre apps et domaine mémorisé localement ;
       le rail pilote le repli natif de la barre latérale, la palette
       ouvre la recherche & commandes native (Ctrl+K) ; les alertes
-       unifiées, la recherche fédérée et Spark arrivent avec les
-       phases suivantes du programme Fusion. */
+       unifiées passent par le panneau draco-alertes.js (Fusion #69,
+       agrégation à la demande, pas une fédération temps réel) ;
+       recherche partout : page /recherche (Fusion #68). */
    window.DRACO_BAR_CONFIG = {
        current: "kanbante",
+        /* v0.1.6 : user = initiale auth_user ou K (draco_avatar). Sans
+           cfg.user, le nouveau JS dériverait l'initiale du title
+           ("Opérateur Kanbante" → "O"), qui est un libellé de rôle et
+           non un nom. Contrepartie documentée : syncAvatar() réécrit
+           aussi le title avec le nom d'affichage, donc l'infobulle
+           devient l'initiale après chargement (le libellé reste dans
+           le HTML servi). */
+        user: "{{ draco_avatar }}",
        domain: (function () { try { return localStorage.getItem("draco_domain") || "pro"; } catch (e) { return "pro"; } })(),
        counts: {},
        onAction: function (act, el) {
@@ -84,9 +103,9 @@
            };
            if (act === "domaine") { try { localStorage.setItem("draco_domain", el.dataset.dom); } catch (e) { } return; }
            if (act === "rail") { var b = document.getElementById("side-collapse"); if (b) b.click(); return; }
-            if (act === "palette") { var p = document.querySelector(".palette-trigger"); if (p) { p.click(); } else { dire("Recherche & commandes : Ctrl+K."); } return; }
-            if (act === "alertes") { dire("Alertes unifiées : arrive avec la fédération (programme Fusion)."); return; }
-            if (act === "menu") { dire("Menu commun : arrive avec la fédération (programme Fusion)."); return; }
+            if (act === "palette") { location.href = "/recherche"; return; }
+            if (act === "alertes") { if (window.DRACO_ALERTES) { window.DRACO_ALERTES.open(); } else { location.href = "/activity"; } return; }
+            /* Correctif fusion #70 : action "menu" supprimée avec le bouton trois points (console agent dans le menu de la marque). */
            if (act === "spark") {
                if (window.DRACO_PANNEAU) { window.DRACO_PANNEAU.toggle(); }
                else { dire("Spark : le panneau n'a pas pu se charger."); }
@@ -101,4 +120,7 @@
    };
 </script>
 <script defer src="/static/js/draco-barre.js?v={{ version }}"></script>
+<script>window.DRACO_PANNEAU_CONFIG = { api: "{{ agent_url }}" };</script>
 <script defer src="/static/js/draco-panneau.js?v={{ version }}"></script>
+<script defer src="/static/js/draco-alertes.js?v={{ version }}"></script>
+
@@ -20,6 +20,7 @@
        ("digest", "/digest", "🧠", "Digest"),
    ]),
    ("pilotage", "Pilotage", [
+        ("inflight", "/inflight", "🛩️", "En vol"),
        ("forecast", "/forecast", "🔮", "Prévisions"),
        ("health", "/health", "🩺", "Santé"),
        ("rules", "/rules", "⚙️", "Règles"),
@@ -35,7 +35,7 @@
                <label>Nom <input type="text" name="name" value="{{ c.name }}"></label>
                <label>URL de base <input type="text" name="base_url" value="{{ c.base_url }}"></label>
                <label>Nouveau jeton (vide = inchangé) <input type="password" name="token" autocomplete="off" placeholder="••••••••"></label>
-                <label>Secret webhook (vide = inchangé) <input type="password" name="hook_secret" autocomplete="off" placeholder="••••••••"></label>
+                <label>Secret webhook (vide = inchangé, ou référence coffre:&lt;slug&gt;/&lt;nom&gt;) <input type="password" name="hook_secret" autocomplete="off" placeholder="••••••••"></label>
                <button type="submit" class="btn-save btn-inline">Enregistrer</button>
            </form>
            <p class="admin-actions">
@@ -68,10 +68,10 @@
                <label>Nom <input type="text" name="name" required placeholder="GitHub perso"></label>
                <label>URL de base <input type="text" name="base_url" required placeholder="https://api.github.com ou https://git.exemple.net"></label>
                <label>Jeton d'accès <input type="password" name="token" autocomplete="off"></label>
-                <label>Secret webhook (optionnel) <input type="password" name="hook_secret" autocomplete="off"></label>
+                <label>Secret webhook (optionnel, ou référence coffre:&lt;slug&gt;/&lt;nom&gt;) <input type="password" name="hook_secret" autocomplete="off" placeholder="coffre:<slug>/<nom>"></label>
                <button type="submit" class="btn-save btn-inline">Ajouter</button>
            </form>
-            <p class="notes-hint">Pour GitHub, un jeton personnel (PAT) avec accès aux dépôts visés suffit. Ajoute ensuite la connexion à un espace (Administration → Espaces) pour voir ses projets.</p>
+            <p class="notes-hint">Secret webhook : une référence <code>coffre:&lt;slug&gt;/&lt;nom&gt;</code> est stockée telle quelle (jamais la valeur) et distribuée par ObsiGate à chaque webhook, puis oubliée ; octroi révoqué ou ObsiGate indisponible = webhook rejeté, sans repli. Les jetons d'accès forge, eux, restent chiffrés au repos (voir app/forge_crypto.py) et ne basculent pas encore sur une référence — voir docs/coffre-reference-obsigate.md. Pour GitHub, un jeton personnel (PAT) avec accès aux dépôts visés suffit. Ajoute ensuite la connexion à un espace (Administration → Espaces) pour voir ses projets.</p>
        </section>
    </main>
 </body>
@@ -5,11 +5,11 @@
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="csrf-token" content="{{ csrf_token }}">
    <title>{{ repo }} — Kanbante</title>
-    <link rel="stylesheet" href="/static/css/style.css">
+    <link rel="stylesheet" href="/static/css/style.css?v={{ version }}">
    <script src="/static/vendor/sortable.min.js"></script>
    <script src="/static/vendor/marked.min.js"></script>
    <script src="/static/vendor/purify.min.js"></script>
-    <script src="/static/js/board.js" defer></script>
+    <script src="/static/js/board.js?v={{ version }}" defer></script>
 </head>
 <body>
    {% include "_header.html" %}
@@ -54,13 +54,24 @@
        <button type="button" id="labels-btn" class="btn-sm">🏷️ Gérer les étiquettes</button>
        <a href="/triage/{{ full_name }}" class="btn-sm" style="text-decoration:none">📥 Triage du backlog</a>
        {% if is_admin or workspace_role == 'admin' %}<a href="/admin/columns" class="btn-sm" style="text-decoration:none" title="Personnaliser les colonnes de cet espace">🧱 Colonnes</a>{% endif %}
-        <form id="create-issue-form">
-            <input type="text" id="new-issue-title" maxlength="255"
-                   placeholder="➕ Nouvelle issue (titre)..." required>
-            <button type="button" id="new-issue-desc-toggle" class="btn-sm" title="Ajouter une description">＋ Description</button>
-            <button type="submit" class="btn-save btn-inline">Créer</button>
-            <textarea id="new-issue-body" rows="4" maxlength="100000" hidden
-                      placeholder="Description (markdown)..."></textarea>
+        <form id="create-issue-form" class="composer">
+            <div class="composer-head">
+                <span class="composer-title">➕ Nouvelle issue</span>
+                <span class="composer-target">arrive dans
+                    <strong>{{ column_labels.backlog }}</strong>
+                </span>
+            </div>
+            <div class="composer-main">
+                <input type="text" id="new-issue-title" maxlength="255"
+                       placeholder="Titre de l'issue..." required>
+                <button type="submit" class="btn-save btn-inline">Créer l'issue</button>
+            </div>
+            <details class="composer-desc" id="new-issue-desc">
+                <summary><span class="composer-desc-label">Ajouter une description</span><span class="composer-chevron" aria-hidden="true">▾</span></summary>
+                <textarea id="new-issue-body" rows="5" maxlength="100000"
+                          placeholder="Description (markdown)..."></textarea>
+                <p class="composer-hint">Markdown accepté · Ctrl+Entrée pour créer l'issue</p>
+            </details>
        </form>
    </div>

@@ -64,6 +64,7 @@
            <label class="dash-tool">Tri
                <select id="dash-sort">
                    <option value="default">Par défaut</option>
+                    <option value="review">🔍 En attente de revue ↓</option>
                    <option value="updated">Activité Gitea récente</option>
                    <option value="activity">Activité kanban récente</option>
                    <option value="open">Issues ouvertes ↓</option>
@@ -85,6 +86,7 @@
                 data-full="{{ full }}" data-home="{{ repo.home_tab or '' }}"
                 data-name="{{ repo.name|lower }}" data-owner="{{ repo.owner.login }}"
                 data-updated="{{ repo.updated_at }}" data-open="{{ repo.open_issues_count or 0 }}"
+                 data-review="{{ stats.get(full, {}).get('review', 0) if stats else 0 }}"
                 data-activity="{{ repo.activity.last_at if repo.activity else '' }}"
                 data-search="{{ (repo.name ~ ' ' ~ repo.full_name ~ ' ' ~ (repo.description or ''))|lower }}"
                 x-show="search === '' || $el.dataset.search.includes(search.toLowerCase())">
@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+<html lang="fr" data-theme="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>En vol partout — Kanbante</title>
+    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🛩️</text></svg>">
+    <link rel="stylesheet" href="/static/css/style.css?v={{ version }}">
+</head>
+<body>
+    {% include "_header.html" %}
+
+    <main class="focus-main">
+        <p class="focus-intro">Tout ce qui est <strong>en vol</strong>, tous projets actifs confondus —
+            regroupé par colonne, les cartes les plus anciennes d'abord.</p>
+
+        <div class="inflight-summary">
+            <span class="inflight-total">🛩️ {{ total }} carte{{ 's' if total != 1 }} en vol</span>
+            {% for group in groups %}
+            <span class="col-chip" style="background: {{ column_colors[group.column] }}20; color: {{ column_colors[group.column] }}">
+                {{ column_labels[group.column] }} · {{ group.cards|length }}{% if wip_globals.get(group.column) %} / limite globale {{ wip_globals[group.column] }}{% endif %}
+            </span>
+            {% endfor %}
+        </div>
+
+        {% if not groups %}
+        <p class="focus-empty">🎉 Rien en vol pour le moment — aucun encours, aucune révision en attente.</p>
+        {% endif %}
+
+        {% for group in groups %}
+        <section class="focus-group">
+            <h2>
+                <span class="filter-chip-dot" style="background: {{ column_colors[group.column] }}"></span>
+                {{ column_labels[group.column] }}
+                <span class="badge secondary">{{ group.cards|length }}</span>
+                {% if wip_globals.get(group.column) %}
+                <span class="inflight-wip">limite WIP globale : {{ wip_globals[group.column] }} (somme des projets qui en définissent une)</span>
+                {% endif %}
+            </h2>
+            <div class="focus-cards">
+                {% for card in group.cards %}
+                <div class="kanban-card focus-card">
+                    <div class="card-id">
+                        #{{ card.issue.number }}
+                        <a class="inflight-repo" href="/board/{{ card.repo }}">{{ card.repo }}</a>
+                        {% if card.issue.html_url %}
+                        <a href="{{ card.issue.html_url }}" target="_blank" title="Ouvrir dans Gitea">↗</a>
+                        {% endif %}
+                    </div>
+                    <div class="card-title">{{ card.issue.title }}</div>
+                    {% if card.issue.labels %}
+                    <div class="card-labels">
+                        {% for label in card.issue.labels %}
+                        <span class="label-tag" style="background: #{{ label.color }}30; color: #{{ label.color }}">
+                            {{ label.name }}
+                        </span>
+                        {% endfor %}
+                    </div>
+                    {% endif %}
+                    <div class="card-meta">
+                        {% if card.issue.assignee %}
+                        <img src="{{ card.issue.assignee.avatar_url }}" class="avatar" alt="{{ card.issue.assignee.login }}">
+                        {% endif %}
+                        <span class="age-badge{% if card.age_days >= aging_days * 2 %} stale{% elif card.age_days >= aging_days %} warn{% endif %}"
+                              title="Dans cette colonne depuis le {{ card.age_since[:10] }}">⏳ {{ card.age_days }} j dans la colonne</span>
+                    </div>
+                </div>
+                {% endfor %}
+            </div>
+        </section>
+        {% endfor %}
+    </main>
+
+    <footer>
+        Kanbante v{{ version }} · en vol partout
+    </footer>
+    <script src="/static/js/live.js" defer></script>
+{% include "_palette.html" %}
+<script src="/static/js/palette.js" defer></script>
+</body>
+</html>
@@ -29,7 +29,7 @@
                </label>
                <button type="submit" class="login-submit">Se connecter</button>
            </form>
-            <a class="login-sso" href="https://og.dracodev.net/sso/authorize?return_to=https%3A%2F%2Fkanbante.dracodev.net%2Fauth%2Fdraco">🧭 Se connecter avec ObsiGate (SSO)</a>
+            <a class="login-sso" href="{{ sso_authorize_url }}">🧭 Se connecter avec ObsiGate (SSO)</a>
            <p class="login-foot">Accès restreint — session de {{ 7 }} jours, déconnexion depuis le menu latéral.</p>
        </section>
    </main>
@@ -5,7 +5,7 @@
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Mes issues — Kanbante</title>
    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>👤</text></svg>">
-    <link rel="stylesheet" href="/static/css/style.css">
+    <link rel="stylesheet" href="/static/css/style.css?v={{ version }}">
 </head>
 <body>
    {% include "_header.html" %}
@@ -15,17 +15,68 @@
        <div class="empty-state">🔑 Aucun utilisateur Gitea résolu : définissez <code>GITEA_TOKEN</code> pour voir les issues qui vous sont assignées.</div>
        {% else %}
        <p class="focus-intro">Issues ouvertes assignées à <strong>{{ user.login }}</strong>, tous projets confondus — {{ total }} au total.</p>
+
+        {% if groups %}
+        <div class="my-filters" id="my-filters">
+            <div class="my-filters-row">
+                <div class="my-search-wrap">
+                    <span class="my-search-icon" aria-hidden="true">🔍</span>
+                    <input type="search" id="my-search" autocomplete="off"
+                           placeholder="Rechercher un titre, un projet, un #numéro, une étiquette…  ( / )">
+                </div>
+                <select id="my-repo" title="Filtrer par projet">
+                    <option value="">Tous les projets</option>
+                    {% for f in repo_facets %}
+                    <option value="{{ f.full_name }}">{{ f.full_name }} ({{ f.count }})</option>
+                    {% endfor %}
+                </select>
+                <select id="my-label" title="Filtrer par étiquette">
+                    <option value="">Toutes les étiquettes</option>
+                    {% for f in label_facets %}
+                    <option value="{{ f.name }}">{{ f.name }} ({{ f.count }})</option>
+                    {% endfor %}
+                </select>
+                <select id="my-sort" title="Trier les résultats">
+                    <option value="recent">Activité récente d'abord</option>
+                    <option value="oldest">Plus anciennes d'abord</option>
+                    <option value="title">Titre (A → Z)</option>
+                    <option value="repo">Projet (A → Z)</option>
+                </select>
+            </div>
+            <div class="my-filters-row my-filters-meta">
+                <div class="my-col-chips" id="my-col-chips" role="group" aria-label="Filtrer par colonne">
+                    <button type="button" class="filter-chip on" data-col="">Toutes les colonnes</button>
+                    {% for f in column_facets %}
+                    <button type="button" class="filter-chip" data-col="{{ f.key }}" aria-pressed="false">
+                        <span class="filter-chip-dot" style="background: {{ column_colors[f.key] }}"></span>{{ column_labels[f.key] }} <span class="filter-chip-count">{{ f.count }}</span>
+                    </button>
+                    {% endfor %}
+                </div>
+                <span class="my-count" id="my-count" role="status"></span>
+                <button type="button" id="my-reset" class="btn-sm" hidden>↺ Réinitialiser les filtres</button>
+            </div>
+        </div>
+        {% endif %}
+
+        <div class="empty-state" id="my-empty" hidden>🔍 Aucune issue ne correspond à ces filtres.
+            <button type="button" id="my-empty-reset" class="btn-sm">↺ Réinitialiser les filtres</button>
+        </div>
        {% if not groups %}
        <div class="empty-state">🎉 Aucune issue ne vous est assignée pour le moment.</div>
        {% endif %}
        {% for group in groups %}
-        <section class="focus-group">
+        <section class="focus-group" data-repo="{{ group.full_name }}">
            <h2><a href="/board/{{ group.full_name }}">{{ group.full_name }}</a>
-                <span class="badge secondary">{{ group.rows|length }}</span></h2>
+                <span class="badge secondary" data-group-count>{{ group.rows|length }}</span></h2>
            <div class="issue-results">
                {% for row in group.rows %}
                {% set issue = row.issue %}
-                <div class="issue-row">
+                <div class="issue-row"
+                     data-column="{{ row.column }}"
+                     data-labels="{{ (issue.labels or [])|map(attribute='name')|join(' ') }}"
+                     data-updated="{{ issue.updated_at or '' }}"
+                     data-title="{{ issue.title }}"
+                     data-search="#{{ issue.number }} {{ issue.title }} {{ group.full_name }} {{ (issue.labels or [])|map(attribute='name')|join(' ') }}">
                    <span class="issue-state">🟢</span>
                    <a class="issue-main" href="/board/{{ group.full_name }}">
                        <span class="card-id">#{{ issue.number }}</span> {{ issue.title }}
@@ -46,6 +97,7 @@
    <footer>
        Kanbante v{{ version }} · mes issues
    </footer>
+    <script src="/static/js/my.js?v={{ version }}" defer></script>
    <script src="/static/js/live.js" defer></script>
 {% include "_palette.html" %}
 <script src="/static/js/palette.js" defer></script>
@@ -5,7 +5,9 @@
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ full_name }} — Projet · Kanbante</title>
    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>📋</text></svg>">
-    <link rel="stylesheet" href="/static/css/style.css">
+    <meta name="csrf-token" content="{{ csrf_token }}">
+    <meta name="repo-full-name" content="{{ full_name }}">
+    <link rel="stylesheet" href="/static/css/style.css?v={{ version }}">
 </head>
 <body>
    {% include "_header.html" %}
@@ -51,11 +53,39 @@
                    {% else %}
                    <div class="ms-meta">Aucune issue dans ce jalon pour le moment.</div>
                    {% endif %}
+                    {% if ms.id %}
+                    <details class="ms-edit">
+                        <summary>✏️ Modifier / fermer</summary>
+                        <form class="ms-form" data-ms-form data-action="/api/repos/{{ full_name }}/milestones/{{ ms.id }}/update">
+                            <label>Titre <input type="text" name="title" value="{{ ms.title }}" maxlength="255" required></label>
+                            <label>Échéance <input type="date" name="due_on" value="{{ ms.due_iso }}">
+                                <span class="ms-hint">vide = retirer l'échéance</span></label>
+                            <div class="ms-form-actions">
+                                <button type="submit" class="btn-save btn-inline">💾 Enregistrer</button>
+                            </div>
+                        </form>
+                        <form class="ms-form" data-ms-form data-action="/api/repos/{{ full_name }}/milestones/{{ ms.id }}/close"
+                              data-confirm="Fermer le jalon « {{ ms.title }} » ? Ses issues restent ouvertes, sans jalon actif.">
+                            <button type="submit" class="btn-mini btn-danger">Fermer le jalon</button>
+                        </form>
+                    </details>
+                    {% endif %}
                </div>
                {% endfor %}
                {% else %}
-                <p class="proj-empty">Aucun jalon ouvert. Les jalons se créent dans Gitea — le board et le récit de sprint s'appuient dessus.</p>
+                <p class="proj-empty">Aucun jalon ouvert pour le moment.</p>
                {% endif %}
+                <details class="ms-edit ms-new">
+                    <summary>➕ Nouveau jalon</summary>
+                    <form class="ms-form" data-ms-form data-action="/api/repos/{{ full_name }}/milestones">
+                        <label>Titre <input type="text" name="title" maxlength="255" required placeholder="Ex. : Version 2.0"></label>
+                        <label>Échéance <input type="date" name="due_on"></label>
+                        <label>Description <textarea name="description" rows="2" maxlength="2000" placeholder="Optionnelle"></textarea></label>
+                        <div class="ms-form-actions">
+                            <button type="submit" class="btn-save btn-inline">🎯 Créer le jalon</button>
+                        </div>
+                    </form>
+                </details>
            </section>

            <section class="proj-panel">
@@ -124,6 +154,7 @@

    <footer>Kanbante v{{ version }} · Page projet — jalons, santé, prévisions, activité et notes en un coup d'œil.</footer>
 {% include "_palette.html" %}
+<script src="/static/js/project.js?v={{ version }}" defer></script>
 <script src="/static/js/palette.js" defer></script>
 </body>
 </html>
@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html lang="fr" data-theme="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Rechercher partout — Kanbante</title>
+    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🔍</text></svg>">
+    <link rel="stylesheet" href="/static/css/style.css">
+    <link rel="stylesheet" href="/static/css/recherche.css">
+</head>
+<body>
+    {% include "_header.html" %}
+
+    <main class="rp-page" id="recherche" data-host="kanbante"
+          data-base-obsigate="{{ draco_urls.obsigate }}"
+          data-base-flowdeck="{{ draco_urls.flowdeck }}"
+          data-base-tiktak="{{ draco_urls.tiktak }}"
+          data-base-kanbante="{{ draco_urls.kanbante }}"
+          data-base-console="{{ agent_url }}">
+        <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>
+
+    <footer>
+        Kanbante v{{ version }} · recherche partout
+    </footer>
+    <script src="/static/js/recherche.js" defer></script>
+</body>
+</html>
@@ -6,6 +6,15 @@ services:
      - "8080:8080"
    environment:
      - GITEA_URL=${GITEA_URL:-https://git.dracodev.net}
+      # Noms publics dracodev (dev/prod) : défauts = noms officiels ;
+      # l'environnement dev déclare ses noms en -dev dans son .env.
+      - KANBANTE_PUBLIC_URL=${KANBANTE_PUBLIC_URL:-https://kanbante.dracodev.net}
+      - DRACO_SSO_URL=${DRACO_SSO_URL:-https://og.dracodev.net}
+      - DRACO_FLOWDECK_URL=${DRACO_FLOWDECK_URL:-https://flowdeck.dracodev.net}
+      - DRACO_TIKTAK_URL=${DRACO_TIKTAK_URL:-https://tiktak.dracodev.net}
+      - AGENT_URL=${AGENT_URL:-https://agent.dracodev.net}
+      - AGENT_EVENEMENTS_URL=${AGENT_EVENEMENTS_URL:-}
+      - AGENT_EVENEMENTS_CLE=${AGENT_EVENEMENTS_CLE:-}
      - GITEA_TOKEN=${GITEA_TOKEN}
      - KANBANTE_DB_PATH=/data/kanbante.db
      # Strongly recommended: without these, the app is unauthenticated.
@@ -0,0 +1,127 @@
+# Kanbante — Références coffre ObsiGate (Phase 4, issue ObsiGate #22)
+
+Patron « même patron, sans variante » de la spec « Coffre de secrets
+ObsiGate » §12, appliqué à Kanbante sur la branche
+`feat/coffre-reference-obsigate` (aucun merge, aucune PR dans ce lot).
+
+## 1. Inventaire honnête des secrets externes (vérifié dans le code, main 0.37.1)
+
+| Secret | Stockage actuel | Statut dans ce lot |
+|---|---|---|
+| Jeton d'accès forge (`forge_connections.token_encrypted`, admin + profil) | **Chiffré Fernet au repos** (`app/forge_crypto.py`, clé `KANBANTE_MASTER_KEY` ou clé générée en base) ; jamais réaffiché (masque `••••••••`) | **Non migré, à raison** : ce n'est pas un secret en clair. Le basculer sur une référence exigerait une distribution *à chaque appel* forge, car le registre met en cache les clients (`ForgeRegistry`) : distribuer une fois à la construction puis garder le client reviendrait à conserver la valeur en mémoire pour la durée de vie de l'app, ce qui violerait le « utilise, puis oublie » de la spec. Reste à faire dédié (voir §5). |
+| Secret webhook (`forge_connections.webhook_secret`, admin) | **En clair en base** (colonne `TEXT`, saisie via `/admin/connections`) ; repli environnement `KANBANTE_WEBHOOK_SECRET` | **Migré** : une référence `coffre:<slug>/<nom>` saisie dans ce même champ est stockée telle quelle, distribuée à chaque webhook, puis oubliée (§2). Les valeurs historiques en clair restent acceptées (compatibilité, migration opportuniste), sans jamais être réécrites. |
+| `GITEA_TOKEN`, `KANBANTE_NTFY_TOKEN`, `KANBANTE_OBSIGATE_MCP_TOKEN`, `KANBANTE_CAPTURE_TOKEN`, `AGENT_EVENEMENTS_CLE`, secrets SSO/session | Variables d'environnement d'exploitation uniquement, jamais persistées par l'app, non surchargeables en base (`OVERRIDABLE_SETTINGS` les exclut explicitement) | **Hors périmètre applicatif** : leur bascule éventuelle vers le coffre relève du déploiement (l'opérateur), pas d'un champ de saisie de Kanbante. Le jeton MCP ObsiGate (`KANBANTE_OBSIGATE_MCP_TOKEN`) n'est **pas** réutilisé ici : le consommateur coffre a son propre jeton, conformément à l'issue. |
+| Mots de passe utilisateurs, jetons API Kanbante | Hashés (`password_hash`, `token_hash`) | Hors périmètre (pas des secrets externes). |
+
+Conclusion : Kanbante ne stockait qu'**un** secret externe en clair
+persisté par l'app — le secret webhook — et c'est celui qui est migré.
+Le client générique ci-dessous reste disponible pour le premier usage
+réel suivant (jetons forge, voir §5).
+
+## 2. Ce qui est implémenté
+
+### `app/coffre_client.py` (nouveau, dépendance : `httpx` uniquement)
+
+- `est_reference()` / `parse_reference()` : validation du format
+  `coffre:<slug>/<nom>` (préfixe, un seul `/`, slug et nom non vides).
+- `config_depuis_env()` : `KANBANTE_OBSIGATE_URL` (base ObsiGate, ex.
+  `https://og.dracodev.net`), `KANBANTE_COFFRE_CONSOMMATEUR_TOKEN`
+  (jeton du consommateur « kanbante » enregistré dans ObsiGate),
+  `KANBANTE_COFFRE_TIMEOUT` (défaut 10 s). Absence de l'un des deux
+  premiers → `CoffreNonConfigure`, échec propre.
+- `distribuer()` / `distribuer_async()` : `POST /api/coffres/distribuer`
+  avec JSON `{reference, contexte_type, contexte_id}` et
+  `Authorization: Bearer <jeton consommateur>` — contrat vérifié dans le
+  routeur ObsiGate (`backend/routers/coffres.py`, main). La valeur
+  retournée n'est **jamais journalisée, jamais persistée, jamais mise
+  en cache**.
+- `usage_distribue()` / `usage_distribue_async()` : gestionnaires de
+  contexte « un seul usage » — la valeur ne doit pas sortir du bloc.
+- Erreurs typées, sans repli, avec messages explicites orientant vers
+  ObsiGate (voir §3). Aucune valeur distribuée n'apparaît dans un
+  message, un log ou une réponse HTTP.
+
+### Webhook (`app/main.py`, `_handle_forge_webhook`)
+
+- Si `webhook_secret` stocké est une référence : distribution
+  asynchrone à chaque webhook (`contexte_type="webhook"`,
+  `contexte_id=<slug de la connexion>`), HMAC vérifié avec la valeur en
+  mémoire, puis oubli (fin de portée de la fonction).
+- Échec de distribution → **aucun repli** sur le secret
+  d'environnement ni sur une ancienne valeur (il n'y en a pas de
+  stockée) : `CoffreAccesRefuse` → HTTP 401 « Accès révoqué ou refusé
+  dans ObsiGate : ré-accorder l'octroi… » ; autre `CoffreErreur`
+  (ObsiGate indisponible, consommateur non configuré) → HTTP 503
+  explicite. Le webhook doit être renvoyé après correction côté
+  ObsiGate.
+- Si la valeur stockée n'est pas une référence : comportement historique
+  inchangé (secret en clair, puis repli environnement).
+
+### Formulaire admin (`app/main.py` + `app/templates/admin_connections.html`)
+
+- Le champ « Secret webhook » accepte désormais une référence
+  `coffre:<slug>/<nom>` (création et modification). Une saisie
+  commençant par `coffre:` mais mal formée est **refusée** (redirection
+  d'erreur), pour ne jamais la stocker comme secret en clair historique
+  par accident.
+- Le champ « Jeton d'accès » est **inchangé** : une référence saisie
+  là serait aujourd'hui chiffrée Fernet puis rejetée par la forge —
+  c'est volontaire tant que la distribution par appel (§5) n'existe pas.
+  Le bandeau du formulaire le signale.
+
+Aucun changement de schéma n'a été nécessaire : la référence est
+stockée dans la colonne `webhook_secret` existante, détectée par son
+préfixe `coffre:` (un secret historique ne peut pas porter ce préfixe
+sans avoir été saisi comme tel, et ce cas est désormais validé).
+
+## 3. Correspondance des erreurs ObsiGate
+
+| Réponse ObsiGate | Erreur Kanbante | Effet |
+|---|---|---|
+| 401 `consommateur_invalide`, 403 `consommateur_revoque` | `CoffreAccesRefuse` | Webhook 401, message « ré-accorder » |
+| 403 `octroi_absent` / `octroi_revoque` / `octroi_expire`, 410 `secret_expire` | `CoffreAccesRefuse` | Webhook 401, message « ré-accorder / renouveler » |
+| 400 `reference_invalide` / `contexte_manquant` | `CoffreReferenceInvalide` / `CoffreContexteManquant` | Webhook 503 (erreur de configuration) |
+| 503 `kek_absente` / `crypto_indisponible`, timeout, connexion refusée, 200 sans valeur | `CoffreIndisponible` | Webhook 503, renvoyer le webhook plus tard |
+
+Dans tous les cas : pas de valeur en cache, pas de continuation.
+
+## 4. Tests
+
+`tests/test_coffre_client.py` (faux endpoint `httpx.MockTransport`,
+valeurs fictives `TEST-VALUE-XXXX` uniquement, aucune instance réelle) :
+
+- validation de références (valides / invalides) ;
+- succès sync + async, avec vérification de la requête (chemin, Bearer,
+  corps `reference` + contexte) ;
+- refus (octroi révoqué/expiré/absent, consommateur révoqué/invalide,
+  secret expiré) → `CoffreAccesRefuse` avec message explicite ;
+- indisponibilité (503, erreur réseau, 200 sans valeur) →
+  `CoffreIndisponible` ;
+- référence invalide / contexte manquant / configuration absente :
+  aucun appel HTTP ;
+- webhook de bout en bout (TestClient) : octroi révoqué → 401 explicite
+  sans repli ; distribution réussie → HMAC accepté et ligne en base
+  toujours porteuse de la référence, jamais de la valeur.
+
+## 5. Restes à faire (exigent validation par Bruno sur instance réelle)
+
+1. **Validation réelle** : enregistrer le consommateur « kanbante »
+   dans ObsiGate, créer un octroi vers un secret webhook de test,
+   configurer `KANBANTE_OBSIGATE_URL` +
+   `KANBANTE_COFFRE_CONSOMMATEUR_TOKEN` sur l'instance Kanbante, saisir
+   la référence dans `/admin/connections`, envoyer un vrai webhook
+   Gitea, vérifier l'acceptation, puis révoquer l'octroi et vérifier
+   le 401 explicite, puis couper ObsiGate et vérifier le 503.
+2. **Jetons forge par référence** : distribution à chaque appel dans
+   `GiteaClient`/`GitHubClient` (ou client jetable par requête), sans
+   passer par le cache `ForgeRegistry` ; seulement alors, accepter une
+   référence dans le champ « Jeton d'accès » et documenter la migration
+   des connexions existantes (chiffrées Fernet → références).
+3. **Migration opportuniste des secrets webhook historiques** : proposer
+   en admin la conversion d'un secret en clair existant vers une
+   référence (l'admin crée le secret + l'octroi dans ObsiGate, puis
+   remplace la valeur par la référence) — aucun outil automatique ne
+   copie une valeur réelle vers ObsiGate dans ce lot.
+4. **CI complète** : la suite n'a été exécutée que localement dans le
+   sandbox (voir rapport) ; le run CI Gitea de la branche reste à
+   observer avant toute PR.
@@ -1,6 +1,6 @@
 [project]
 name = "kanbante"
-version = "0.31.0"
+version = "0.37.1"
 description = "Kanban project manager integrated with Gitea"
 requires-python = ">=3.11"
 dependencies = [
@@ -0,0 +1,58 @@
+/* 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; }
+/* Chantier 5 — onglets + filtre (mêmes variables d'hôte, mêmes replis). */
+.draco-alertes-tabs { display: flex; flex-wrap: wrap; gap: 6px; margin: 2px 0 12px; }
+.draco-alertes-tab {
+  border: 1px solid var(--border, #333); background: transparent;
+  color: inherit; border-radius: 999px; padding: 5px 11px;
+  cursor: pointer; font-size: 13px; line-height: 1.3;
+}
+.draco-alertes-tab[aria-selected="true"] { background: #e8762c; border-color: #e8762c; color: #fff; }
+.draco-alertes-tab:focus-visible { outline: 2px solid #e8762c; outline-offset: 2px; }
+.draco-alertes-filtre { display: flex; gap: 8px; align-items: center; margin: 0 0 4px; }
+.draco-alertes-filtre label { font-size: 13px; color: var(--text-dim, #999); }
+.draco-alertes-filtre input {
+  flex: 1; min-width: 0; background: transparent; color: inherit;
+  border: 1px solid var(--border, #333); border-radius: 8px; padding: 6px 10px;
+  font-size: 13px;
+}
+.draco-alertes-compte { font-size: 12.5px; color: var(--text-dim, #999); margin: 4px 0 10px; min-height: 1em; }
+.draco-alertes-compte:empty { display: none; }
+.draco-alertes-item.is-error { border-color: #c2437e; }
@@ -2,7 +2,11 @@
   v0.1.2 : palier mobile resserré selon la spec (voir @media 700px) ;
   v0.1.3 : la marque ✦ (plus grande) ouvre le menu des applications —
   c'est LE changement d'app en mobile (choix de Bruno, 2026-10-21) ;
-   v0.1.4 : palier mobile élargi de 700 à 900 px (zone morte comblée).
+   v0.1.4 : palier mobile élargi de 700 à 900 px (zone morte comblée) ;
+   v0.1.6 : menu compte (construit par le JS, mêmes jetons que le
+   menu des applications) ; l'avatar est un vrai <button>.
+   Correctif fusion #70 (SANS bump) : bouton trois points et menu par
+   défaut supprimés ; le menu de la marque gagne « Console Spark ».
   Jetons repris du prototype validé Console v7.2.
   Thème : clair par défaut, sombre via [data-theme="dark"] sur <html>
   ou prefers-color-scheme si l'app intégratrice ne force rien. */
@@ -32,6 +36,7 @@
 /* Marque — bouton du menu des applications (v0.1.3) */
 .draco-brand { display: flex; align-items: center; gap: 7px; color: var(--ink); text-decoration: none; font-weight: 800; cursor: pointer; border-radius: 10px; padding: 4px 6px; margin: -4px -6px; }
 .draco-brand:hover { background: var(--surface-2); }
+.draco-brand:focus-visible { outline: 2px solid var(--agent); outline-offset: 2px; }
 .draco-brand-mark { color: var(--agent); font-size: 24px; line-height: 1; }

 /* Menu des applications — construit par le JS depuis les onglets */
@@ -42,6 +47,29 @@
  box-shadow: 0 16px 44px rgb(0 0 0 / .28);
 }
 .draco-apps-menu[hidden] { display: none; }
+
+/* Menu compte (v0.1.6) — même boîte que le menu des apps, ancré à
+ * droite ; ses items réutilisent .draco-apps-item. */
+.draco-compte-menu {
+  position: absolute; top: calc(100% + 6px); right: 10px; z-index: 400;
+  min-width: 248px; padding: 6px;
+  background: var(--surface); border: 1px solid var(--line); border-radius: 14px;
+  box-shadow: 0 16px 44px rgb(0 0 0 / .28);
+}
+.draco-compte-menu[hidden] { display: none; }
+.draco-menu-item {
+  display: flex; align-items: center; gap: 10px; width: 100%; box-sizing: border-box;
+  padding: 8px 10px; border: 0; border-radius: 10px;
+  background: transparent; color: var(--ink); font: inherit; text-align: left;
+  text-decoration: none; cursor: pointer;
+}
+.draco-menu-item:hover, .draco-menu-item:focus-visible { background: var(--surface-2); }
+.draco-menu-sep { height: 1px; margin: 6px 10px; background: var(--line); }
+.draco-compte-nom {
+  padding: 8px 10px 10px; font-weight: 700; font-size: 14px;
+  border-bottom: 1px solid var(--line); margin-bottom: 6px;
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
 .draco-apps-item {
  display: flex; align-items: center; gap: 10px;
  padding: 8px 10px; border-radius: 10px;
@@ -122,8 +150,10 @@
 }
 .draco-icon-btn:hover { background: var(--surface-2); }
 .draco-avatar {
-  width: 34px; height: 34px; border-radius: 50%; display: grid; place-items: center;
-  background: #2f6fed; color: #fff; font-weight: 700;
+  width: 34px; height: 34px; border: 0; padding: 0; border-radius: 50%;
+  display: grid; place-items: center; flex: none;
+  background: #2f6fed; color: #fff; font: inherit; font-weight: 700;
+  cursor: pointer;
 }

 /* Rappel de l'en-tête masqué — onglet ancré au bord supérieur (v6) */
@@ -147,8 +177,8 @@
@media (max-width: 900px) {
  /* Mobile (spec des barres, § Mobile) : la barre se resserre sur
     l'essentiel — marque, onglet de l'app courante, alertes, Spark,
-     avatar. Le rail, la recherche, les domaines et le menu « ••• »
-     disparaissent : chaque app garde ses contrôles natifs (barre
+     avatar. Le rail, la recherche et les domaines disparaissent :
+     chaque app garde ses contrôles natifs (barre
     basse, en-tête) — un seul hamburger visible, celui de l'app.
     Le changement d'app passe par le menu du ✦ (v0.1.3).
     (v0.1.2 — avant, les onglets entiers et les pastilles domaines
@@ -162,5 +192,9 @@
  .draco-bar[data-current="obsigate"] .draco-apptab[data-app="obsigate"],
  .draco-bar[data-current="flowdeck"] .draco-apptab[data-app="flowdeck"],
  .draco-bar[data-current="tiktak"] .draco-apptab[data-app="tiktak"],
-  .draco-bar[data-current="kanbante"] .draco-apptab[data-app="kanbante"] { display: flex; }
+  .draco-bar[data-current="kanbante"] .draco-apptab[data-app="kanbante"],
+  /* Chantier 5 : sur la console elle-même (data-current="agent",
+     programme console #71), c'est l'onglet Console Spark qui reste
+     visible en mobile — les 4 hôtes gardent leur propre courant. */
+  .draco-bar[data-current="agent"] .draco-apptab[data-app="agent"] { display: flex; }
 }
@@ -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; }
@@ -1693,4 +1693,60 @@ body.sidebar-collapsed .ws-switch { display: none; }
 .asset-row a { text-decoration: none; font-weight: 600; }
 .asset-meta { color: var(--muted, #999); font-size: 0.85em; margin-right: auto; }
 .asset-form { display: flex; gap: 8px; align-items: center; margin: 8px 0 4px; flex-wrap: wrap; }
-#create-issue-form textarea { flex-basis: 100%; margin-top: 6px; }
+
+/* ── Compositeur de nouvelle issue (0.31.1) ── */
+/* La toolbar impose display:flex à ses formulaires : le
+   compositeur est une carte, en bloc et pleine largeur. */
+.board-toolbar form.composer { display: block; flex: 1 1 100%; }
+.composer { background: var(--surface); border: 1px solid var(--border); border-radius: 12px; padding: 12px 14px; margin: 6px 0 10px; }
+.composer-head { display: flex; align-items: baseline; gap: 10px; margin-bottom: 10px; }
+.composer-title { font-weight: 700; font-size: 0.95rem; }
+.composer-target { color: var(--muted, #9aa3b5); font-size: 0.82rem; }
+.composer-main { display: flex; gap: 8px; }
+.composer-main input[type="text"] { flex: 1; background: var(--surface-2); border: 1px solid var(--border); border-radius: 8px; padding: 9px 12px; color: inherit; font-size: 0.95rem; }
+.composer-main input[type="text"]:focus { outline: none; border-color: var(--accent); box-shadow: 0 0 0 3px rgba(124, 92, 252, 0.25); }
+.composer-desc { margin-top: 10px; }
+.composer-desc summary { list-style: none; cursor: pointer; display: inline-flex; align-items: center; gap: 6px; font-size: 0.88rem; color: var(--accent-2); padding: 4px 2px; user-select: none; }
+.composer-desc summary::-webkit-details-marker { display: none; }
+.composer-desc summary:hover .composer-desc-label { text-decoration: underline; }
+.composer-chevron { transition: transform 0.15s ease; font-size: 0.75rem; }
+.composer-desc[open ] .composer-chevron { transform: rotate(180deg); }
+.composer-desc textarea { width: 100%; margin-top: 8px; background: var(--surface-2); border: 1px solid var(--border); border-radius: 8px; padding: 10px 12px; color: inherit; font-family: inherit; resize: vertical; }
+.composer-desc textarea:focus { outline: none; border-color: var(--accent); box-shadow: 0 0 0 3px rgba(124, 92, 252, 0.25); }
+.composer-hint { color: var(--muted, #9aa3b5); font-size: 0.78rem; margin: 6px 0 0; }
+
+/* ── Mes issues : barre de filtres (0.33.0) ── */
+.my-filters { background: var(--surface); border: 1px solid var(--border); border-radius: 12px; padding: 12px 14px; margin: 12px 0 18px; }
+.my-filters-row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+.my-filters-row + .my-filters-row { margin-top: 10px; }
+.my-search-wrap { position: relative; flex: 1 1 280px; }
+.my-search-icon { position: absolute; left: 12px; top: 50%; transform: translateY(-50%); opacity: 0.65; pointer-events: none; }
+.my-search-wrap input[type="search"] { width: 100%; background: var(--surface-2); border: 1px solid var(--border); border-radius: 999px; padding: 9px 14px 9px 38px; color: inherit; font-size: 0.92rem; }
+.my-search-wrap input[type="search"]:focus { outline: none; border-color: var(--accent); box-shadow: 0 0 0 3px rgba(124, 92, 252, 0.25); }
+.my-filters select { background: var(--surface-2); border: 1px solid var(--border); border-radius: 8px; padding: 9px 10px; color: inherit; font-size: 0.9rem; }
+.my-filters select:focus { outline: none; border-color: var(--accent); }
+.my-col-chips { display: flex; gap: 6px; flex-wrap: wrap; margin-right: auto; }
+.filter-chip { display: inline-flex; align-items: center; gap: 6px; background: var(--surface-2); border: 1px solid var(--border); color: inherit; border-radius: 999px; padding: 5px 12px; font-size: 0.85rem; cursor: pointer; transition: border-color 0.15s, background 0.15s; }
+.filter-chip:hover { border-color: var(--border-strong); }
+.filter-chip.on { background: rgba(124, 92, 252, 0.18); border-color: var(--accent); font-weight: 600; }
+.filter-chip-dot { width: 8px; height: 8px; border-radius: 50%; display: inline-block; }
+.filter-chip-count { opacity: 0.7; font-size: 0.78rem; }
+.my-count { color: var(--muted, #9aa3b5); font-size: 0.88rem; white-space: nowrap; }
+
+/* ── En vol partout (0.34.0, issue #24) ── */
+.inflight-summary { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; margin: 10px 0 18px; }
+.inflight-total { font-weight: 700; margin-right: 4px; }
+.inflight-repo { color: var(--accent-2); font-weight: 600; font-size: 0.85rem; }
+.inflight-wip { color: var(--muted, #9aa3b5); font-size: 0.8rem; font-weight: 400; margin-left: 8px; }
+
+/* ── Page Projet : gestion des jalons (0.35.0, #26) ── */
+.ms-edit { margin-top: 8px; }
+.ms-edit summary { cursor: pointer; font-size: 0.85rem; color: var(--accent-2); list-style: none; }
+.ms-edit summary::-webkit-details-marker { display: none; }
+.ms-edit summary:hover { text-decoration: underline; }
+.ms-form { display: flex; flex-direction: column; gap: 8px; margin: 10px 0; padding: 10px 12px; background: var(--surface-2); border: 1px solid var(--border); border-radius: 10px; }
+.ms-form label { display: flex; flex-direction: column; gap: 4px; font-size: 0.85rem; }
+.ms-form input[type="text"], .ms-form input[type="date"], .ms-form textarea { background: var(--surface); border: 1px solid var(--border); border-radius: 8px; padding: 8px 10px; color: inherit; font-family: inherit; }
+.ms-form input:focus, .ms-form textarea:focus { outline: none; border-color: var(--accent); }
+.ms-hint { color: var(--muted, #9aa3b5); font-size: 0.78rem; }
+.ms-form-actions { display: flex; gap: 8px; }
@@ -122,9 +122,11 @@ document.addEventListener('DOMContentLoaded', () => {
        }
    });

-    document.getElementById('new-issue-desc-toggle')?.addEventListener('click', () => {
-        const area = document.getElementById('new-issue-body');
-        if (area) { area.hidden = !area.hidden; if (!area.hidden) area.focus(); }
+    createForm?.addEventListener('keydown', (e) => {
+        if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') {
+            e.preventDefault();
+            createForm.requestSubmit();
+        }
    });

    // The "Glissez une carte ici" hint is rendered by the server only
@@ -32,6 +32,7 @@
    function cardKey(card, mode) {
        if (mode === 'name') return (card.getAttribute('data-name') || '').toLowerCase();
        if (mode === 'open') return -(parseInt(card.getAttribute('data-open') || '0', 10));
+        if (mode === 'review') return -(parseInt(card.getAttribute('data-review') || '0', 10));
        if (mode === 'updated') return card.getAttribute('data-updated') || '';
        if (mode === 'activity') return card.getAttribute('data-activity') || '';
        return null; // 'default' : ordre serveur, on ne touche à rien
@@ -52,6 +53,13 @@
                if (isNaN(tb)) return -1;
                return tb - ta;
            }
+            // Modes numériques (open, review) : les clés sont
+            // des compteurs niés (-n) — ka - kb donne donc le
+            // plus grand compteur en premier, comme l'annonce
+            // le « ↓ » des options. (Avant 0.37.0, la
+            // comparaison générique ci-dessous inversait ces
+            // deux tris : ils ressortaient croissants.)
+            if (mode === 'open' || mode === 'review') return ka - kb;
            if (ka < kb) return mode === 'name' ? -1 : 1;
            if (ka > kb) return mode === 'name' ? 1 : -1;
            return 0;
@@ -0,0 +1,749 @@
+/* Alertes unifiées dracodev — Fusion #69 (chantier 2) + chantier 5
+ * (onglets + composant partagé + onglet Console Spark).
+ *
+ * SOURCE CANONIQUE : Projets/dracodev-commons, ui/alertes/. Les copies
+ * dans les 4 hôtes (TikTak, Kanbante, Flowdeck, ObsiGate) sont des
+ * vendoring byte-identiques de ce fichier — ne pas les modifier sur
+ * place, toute évolution passe par commons puis re-vendoring.
+ *
+ * Agrégation À LA DEMANDE, pas une fédération temps réel : à chaque
+ * ouverture du panneau (et au chargement, pour la pastille), le module
+ * interroge les API de notifications réellement exposées par chaque
+ * application, avec les identifiants du navigateur (credentials:
+ * "include"). Aucune alerte n'est inventée : une source injoignable
+ * ou non authentifiée affiche son état réel par section (une section
+ * en échec n'empêche jamais de consulter les autres), jamais du vide
+ * déguisé. En attendant le correctif CORS des allowlists (autre
+ * chantier), une section inter-origines peut afficher cet état
+ * d'erreur : c'est un état d'erreur transitoire, pas un comportement
+ * normal — aucun état « Injoignable » systématique n'est présenté
+ * comme normal.
+ *
+ * Sources réelles (audit #69, 2026-10-28, inchangé) :
+ *   - Flowdeck : GET {base}/api/notifications?limit=50
+ *     -> { notifications: [{id, ntype, title, message, url, is_read,
+ *     created_at}], unread } ; active = is_read = 0 ; lien = base + url.
+ *   - 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. L'onglet
+ *     ObsiGate le dit et renvoie vers l'accueil d'ObsiGate.
+ *   - Console Spark : AUCUN endpoint d'alertes console n'est publié
+ *     sur agent-commun main au moment de ce chantier (autre chantier
+ *     en cours). L'onglet Console Spark affiche donc un état vide
+ *     HONNÊTE (« source indisponible », lien vers la console) et ne
+ *     fabrique aucune alerte. Branchement prévu, sans deviner d'URL :
+ *     poser window.DRACO_ALERTES_CONSOLE_URL (ou
+ *     DRACO_BAR_CONFIG.consoleAlertsUrl) vers l'endpoint livré par
+ *     l'autre chantier ; forme attendue : tableau, ou
+ *     {alerts:[...]} / {items:[...]}, chaque alerte portant title,
+ *     detail|message|context, date|created_at, active (booléen) ou
+ *     status/state (pause budget, accès requis, en attente, fermée…),
+ *     url|link. Les missions en pause budget / accès requis et les
+ *     approbations en attente y apparaîtront avec leurs états réels.
+ *
+ * Résolution des bases (même ordre que barre-apps v0.1.6) :
+ *   1. window.DRACO_BAR.urls déjà résolue par la barre, sinon
+ *      window.DRACO_BAR_CONFIG.urls (config explicite de l'hôte) ;
+ *   2. dérivation -dev par l'hôte courant (hôte -dev dracodev.net) ;
+ *   3. href rendu de l'onglet .draco-apptab[data-app] (l'onglet
+ *      « Console Spark » ajouté par le chantier 5 porte data-app
+ *      "agent", donc la base agent suit le même ordre) ;
+ *   4. défaut officiel (production).
+ * ObsiGate n'a pas de .draco-apptab dans tous les cas : l'étape 3 y
+ * lit aussi window.DRACO_URLS (injecté par son backend, clé "agent"
+ * incluse).
+ * Aucun nom en -dev n'est un défaut : la dérivée -dev ne s'applique
+ * que sur un hôte -dev, exactement comme la barre.
+ *
+ * Présentation (identique partout, imposée par ce seul fichier) :
+ *   champs par alerte = application, titre, date, état, lien profond
+ *   (environnement -dev respecté via la résolution ci-dessus) ;
+ *   ordre = date décroissante dans chaque onglet (sans date en
+ *   dernier) ; format de date = toLocaleString("fr-FR"), « sans date »
+ *   si absente ou illisible ; libellés d'état affichés = « Active »,
+ *   « Lue », ou le libellé d'événement Kanbante (ex. « Fermée »),
+ *   ou l'état réel console quand la source existe. Le type brut
+ *   Kanbante (« moved »…) n'est plus affiché : il dupliquait le
+ *   libellé d'état en anglais.
+ *   Onglets : Tout, ObsiGate, Flowdeck, TikTak, Kanbante,
+ *   Console Spark, Historique — dans cet ordre. Tout et chaque onglet
+ *   par application ne montrent QUE les alertes actives ; Historique
+ *   ne montre QUE les alertes fermées (lues / événements Kanbante /
+ *   console fermées). Le filtre texte (titre + contexte) s'applique
+ *   APRÈS le périmètre de l'onglet courant : il ne mélange jamais
+ *   actifs et historique. L'onglet courant est dans l'URL
+ *   (#alertes=<onglet>, partageable, retour arrière via pushState).
+ *
+ * Le fichier ne touche à AUCUN fichier ui/barre-apps.* : il consomme
+ * seulement l'action "alertes" relayée par l'hôte et DRACO_BAR.setCounts
+ * pour la pastille (repli : mise à jour directe du badge).
+ * 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/",
+    agent: "https://agent.dracodev.net/"
+  };
+  var DEV_URLS = {
+    obsigate: "https://og-dev.dracodev.net/",
+    flowdeck: "https://flowdeck-dev.dracodev.net/",
+    tiktak: "https://tiktak-dev.dracodev.net/",
+    kanbante: "https://kanbante-dev.dracodev.net/",
+    agent: "https://agent-dev.dracodev.net/"
+  };
+  var APP_LABELS = {
+    obsigate: "ObsiGate", flowdeck: "Flowdeck",
+    tiktak: "TikTak", kanbante: "Kanbante", console: "Console Spark"
+  };
+  var APP_ORDER = ["obsigate", "flowdeck", "tiktak", "kanbante"];
+  var ALL_APPS = ["obsigate", "flowdeck", "tiktak", "kanbante", "console"];
+  var TABS = ["tout", "obsigate", "flowdeck", "tiktak", "kanbante", "console", "historique"];
+  var TAB_LABELS = {
+    tout: "Tout", obsigate: "ObsiGate", flowdeck: "Flowdeck",
+    tiktak: "TikTak", kanbante: "Kanbante",
+    console: "Console Spark", historique: "Historique"
+  };
+  var EVENT_LABELS = {
+    created: "créée", moved: "déplacée", closed: "fermée",
+    reopened: "rouverte", commented: "commentée"
+  };
+  var CONSOLE_ACTIVE_STATUSES = [
+    "active", "pending", "pause", "pause_budget", "acces_requis",
+    "en_attente", "en attente", "requise", "awaiting"
+  ];
+  var CONSOLE_CLOSED_STATUSES = [
+    "closed", "resolved", "resolue", "lue", "terminee", "done", "fermee"
+  ];
+
+  function isDevHost(hostname) {
+    if (!hostname) return false;
+    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 "";
+    try { return t.toLocaleString("fr-FR"); } catch (e) { return t.toISOString().slice(0, 16); }
+  }
+  function capitalize(s) {
+    s = String(s || "");
+    return s ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+  }
+
+  /* Résolution des bases. `env` permet les tests sans navigateur :
+   * { hostname, barUrls, configUrls, tabHrefs, dracoUrls, consoleUrl }. */
+  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 = {};
+    ALL_APPS.forEach(function (key) {
+      var app = key === "console" ? "agent" : key;
+      var out = key === "console" ? "agent" : key;
+      var u = cleanUrl(env.barUrls && (env.barUrls[key] || env.barUrls[app]))
+        || cleanUrl(env.configUrls && (env.configUrls[key] || env.configUrls[app]));
+      if (!u && dev) u = DEV_URLS[app] || null;
+      if (!u) {
+        var href = null;
+        if (env.tabHrefs && (env.tabHrefs[key] || env.tabHrefs[app])) href = env.tabHrefs[key] || env.tabHrefs[app];
+        else if (typeof document !== "undefined" && document.querySelector) {
+          var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
+          href = tab ? tab.getAttribute("href") : null;
+        }
+        u = cleanUrl(href);
+      }
+      if (!u && env.dracoUrls && (env.dracoUrls[key] || env.dracoUrls[app])) u = cleanUrl(env.dracoUrls[key] || env.dracoUrls[app]);
+      if (!u) {
+        /* ObsiGate : window.DRACO_URLS injecté par le backend. */
+        try {
+          if (global.DRACO_URLS && (global.DRACO_URLS[key] || global.DRACO_URLS[app])) u = cleanUrl(global.DRACO_URLS[key] || global.DRACO_URLS[app]);
+        } catch (e) { /* rien */ }
+      }
+      if (!u) u = DEFAULT_URLS[app];
+      urls[out] = withSlash(u);
+      if (key === "console") urls.console = 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,
+      consoleUrl: null
+    };
+  }
+  /* URL de la source console, si l'hôte l'a configurée. AUCUNE URL
+   * n'est devinée : sans configuration, la source est indisponible
+   * (état vide honnête, voir renderCurrent). */
+  function consoleSourceUrl(env) {
+    env = env || {};
+    if (env.consoleUrl) return env.consoleUrl;
+    try {
+      if (global.DRACO_ALERTES_CONSOLE_URL) return global.DRACO_ALERTES_CONSOLE_URL;
+      var cfg = global.DRACO_BAR_CONFIG || {};
+      if (cfg.consoleAlertsUrl) return cfg.consoleAlertsUrl;
+    } catch (e) { /* rien */ }
+    return null;
+  }
+
+  function normalizeFlowdeck(base, payload) {
+    var list = (payload && payload.notifications) || [];
+    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 || ""))
+      };
+    });
+  }
+  function normalizeConsole(base, payload) {
+    var list = Array.isArray(payload) ? payload
+      : (payload && (payload.alerts || payload.items)) || [];
+    return list.map(function (n) {
+      var status = String(n.status || "").toLowerCase().replace(/_/g, " ").trim();
+      var stateRaw = String(n.state || status || "");
+      var active;
+      if (typeof n.active === "boolean") active = n.active;
+      else if (status && CONSOLE_ACTIVE_STATUSES.indexOf(status.replace(/ /g, "_")) !== -1) active = true;
+      else if (status && CONSOLE_CLOSED_STATUSES.indexOf(status.replace(/ /g, "_")) !== -1) active = false;
+      else if (/pause|acc[eè]s|attente/.test(stateRaw.toLowerCase())) active = true;
+      else if (/ferm|résol|resol|termin/.test(stateRaw.toLowerCase())) active = false;
+      else active = true; /* source réelle, statut inconnu : on l'expose en active */
+      return {
+        app: "console", id: n.id, title: n.title || "(sans titre)",
+        detail: n.detail || n.message || n.context || "", date: n.date || n.created_at || "",
+        active: active, state: stateRaw || (active ? "en attente" : "fermée"),
+        kind: n.kind || n.type || "",
+        url: n.url || n.link ? joinUrl(base, n.url || n.link) : withSlash(base)
+      };
+    });
+  }
+  /* Libellé d'état AFFICHÉ, uniforme partout (les valeurs brutes de
+   * normalize* sont inchangées, pour compatibilité des tests #69). */
+  function displayState(a) {
+    if (a.active) return "Active";
+    if (a.app === "kanbante") return capitalize(a.state);
+    if (a.app === "console") return capitalize(a.state);
+    return "Lue";
+  }
+  function metaLine(a) {
+    var date = fmtDate(a.date) || "sans date";
+    /* Kanbante : le type brut (« moved ») dupliquait le libellé
+     * d'état ; il n'est plus affiché. Les autres apps gardent leur
+     * type quand il apporte une information. */
+    if (a.app === "kanbante") return APP_LABELS[a.app] + " · " + date + " · " + displayState(a);
+    var kind = a.kind ? " · " + a.kind : "";
+    return APP_LABELS[a.app] + kind + " · " + date + " · " + displayState(a);
+  }
+  /* Actives d'abord, puis date décroissante (sans date en dernier).
+   * Dans un onglet, le périmètre est déjà homogène (que des actives
+   * ou que des fermées) : l'ordre effectif est donc la date décroissante. */
+  function sortAlerts(list) {
+    return list.slice().sort(function (a, b) {
+      if (a.active !== b.active) return a.active ? -1 : 1;
+      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;
+  }
+  function allItems(results) {
+    var all = [];
+    ALL_APPS.forEach(function (app) {
+      (results[app] && results[app].items || []).forEach(function (a) { all.push(a); });
+    });
+    return all;
+  }
+  /* Périmètre d'un onglet. Retour : { items, errors, consoleMissing }.
+   * Tout et onglets par application = actives seulement ; Historique =
+   * fermées seulement. Les erreurs de section sont remontées dans
+   * chaque onglet concerné (jamais silencieusement avalées). */
+  function scopeAlerts(all, tab, results) {
+    results = results || {};
+    var items = [], errors = [];
+    function collect(app, pred) {
+      if (results[app] && results[app].error) errors.push({ app: app, error: results[app].error });
+      all.forEach(function (a) { if (a.app === app && pred(a)) items.push(a); });
+    }
+    if (tab === "historique") {
+      ALL_APPS.forEach(function (app) { collect(app, function (a) { return !a.active; }); });
+    } else if (tab === "tout") {
+      ALL_APPS.forEach(function (app) { collect(app, function (a) { return a.active; }); });
+    } else if (ALL_APPS.indexOf(tab) !== -1) {
+      collect(tab, function (a) { return a.active; });
+    } else {
+      ALL_APPS.forEach(function (app) { collect(app, function (a) { return a.active; }); });
+    }
+    return {
+      items: sortAlerts(items), errors: errors,
+      consoleMissing: !!(results.console && results.console.sourceMissing)
+    };
+  }
+  function countByTab(all, results) {
+    var counts = {};
+    TABS.forEach(function (tab) { counts[tab] = scopeAlerts(all, tab, results).items.length; });
+    return counts;
+  }
+  /* Filtre texte, appliqué APRÈS le périmètre de l'onglet : titre ou
+   * contexte, insensible à la casse, sans jamais mélanger actifs et
+   * historique (le périmètre est déjà fixé par scopeAlerts). */
+  function filterAlerts(list, q) {
+    q = String(q || "").trim().toLowerCase();
+    if (!q) return list.slice();
+    return list.filter(function (a) {
+      return (String(a.title || "").toLowerCase().indexOf(q) !== -1)
+        || (String(a.detail || "").toLowerCase().indexOf(q) !== -1);
+    });
+  }
+  /* Onglet depuis le hash d'URL : "#alertes=historique" -> "historique",
+   * "#alertes" -> "tout", autre -> null. */
+  function parseAlertTab(hash) {
+    if (!hash) return null;
+    var h = String(hash).replace(/^#/, "");
+    if (h === "alertes") return "tout";
+    var m = /^alertes=([a-z]+)$/.exec(h);
+    if (m && TABS.indexOf(m[1]) !== -1) return m[1];
+    return null;
+  }
+  function hashForTab(tab) {
+    if (TABS.indexOf(tab) === -1) tab = "tout";
+    return "#alertes=" + tab;
+  }
+
+  /* ---- Rendu (navigateur seulement) ---- */
+  var panel = null, listEl = null, tabsEl = null, filterEl = null,
+    countEl = null, badgeTimer = null;
+  var currentTab = "tout", currentData = null, currentFilter = "";
+  var panelPushed = false, closingViaBack = false, suppressHash = false;
+
+  function el(tag, cls, text) {
+    var d = document.createElement(tag);
+    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 close = el("button", "draco-alertes-close", "✕");
+    close.setAttribute("aria-label", "Fermer");
+    close.addEventListener("click", function () { closePanel(); });
+    head.appendChild(close);
+    box.appendChild(head);
+    box.appendChild(el("p", "draco-alertes-note",
+      "Agrégation à la demande, pas une fédération temps réel : " +
+      "les alertes sont relues dans chaque application à l'ouverture. " +
+      "Une section en échec n'empêche pas de consulter les autres."));
+    tabsEl = el("div", "draco-alertes-tabs");
+    tabsEl.setAttribute("role", "tablist");
+    tabsEl.setAttribute("aria-label", "Alertes par application");
+    tabsEl.addEventListener("keydown", onTabsKeydown);
+    box.appendChild(tabsEl);
+    var filtre = el("div", "draco-alertes-filtre");
+    var lbl = el("label", "", "Filtrer");
+    lbl.setAttribute("for", "draco-alertes-filtre-input");
+    filtre.appendChild(lbl);
+    filterEl = el("input", "");
+    filterEl.type = "search";
+    filterEl.id = "draco-alertes-filtre-input";
+    filterEl.setAttribute("placeholder", "Filtrer par titre ou contexte, dans cet onglet…");
+    filterEl.setAttribute("aria-label", "Filtrer les alertes de l'onglet courant");
+    filterEl.addEventListener("input", function () {
+      currentFilter = filterEl.value;
+      renderCurrent();
+    });
+    filtre.appendChild(filterEl);
+    box.appendChild(filtre);
+    countEl = el("p", "draco-alertes-compte", "");
+    box.appendChild(countEl);
+    listEl = el("div", "draco-alertes-list");
+    listEl.setAttribute("role", "tabpanel");
+    box.appendChild(listEl);
+    ov.appendChild(box);
+    ov.addEventListener("click", function (ev) { if (ev.target === ov) closePanel(); });
+    document.addEventListener("keydown", function (ev) {
+      if (ev.key === "Escape" && panel && panel.style.display !== "none") closePanel();
+    });
+    document.body.appendChild(ov);
+    panel = ov;
+    return ov;
+  }
+  function closePanel() {
+    if (!panel) return;
+    panel.style.display = "none";
+    if (panelPushed) {
+      panelPushed = false;
+      closingViaBack = true;
+      try { history.back(); } catch (e) { closingViaBack = false; }
+      return;
+    }
+    try {
+      var h = parseAlertTab(window.location.hash);
+      if (h) {
+        suppressHash = true;
+        history.replaceState(null, "", window.location.pathname + window.location.search);
+        suppressHash = false;
+      }
+    } catch (e) { /* rien */ }
+  }
+  function onHashChange() {
+    if (suppressHash) return;
+    if (closingViaBack) { closingViaBack = false; return; }
+    var tab = parseAlertTab(window.location.hash);
+    if (tab) {
+      if (!panel || panel.style.display === "none") openPanel(tab);
+      else setTab(tab, false);
+    } else if (panel && panel.style.display !== "none") {
+      panelPushed = false;
+      panel.style.display = "none";
+    }
+  }
+  function onTabsKeydown(ev) {
+    var keys = ["ArrowLeft", "ArrowRight", "Home", "End"];
+    if (keys.indexOf(ev.key) === -1) return;
+    var btns = tabsEl.querySelectorAll(".draco-alertes-tab");
+    var idx = TABS.indexOf(currentTab);
+    if (ev.key === "ArrowLeft") idx = (idx + TABS.length - 1) % TABS.length;
+    else if (ev.key === "ArrowRight") idx = (idx + 1) % TABS.length;
+    else if (ev.key === "Home") idx = 0;
+    else if (ev.key === "End") idx = TABS.length - 1;
+    ev.preventDefault();
+    setTab(TABS[idx], true);
+    if (btns[idx] && btns[idx].focus) btns[idx].focus();
+  }
+  function renderTabs() {
+    if (!tabsEl || !currentData) return;
+    tabsEl.textContent = "";
+    var all = allItems(currentData.results);
+    var counts = countByTab(all, currentData.results);
+    TABS.forEach(function (tab) {
+      var b = el("button", "draco-alertes-tab",
+        TAB_LABELS[tab] + " (" + counts[tab] + ")");
+      b.type = "button";
+      b.setAttribute("role", "tab");
+      b.setAttribute("aria-selected", tab === currentTab ? "true" : "false");
+      b.tabIndex = tab === currentTab ? 0 : -1;
+      b.addEventListener("click", function () { setTab(tab, true); });
+      tabsEl.appendChild(b);
+    });
+  }
+  function renderRow(a) {
+    var row = el("div", "draco-alertes-item" + (a.active ? " is-active" : ""));
+    var main = el("div", "draco-alertes-main");
+    var link = el("a", "draco-alertes-title", a.title);
+    link.href = a.url;
+    main.appendChild(link);
+    if (a.detail) main.appendChild(el("div", "draco-alertes-detail", a.detail));
+    main.appendChild(el("div", "draco-alertes-meta", metaLine(a)));
+    row.appendChild(main);
+    return row;
+  }
+  function renderErrorRow(app, msg) {
+    var row = el("div", "draco-alertes-item is-error");
+    var main = el("div", "draco-alertes-main");
+    main.appendChild(el("div", "draco-alertes-title", APP_LABELS[app] + " — section en échec"));
+    main.appendChild(el("div", "draco-alertes-detail", msg));
+    main.appendChild(el("div", "draco-alertes-meta",
+      APP_LABELS[app] + " · section en échec — les autres sections restent consultables"));
+    row.appendChild(main);
+    return row;
+  }
+  function renderCurrent() {
+    if (!listEl || !currentData) return;
+    renderTabs();
+    var scope = scopeAlerts(allItems(currentData.results), currentTab, currentData.results);
+    var filtered = filterAlerts(scope.items, currentFilter);
+    var q = String(currentFilter || "").trim();
+    if (countEl) {
+      countEl.textContent = q
+        ? filtered.length + " résultat(s) sur " + scope.items.length + " dans cet onglet — filtre « " + q + " »"
+        : "";
+    }
+    listEl.textContent = "";
+    /* Onglet Console sans source : état vide honnête, jamais d'alertes
+     * inventées, avec le lien profond vers la console. */
+    if (currentTab === "console" && scope.consoleMissing) {
+      var sec = el("section", "draco-alertes-section");
+      sec.appendChild(el("h3", "", "Console Spark (0)"));
+      sec.appendChild(el("p", "draco-alertes-empty",
+        "Aucune alerte console — source indisponible : l'endpoint " +
+        "d'alertes console (agent-commun, autre chantier) n'est pas " +
+        "encore publié. Les missions en pause budget / accès requis " +
+        "et les approbations en attente apparaîtront ici, avec leurs " +
+        "états réels, dès sa livraison."));
+      var link = el("div", "draco-alertes-empty");
+      var a = el("a", "", "Ouvrir la Console Spark");
+      a.href = currentData.urls.agent || currentData.urls.console || "#";
+      link.appendChild(a);
+      sec.appendChild(link);
+      listEl.appendChild(sec);
+      scope.errors.forEach(function (e) { listEl.appendChild(renderErrorRow(e.app, e.error)); });
+      return;
+    }
+    if (currentTab === "obsigate" && !scope.items.length && !scope.errors.length) {
+      var secOg = el("section", "draco-alertes-section");
+      secOg.appendChild(el("h3", "", "ObsiGate (0)"));
+      secOg.appendChild(el("p", "draco-alertes-empty",
+        "ObsiGate n'expose aucune notification entrante consultable " +
+        "(ses canaux /api/notify sont des envois sortants, réservés aux administrateurs)."));
+      var linkOg = el("div", "draco-alertes-empty");
+      var aOg = el("a", "", "Ouvrir ObsiGate");
+      aOg.href = currentData.urls.obsigate;
+      linkOg.appendChild(aOg);
+      secOg.appendChild(linkOg);
+      listEl.appendChild(secOg);
+      return;
+    }
+    scope.errors.forEach(function (e) { listEl.appendChild(renderErrorRow(e.app, e.error)); });
+    if (!scope.items.length && !scope.errors.length) {
+      var empty = currentTab === "historique"
+        ? "Aucune alerte fermée dans les applications joignables."
+        : currentTab === "tout"
+          ? "Aucune alerte active dans les applications joignables."
+          : "Aucune alerte active pour " + TAB_LABELS[currentTab] + ".";
+      if (currentTab === "console") empty = "Aucune alerte console.";
+      listEl.appendChild(el("p", "draco-alertes-empty", empty));
+      return;
+    }
+    if (q && !filtered.length) {
+      listEl.appendChild(el("p", "draco-alertes-empty",
+        "Aucune alerte dans cet onglet pour ce filtre."));
+      return;
+    }
+    filtered.forEach(function (a) { listEl.appendChild(renderRow(a)); });
+  }
+  function setTab(tab, push) {
+    if (TABS.indexOf(tab) === -1) tab = "tout";
+    currentTab = tab;
+    renderCurrent();
+    if (push) {
+      try {
+        history.pushState(null, "", hashForTab(tab));
+        panelPushed = true;
+      } catch (e) { /* URL partageable : repli silencieux */ }
+    }
+  }
+
+  function fetchJson(url, timeoutMs) {
+    var ctrl = null, timer = null;
+    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 consoleUrl = consoleSourceUrl(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) }; })
+    };
+    if (consoleUrl) {
+      var agentBase = urls.agent || urls.console;
+      jobs.console = fetchJson(consoleUrl)
+        .then(function (p) { return { items: normalizeConsole(agentBase, p) }; });
+    }
+    var keys = Object.keys(jobs);
+    return Promise.all(keys.map(function (k) {
+      return jobs[k].then(function (v) { return [k, v]; }).catch(function (e) {
+        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]; });
+      if (!consoleUrl) results.console = { items: [], sourceMissing: true };
+      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 n = countActive(allItems(r.results));
+      setBadge(n);
+      return n;
+    }).catch(function () { /* pastille optionnelle : la barre vit sans */ });
+  }
+  function openPanel(initialTab) {
+    ensurePanel();
+    panel.style.display = "flex";
+    var tab = initialTab || parseAlertTab(window.location.hash) || "tout";
+    currentTab = tab;
+    currentFilter = "";
+    if (filterEl) filterEl.value = "";
+    listEl.textContent = "";
+    listEl.appendChild(el("p", "draco-alertes-empty", "Chargement des alertes…"));
+    if (tabsEl) tabsEl.textContent = "";
+    loadAll().then(function (r) {
+      currentData = r;
+      /* Ouverture par le bouton (pas de hash) : l'onglet entre dans
+       * l'URL pour être partageable ; ouverture par lien partagé : le
+       * hash est déjà le bon, on ne pousse pas d'entrée en double. */
+      var fromHash = parseAlertTab(window.location.hash);
+      if (!fromHash) {
+        try { history.pushState(null, "", hashForTab(tab)); panelPushed = true; } catch (e) { /* rien */ }
+      }
+      renderCurrent();
+      setBadge(countActive(allItems(r.results)));
+    }).catch(function () {
+      currentData = { urls: resolveUrls(browserEnv()), results: { obsigate: { items: [] }, console: { items: [], sourceMissing: true } } };
+      renderCurrent();
+    });
+  }
+
+  var api = {
+    open: openPanel, close: closePanel, refreshBadge: refreshBadge,
+    _test: {
+      resolveUrls: resolveUrls, normalizeFlowdeck: normalizeFlowdeck,
+      normalizeTiktak: normalizeTiktak, normalizeKanbante: normalizeKanbante,
+      normalizeConsole: normalizeConsole, consoleSourceUrl: consoleSourceUrl,
+      sortAlerts: sortAlerts, countActive: countActive,
+      filterAlerts: filterAlerts, scopeAlerts: scopeAlerts,
+      countByTab: countByTab, parseAlertTab: parseAlertTab,
+      hashForTab: hashForTab, displayState: displayState,
+      metaLine: metaLine, fmtDate: fmtDate,
+      isDevHost: isDevHost, DEFAULT_URLS: DEFAULT_URLS, DEV_URLS: DEV_URLS,
+      TABS: TABS, TAB_LABELS: TAB_LABELS, APP_LABELS: APP_LABELS
+    }
+  };
+  global.DRACO_ALERTES = api;
+  if (typeof module !== "undefined" && module.exports) module.exports = api._test;
+
+  /* Pastille au chargement (après les scripts defer de la barre) ;
+   * un lien partagé #alertes=<onglet> ouvre directement le panneau
+   * sur cet onglet. */
+  if (typeof document !== "undefined" && document.addEventListener) {
+    document.addEventListener("DOMContentLoaded", function () {
+      if (badgeTimer) clearTimeout(badgeTimer);
+      badgeTimer = setTimeout(refreshBadge, 300);
+      var tab = parseAlertTab(window.location.hash);
+      if (tab) setTimeout(function () { openPanel(tab); }, 350);
+    });
+    window.addEventListener("hashchange", onHashChange);
+  }
+})(typeof window !== "undefined" ? window : globalThis);
@@ -1,5 +1,14 @@
 /* Barre d'apps commune dracodev — comportement (v0.1.0, ACC-0.2 ;
- * v0.1.3 : menu des applications ouvert par la marque ✦).
+ * v0.1.3 : menu des applications ouvert par la marque ✦ ;
+ * v0.1.5 : noms publics par configuration — aucun nom public d'un
+ * environnement particulier n'est codé en dur, voir « URL » ci-dessous ;
+ * v0.1.6 (prochaine publication — VERSION non bumpée dans cette PR,
+ * la publication est séparée) : dérivation -dev par l'hôte courant,
+ * menu trois points par défaut et menu compte fonctionnels, voir ci-dessous ;
+ * correctif fusion #70 (SANS bump de version, publication séparée) :
+ * bouton trois points et son menu par défaut SUPPRIMÉS, « Console Spark »
+ * ajoutée au menu de la marque, fermeture/focus corrigés (voir
+ * « Menu des applications », « Focus » et « Écouteurs globaux »).
 *
 * Aucun gestionnaire inline : un seul écouteur délégué sur le document
 * (patron validé par le prototype — les onclick du HTML généré sont
@@ -10,19 +19,205 @@
 *     current: "tiktak",                      // app courante
 *     domain: "pro",                          // domaine actif
 *     counts: { tiktak: 3, kanbante: 3, alertes: 3, spark: 0 },
+ *     user: "Bruno",                          // nom affiché (v0.1.6) ;
+ *       // ou { display_name: "Bruno", username: "bruno" }
+ *     urls: {                                 // bases des applications
+ *       obsigate: "https://og.dracodev.net/",
+ *       flowdeck: "https://flowdeck.dracodev.net/",
+ *       tiktak:   "https://tiktak.dracodev.net/",
+ *       kanbante: "https://kanbante.dracodev.net/",
+ *       agent:    "https://agent.dracodev.net/",
+ *       spark:    "https://spark.dracodev.net/"
+ *     },
 *     onAction: function (act, el) { … }      // l'app relaie les actions
 *   }                                          // qu'elle ne connaît pas
+ *
+ * URL des applications (contrat dev/prod, v0.1.5 puis v0.1.6) —
+ * résolution, dans l'ordre STRICT, pour chaque app :
+ *   1. DRACO_BAR_CONFIG.urls.<app>, injectée par l'app hôte (rendu
+ *      serveur ou client) depuis SA configuration d'environnement —
+ *      explicite, donc prioritaire, même sur un hôte -dev ;
+ *   2. (v0.1.6) SI l'hôte courant est un hôte -dev dracodev.net
+ *      (première étiquette se terminant par -dev : tiktak-dev,
+ *      kanbante-dev, og-dev, flowdeck-dev, agent-dev…), l'URL sœur
+ *      dérivée avec -dev (voir DEV_URLS). C'est le correctif du bug
+ *      constaté sur tiktak-dev / kanbante-dev, où les liens suivaient
+ *      les noms SANS -dev faute de configuration explicite ;
+ *   3. le href déjà rendu dans le fragment HTML, c.-à-d. le jeton
+ *      {{URL_<APP>}} remplacé côté serveur par l'app hôte ;
+ *   4. le défaut officiel ci-dessous (production, noms SANS suffixe).
+ * Un jeton {{URL_…}} non remplacé n'est jamais une URL : il est ignoré
+ * partout (config injectée comme href rendu) et ne peut pas être exposé.
+ * Cas spark (v0.1.6) : AUCUNE dérivation inventée — aucun hôte
+ * spark-dev connu ; sur un hôte -dev, spark retombe sur l'étape 3
+ * (href rendu) puis 4 (défaut prod), sauf config explicite (étape 1).
+ * La clé spark ne correspond à aucun onglet de la barre : elle est
+ * résolue et exposée via DRACO_BAR.urls pour le panneau Spark
+ * (panneau-agent), qui suit le même contrat d'injection. La clé agent,
+ * elle, a un onglet depuis le chantier 5 (ordre : ObsiGate, Flowdeck,
+ * TikTak, Kanbante, Console Spark) : elle suit donc l'étape « href
+ * rendu » comme les autres onglets, en plus d'alimenter le menu de
+ * la marque et DRACO_BAR.urls.
 * Actions émises (data-act) : rail, palette, domaine (data-dom),
- * alertes, spark, menu, rappel-entete. L'app intégratrice décide de
- * chacune (ouvrir la palette, le panneau Spark, changer de domaine…).
- * Action INTERNE (jamais relayée) : apps — la marque ✦ ouvre le menu
- * des applications, construit depuis les onglets ; c'est le moyen de
- * changer d'app en mobile, où les onglets sont repliés (v0.1.2).
+ * alertes, spark, rappel-entete. L'app intégratrice décide de chacune
+ * (ouvrir la palette, le panneau Spark, changer de domaine…).
+ * Actions INTERNES (jamais relayées comme avant) : apps — la marque ✦
+ * ouvre le menu des applications, construit depuis les onglets, plus
+ * (depuis le correctif #70) une entrée « Console Spark » vers la
+ * console de l'agent commun (URL agent résolue, voir ci-dessous) ;
+ * c'est le moyen de changer d'app en mobile, où les onglets sont
+ * repliés (v0.1.2). Menu compte : voir ci-dessous.
+ * L'action « menu » n'est PLUS émise nulle part : le bouton trois points
+ * a été supprimé (#70) ; les branches onAction("menu") des hôtes
+ * (TikTak/Kanbante/Flowdeck : retour false pour le menu par défaut ;
+ * ObsiGate : clic #header-menu-btn) sont donc mortes et ont été
+ * retirées des gabarits hôtes — le menu natif d'ObsiGate
+ * (#header-menu-btn) lui-même n'est pas touché.
+ *
+ * Retrait du bouton trois points (correctif fusion #70) — le bouton et
+ * son menu par défaut (console agent + applications) sont supprimés
+ * du fragment, du JS et du CSS. La console agent reste joignable par
+ * l'entrée « Console Spark » du menu de la marque (ci-dessous) et
+ * par le bouton Spark (panneau), donc aucun accès n'est perdu.
+ * Menu des applications (v0.1.3, étendu #70) — construit depuis les
+ * onglets présents dans la barre, puis une entrée « Console Spark »
+ * (logo ✦, rôle « Agent commun ») APRÈS Kanbante, vers l'URL agent
+ * résolue : 1) config explicite DRACO_BAR_CONFIG.urls.agent,
+ * 2) dérivation -dev agent-dev sur hôte -dev, 3) href rendu de
+ * l'onglet « Console Spark » (chantier 5, data-app="agent"),
+ * 4) défaut officiel prod https://agent.dracodev.net/.
+ * AUCUN hôte spark-dev n'est inventé :
+ * la clé spark, elle, suit toujours son propre contrat (explicite >
+ * href rendu > défaut prod) et ne sert qu'au panneau Spark.
+ * Focus (correctif #70) — ouverture au clavier : Entrée sur la marque
+ * (clic natif du lien) ; Espace sur la marque (keydown dédié, car un
+ * lien ne s'active pas à l'Espace) : ouvre le menu et met le focus
+ * sur son premier item. Fermeture : Échap (focus rendu au déclencheur
+ * qui avait ouvert le menu : la marque pour le menu apps, l'avatar
+ * pour le menu compte), nouvel appui sur le déclencheur (le focus y
+ * est déjà), choix d'un item, ou clic extérieur — ce dernier cas ne
+ * déplace VOLONTAIREMENT pas le focus (l'utilisateur vient de cliquer
+ * ailleurs : recherche, tâche… ; lui voler le focus casserait son
+ * geste). aria-expanded est tenu à jour sur chaque déclencheur.
+ * Écouteurs globaux (correctif #70, bug tiktak-dev) — les écouteurs
+ * clic/Échap de la barre sont posés via EventTarget.prototype (voir
+ * addGlobalListener), PAS via document.addEventListener. Cause
+ * prouvée sur TikTak (app/static/js/app.js, navigation #89) : app.js
+ * remplace document/window.addEventListener par un registre
+ * (__tcDocWin) et chaque navigation douce appelle tcInit() puis
+ * __tcTeardown(), qui SUPPRIME tous les écouteurs du registre — y
+ * compris ceux de draco-barre.js (script defer, enregistré après le
+ * tcInit() initial). La barre survit à la navigation (hors .layout
+ * remplacé) mais ses gestionnaires sont morts : un menu ouvert avant
+ * la navigation reste ouvert (Échap et clic extérieur sans effet) et
+ * la marque, lien href="/", est interceptée par l'intercepteur SPA
+ * brut de TikTak (__tcDocAdd, hors registre, donc survivant) comme
+ * une navigation interne au lieu de basculer le menu. Les écouteurs
+ * posés sur le prototype ne figurent pas dans le registre et ne sont
+ * donc jamais supprimés par le teardown ; en complément, le gabarit
+ * TikTak exclut désormais .draco-bar de l'intercepteur SPA, pour que
+ * la marque ne déclenche plus de navigation douce. Les autres hôtes
+ * (SSR, rechargement complet) ne sont pas concernés par le teardown
+ * mais bénéficient du même code ; repli : si EventTarget.prototype
+ * est indisponible (mini-DOM de tests), document.addEventListener
+ * classique est utilisé.
+ * Menu compte (v0.1.6) — l'avatar, auparavant un <span> mort affichant
+ * un « B » codé en dur dans le fragment, est un vrai <button>
+ * (data-act="compte"). Son initiale vient de cfg.user ou, à défaut, de
+ * la première lettre du title {{UTILISATEUR}} remplacé ; sans nom connu,
+ * le neutre ✦ est conservé (jamais de lettre codée en dur). Le clic
+ * ouvre un petit menu affichant le nom de l'utilisateur ; les items
+ * Profil / Déconnexion sont relayés à l'hôte via onAction ou, à défaut,
+ * via l'événement draco:bar (détail { act: "profil" | "deconnexion" }),
+ * mais le menu affiche l'identité même sans gestionnaire hôte.
+ * Accessibilité : vrais <button>, aria-haspopup / aria-expanded,
+ * role="menu" / "menuitem", fermeture par Échap et clic extérieur.
 */
 (function () {
  "use strict";
  var cfg = window.DRACO_BAR_CONFIG || {};

+  /* Défauts OFFICIELS (production) — les seuls noms publics présents
+   * dans ce fichier, documentés comme défauts (contrat dev/prod). */
+  var DEFAULT_URLS = {
+    obsigate: "https://og.dracodev.net/",
+    flowdeck: "https://flowdeck.dracodev.net/",
+    tiktak: "https://tiktak.dracodev.net/",
+    kanbante: "https://kanbante.dracodev.net/",
+    agent: "https://agent.dracodev.net/",
+    spark: "https://spark.dracodev.net/"
+  };
+
+  /* Dérivation -dev (v0.1.6) — appliquée UNIQUEMENT quand l'hôte courant
+   * est lui-même un hôte -dev dracodev.net (voir isDevHost). spark est
+   * volontairement absent : aucun hôte spark-dev connu, aucune URL
+   * inventée ; spark retombe sur href rendu puis défaut prod. */
+  var DEV_URLS = {
+    obsigate: "https://og-dev.dracodev.net/",
+    flowdeck: "https://flowdeck-dev.dracodev.net/",
+    tiktak: "https://tiktak-dev.dracodev.net/",
+    kanbante: "https://kanbante-dev.dracodev.net/",
+    agent: "https://agent-dev.dracodev.net/"
+  };
+
+  var APP_LABELS = {
+    obsigate: "ObsiGate", flowdeck: "Flowdeck",
+    tiktak: "TikTak", kanbante: "Kanbante"
+  };
+
+  /* Vrai si hostname est un hôte -dev dracodev.net : première étiquette
+   * se terminant par -dev ET domaine dracodev.net (un suffixe -dev sur
+   * un autre domaine, ou un hôte piège du type x-dev.dracodev.net.evil,
+   * ne déclenche rien). Insensible à la casse. */
+  function isDevHost(hostname) {
+    if (!hostname) return false;
+    var h = String(hostname).toLowerCase();
+    if (h.slice(-13) !== ".dracodev.net") return false;
+    var first = h.split(".")[0];
+    return first.length > 4 && first.slice(-4) === "-dev";
+  }
+
+  /* Un jeton {{…}} non remplacé n'est pas une URL : l'ignorer. */
+  function cleanUrl(u) {
+    if (!u || typeof u !== "string") return null;
+    if (u.indexOf("{{") !== -1) return null;
+    if (!u.replace(/\s/g, "")) return null;
+    return u;
+  }
+
+  function withSlash(u) {
+    return u.charAt(u.length - 1) !== "/" ? u + "/" : u;
+  }
+
+  function resolveUrls() {
+    var host = "";
+    try { host = (window.location && window.location.hostname) || ""; } catch (e) { host = ""; }
+    var dev = isDevHost(host);
+    var urls = {};
+    Object.keys(DEFAULT_URLS).forEach(function (app) {
+      /* 1. Config explicite de l'hôte — prioritaire, même sur -dev. */
+      var u = cleanUrl(cfg.urls && cfg.urls[app]);
+      /* 2. Dérivation -dev par l'hôte courant (spark : pas de dérivée). */
+      if (!u && dev) u = DEV_URLS[app] || null;
+      /* 3. href rendu dans le fragment (jeton remplacé côté serveur). */
+      if (!u) {
+        var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
+        var href = tab ? tab.getAttribute("href") : null;
+        u = cleanUrl(href);
+      }
+      /* 4. Défaut officiel (production). */
+      if (!u) u = DEFAULT_URLS[app];
+      urls[app] = withSlash(u);
+    });
+    return urls;
+  }
+  function applyUrls(urls) {
+    document.querySelectorAll(".draco-apptab, .draco-apps-item").forEach(function (t) {
+      if (t.dataset.app && urls[t.dataset.app]) t.setAttribute("href", urls[t.dataset.app]);
+    });
+  }
+  var resolvedUrls = resolveUrls();
+
  function setCounts(counts) {
    Object.keys(counts || {}).forEach(function (k) {
      /* Toutes les occurrences : l'onglet ET sa ligne dans le menu. */
@@ -43,26 +238,110 @@
    });
  }

-  /* ── Menu des applications (v0.1.3) ──────────────────────────────
-   * Construit depuis les onglets présents dans la barre : mêmes
-   * liens, mêmes icônes, mêmes badges. Ouvert par la marque ✦
-   * (data-act="apps"), fermé par un clic extérieur, Échap, ou le
-   * choix d'une application (la navigation suit son cours). */
+  /* ── Identité / avatar (v0.1.6) ───────────────────────────────────
+   * Nom : cfg.user (chaîne, ou objet display_name / name / username),
+   * sinon le title de l'avatar quand le jeton {{UTILISATEUR}} a bien été
+   * remplacé côté serveur. L'initiale en découle ; sans nom, le neutre
+   * ✦ du fragment est conservé — jamais de lettre codée en dur. */
+  function userName() {
+    var u = cfg.user;
+    if (typeof u === "string" && u.replace(/\s/g, "")) return u.trim();
+    if (u && typeof u === "object") {
+      var n = u.display_name || u.name || u.username;
+      if (n && String(n).replace(/\s/g, "")) return String(n).trim();
+    }
+    return null;
+  }
+  function titleName() {
+    var av = document.querySelector(".draco-avatar");
+    var t = av ? av.getAttribute("title") : null;
+    if (t && t.indexOf("{{") === -1 && t.replace(/\s/g, "")) return t.trim();
+    return null;
+  }
+  function displayName() { return userName() || titleName(); }
+  function syncAvatar() {
+    var av = document.querySelector(".draco-avatar");
+    if (!av) return;
+    /* Compatibilité avec un fragment vendangé antérieur (avatar <span>
+     * sans data-act) : le rendre déclencheur du menu compte. */
+    if (!av.getAttribute("data-act")) av.setAttribute("data-act", "compte");
+    if (!av.getAttribute("aria-haspopup")) av.setAttribute("aria-haspopup", "menu");
+    var name = displayName();
+    if (name) {
+      av.textContent = name.charAt(0).toUpperCase();
+      av.setAttribute("title", name);
+      av.setAttribute("aria-label", "Compte : " + name);
+    }
+  }
+
+  /* ── Menus déroulants (apps, compte) ───────────────────────────────
+   * Un seul menu ouvert à la fois ; fermeture par clic extérieur,
+   * Échap, ou choix d'un item. aria-expanded tenu à jour sur chaque
+   * déclencheur. Les href des menus sont (re)synchronisés avec
+   * resolvedUrls à chaque ouverture, pour que setUrls et la dérivation
+   * -dev s'y reflètent même si le menu a été construit avant. */
  var bar = document.querySelector(".draco-bar");
  var brand = bar ? bar.querySelector(".draco-brand") : null;
-  var menu = null;
+  var avatarBtn = document.querySelector(".draco-avatar");
+  var appsMenu = null, compteMenu = null;
+  /* Déclencheur du menu ouvert en dernier (marque ou avatar) : Échap
+   * lui rend le focus à la fermeture (correctif #70). */
+  var lastOpener = null;

-  function buildMenu() {
-    if (!bar || !brand || menu) return;
-    menu = document.createElement("div");
-    menu.className = "draco-apps-menu";
-    menu.hidden = true;
-    menu.setAttribute("role", "menu");
-    menu.setAttribute("aria-label", "Applications");
+  function setExpanded(btn, open) {
+    if (btn) btn.setAttribute("aria-expanded", open ? "true" : "false");
+  }
+  function refreshMenuHrefs(menu) {
+    if (!menu) return;
+    menu.querySelectorAll(".draco-apps-item").forEach(function (a) {
+      if (a.dataset.app && resolvedUrls[a.dataset.app]) a.setAttribute("href", resolvedUrls[a.dataset.app]);
+    });
+  }
+  function togglePopup(menu, btn, force) {
+    if (!menu) return;
+    var open = typeof force === "boolean" ? force : menu.hidden;
+    menu.hidden = !open;
+    setExpanded(btn, open);
+  }
+  function closeAllPopups(returnFocus) {
+    var anyOpen = (appsMenu && !appsMenu.hidden) || (compteMenu && !compteMenu.hidden);
+    if (appsMenu) togglePopup(appsMenu, brand, false);
+    if (compteMenu) togglePopup(compteMenu, avatarBtn, false);
+    /* Échap seulement : le clic extérieur ne déplace pas le focus
+     * (voir l'en-tête, « Focus »). */
+    if (returnFocus && anyOpen && lastOpener && typeof lastOpener.focus === "function") lastOpener.focus();
+  }
+  function tabLabel(app) {
+    var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
+    var fort = tab ? tab.querySelector(".draco-apptab-txt strong") : null;
+    return fort ? fort.textContent : (APP_LABELS[app] || app);
+  }
+  function tabRole(app) {
+    var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
+    var petit = tab ? tab.querySelector(".draco-apptab-txt small") : null;
+    return petit ? petit.textContent : "";
+  }
+  /* Menu des applications (v0.1.3) — construit depuis les onglets
+   * présents dans la barre : mêmes liens, mêmes icônes, mêmes badges.
+   * Ouvert par la marque ✦ (data-act="apps"), fermé par un clic
+   * extérieur, Échap, ou le choix d'une application (la navigation
+   * suit son cours). */
+  function buildAppsMenu() {
+    if (!bar || !brand || appsMenu) return;
+    appsMenu = document.createElement("div");
+    appsMenu.className = "draco-apps-menu";
+    appsMenu.hidden = true;
+    appsMenu.setAttribute("role", "menu");
+    appsMenu.setAttribute("aria-label", "Applications");
    document.querySelectorAll(".draco-apptab").forEach(function (t) {
+      /* Chantier 5 : l'onglet agent (« Console Spark ») n'est PAS
+       * repris ici — l'entrée dédiée ci-dessous le représente déjà
+       * (après Kanbante, avec séparateur) ; sans ce saut, le menu
+       * listerait « Console Spark » deux fois. */
+      if (t.dataset.app === "agent") return;
      var a = document.createElement("a");
      a.className = "draco-apps-item";
-      a.href = t.getAttribute("href");
+      a.href = resolvedUrls[t.dataset.app] || t.getAttribute("href");
      a.dataset.app = t.dataset.app;
      a.setAttribute("role", "menuitem");
      var ico = t.querySelector(".draco-apptab-ico");
@@ -84,44 +363,183 @@
      a.appendChild(txt);
      var badge = t.querySelector(".draco-badge");
      if (badge) a.appendChild(badge.cloneNode(true));
-      menu.appendChild(a);
+      appsMenu.appendChild(a);
    });
-    bar.appendChild(menu);
+    /* Entrée « Console Spark » (#70) : après Kanbante, vers la console
+     * de l'agent commun (URL agent résolue — explicite > -dev >
+     * défaut prod ; aucun hôte spark-dev inventé). data-app="agent"
+     * l'intègre à refreshMenuHrefs/applyUrls/setCurrent comme les
+     * autres items ; l'icône ✦ reprend la couleur agent du CSS. */
+    var sep = document.createElement("div");
+    sep.className = "draco-menu-sep";
+    sep.setAttribute("aria-hidden", "true");
+    appsMenu.appendChild(sep);
+    var sparkItem = document.createElement("a");
+    sparkItem.className = "draco-apps-item";
+    sparkItem.href = resolvedUrls.agent || "#";
+    sparkItem.dataset.app = "agent";
+    sparkItem.setAttribute("role", "menuitem");
+    var sparkIco = document.createElement("span");
+    sparkIco.className = "draco-apptab-ico";
+    sparkIco.setAttribute("style", "--app:#c2437e");
+    sparkIco.textContent = "✦";
+    sparkItem.appendChild(sparkIco);
+    var sparkTxt = document.createElement("span");
+    sparkTxt.className = "draco-apps-item-txt";
+    var sparkNom = document.createElement("span");
+    sparkNom.className = "draco-apps-item-nom";
+    sparkNom.textContent = "Console Spark";
+    sparkTxt.appendChild(sparkNom);
+    var sparkRole = document.createElement("span");
+    sparkRole.className = "draco-apps-item-role";
+    sparkRole.textContent = "Agent commun";
+    sparkTxt.appendChild(sparkRole);
+    sparkItem.appendChild(sparkTxt);
+    appsMenu.appendChild(sparkItem);
+    bar.appendChild(appsMenu);
+  }
+  function toggleAppsMenu(force) {
+    buildAppsMenu();
+    if (!appsMenu) return;
+    if (force !== false) refreshMenuHrefs(appsMenu);
+    togglePopup(appsMenu, brand, force);
+    if (!appsMenu.hidden) lastOpener = brand;
  }

-  function toggleMenu(force) {
-    buildMenu();
-    if (!menu) return;
-    var open = typeof force === "boolean" ? force : menu.hidden;
-    menu.hidden = !open;
-    if (brand) brand.setAttribute("aria-expanded", open ? "true" : "false");
+  /* Menu compte (v0.1.6) — en-tête d'identité + Profil / Déconnexion
+   * relayés à l'hôte. L'en-tête est rafraîchi à chaque ouverture, pour
+   * refléter un title posé après coup par l'hôte (ex. ObsiGate, qui
+   * remplit l'avatar depuis /api/auth/me après chargement). */
+  function buildCompteMenu() {
+    if (!bar || !avatarBtn || compteMenu) return;
+    compteMenu = document.createElement("div");
+    compteMenu.className = "draco-compte-menu";
+    compteMenu.hidden = true;
+    compteMenu.setAttribute("role", "menu");
+    compteMenu.setAttribute("aria-label", "Compte");
+    var head = document.createElement("div");
+    head.className = "draco-compte-nom";
+    compteMenu.appendChild(head);
+    [["profil", "Profil"], ["deconnexion", "Déconnexion"]].forEach(function (pair) {
+      var b = document.createElement("button");
+      b.type = "button";
+      b.className = "draco-menu-item";
+      b.setAttribute("data-compte-act", pair[0]);
+      b.setAttribute("role", "menuitem");
+      b.textContent = pair[1];
+      compteMenu.appendChild(b);
+    });
+    bar.appendChild(compteMenu);
+  }
+  function refreshCompteMenu() {
+    if (!compteMenu) return;
+    var head = compteMenu.querySelector(".draco-compte-nom");
+    var name = displayName();
+    if (head) head.textContent = name || "Compte";
+  }
+  function toggleCompteMenu(force) {
+    buildCompteMenu();
+    if (!compteMenu) return;
+    if (force !== false) { syncAvatar(); refreshCompteMenu(); }
+    togglePopup(compteMenu, avatarBtn, force);
+    if (!compteMenu.hidden) lastOpener = avatarBtn;
  }

-  document.addEventListener("click", function (ev) {
-    var el = ev.target.closest("[data-act]");
-    if (el && el.dataset.act === "apps") {
-      ev.preventDefault();
-      toggleMenu();
+  /* Relais d'une action vers l'hôte : onAction si présent, sinon
+   * événement draco:bar (contrat historique des actions relayées). */
+  function relay(act, el, ev) {
+    if (typeof cfg.onAction === "function") cfg.onAction(act, el, ev);
+    else document.dispatchEvent(new CustomEvent("draco:bar", { detail: { act: act, el: el } }));
+  }
+
+  /* Écouteurs globaux posés sur le prototype EventTarget quand il
+   * existe, pour survivre au registre/teardown d'un hôte SPA (TikTak,
+   * voir l'en-tête) ; sinon document.addEventListener classique. */
+  function addGlobalListener(type, fn) {
+    try {
+      if (typeof EventTarget !== "undefined" && EventTarget.prototype &&
+          EventTarget.prototype.addEventListener) {
+        EventTarget.prototype.addEventListener.call(document, type, fn, false);
+        return;
+      }
+    } catch (e) { /* repli ci-dessous */ }
+    document.addEventListener(type, fn);
+  }
+
+  addGlobalListener("click", function (ev) {
+    /* Items du menu compte : relais + fermeture, jamais de navigation. */
+    var compteItem = ev.target.closest ? ev.target.closest("[data-compte-act]") : null;
+    if (compteItem) {
+      relay(compteItem.getAttribute("data-compte-act"), compteItem, ev);
+      toggleCompteMenu(false);
      return;
    }
-    if (menu && !menu.hidden && !ev.target.closest(".draco-apps-menu") && !ev.target.closest(".draco-brand")) {
-      toggleMenu(false);
+    var el = ev.target.closest ? ev.target.closest("[data-act]") : null;
+    if (el && el.dataset.act === "apps") {
+      ev.preventDefault();
+      if (compteMenu) toggleCompteMenu(false);
+      toggleAppsMenu();
+      return;
+    }
+    if (el && el.dataset.act === "compte") {
+      if (appsMenu) toggleAppsMenu(false);
+      toggleCompteMenu();
+      return;
+    }
+    /* Clic extérieur : ferme tout menu ouvert (clic dans un menu ou
+     * sur son déclencheur déjà traité ci-dessus). */
+    var inPopup = ev.target.closest ? (ev.target.closest(".draco-apps-menu") ||
+      ev.target.closest(".draco-compte-menu")) : null;
+    if (!inPopup && ((appsMenu && !appsMenu.hidden) || (compteMenu && !compteMenu.hidden))) {
+      closeAllPopups(false);
    }
    if (!el) return;
    var act = el.dataset.act;
    if (act === "domaine") setDomain(el.dataset.dom);
-    if (typeof cfg.onAction === "function") cfg.onAction(act, el, ev);
-    else document.dispatchEvent(new CustomEvent("draco:bar", { detail: { act: act, el: el } }));
+    relay(act, el, ev);
  });

-  document.addEventListener("keydown", function (ev) {
-    if (ev.key === "Escape") toggleMenu(false);
+  addGlobalListener("keydown", function (ev) {
+    if (ev.key === "Escape") { closeAllPopups(true); return; }
+    /* Espace sur la marque : un lien ne s'active pas à l'Espace, donc
+     * ouverture explicite + focus sur le premier item du menu (#70).
+     * Entrée : clic natif du lien, déjà géré par le gestionnaire clic
+     * ci-dessus (pas de double bascule ici). */
+    if ((ev.key === " " || ev.key === "Spacebar") && ev.target && ev.target.closest) {
+      var brandEl = ev.target.closest('[data-act="apps"]');
+      if (brandEl) {
+        if (ev.preventDefault) ev.preventDefault();
+        toggleAppsMenu();
+        if (appsMenu && !appsMenu.hidden) {
+          var first = appsMenu.querySelector(".draco-apps-item");
+          if (first && typeof first.focus === "function") first.focus();
+        }
+      }
+    }
  });

-  /* API publique : l'app met les compteurs à jour sans recharger. */
-  window.DRACO_BAR = { setCounts: setCounts, setCurrent: setCurrent, setDomain: setDomain };
+  /* API publique : l'app met les compteurs à jour sans recharger.
+   * setUrls(urls) fusionne de nouvelles bases (même contrat que
+   * DRACO_BAR_CONFIG.urls — donc prioritaires sur la dérivation -dev)
+   * et les ré-applique aux onglets et aux menus ; DRACO_BAR.urls expose
+   * les bases résolues (défauts inclus), pour le panneau Spark et tout
+   * autre consommateur de l'hôte. */
+  window.DRACO_BAR = {
+    setCounts: setCounts, setCurrent: setCurrent, setDomain: setDomain,
+    urls: resolvedUrls,
+    setUrls: function (urls) {
+      cfg.urls = Object.assign({}, cfg.urls, urls || {});
+      resolvedUrls = resolveUrls();
+      window.DRACO_BAR.urls = resolvedUrls;
+      applyUrls(resolvedUrls);
+    }
+  };

-  buildMenu();
+  applyUrls(resolvedUrls);
+  buildAppsMenu();
+  buildCompteMenu();
+  syncAvatar();
+  refreshCompteMenu();
  if (cfg.current) setCurrent(cfg.current);
  if (cfg.domain) setDomain(cfg.domain);
  if (cfg.counts) setCounts(cfg.counts);
@@ -19,7 +19,7 @@
 * (persistée), thème clair/sombre aligné sur l'app hôte
 * (html[data-theme], repli prefers-color-scheme, suivi en direct).
 * Bouton « Console » (barre des discussions) : ouvre la console web
- * du même service (agent.dracodev.net) DANS la page, en surimpression
+ * du même service (adresse injectée par l'hôte) DANS la page, en surimpression
 * pleine page (iframe) qui naît à la géométrie du panneau puis
 * s'étend à toute la fenêtre ; l'URL profonde (?disc= discussion
 * courante, ?app= app d'origine déduite du sous-domaine) est celle
@@ -32,13 +32,18 @@
 * configuré / exécuteur non configuré sont affichés tels quels. */
 (function () {
  "use strict";
-  var API = "https://agent.dracodev.net";
+  /* Adresse du service : injectée par l'app hôte (gabarit
+   * _draco_bar.html, window.DRACO_PANNEAU_CONFIG.api, issu de la
+   * configuration de l'hôte — AGENT_URL). Aucun nom public en dur
+   * ici : sans injection, le panneau se déclare non configuré. */
+  var API = (window.DRACO_PANNEAU_CONFIG && window.DRACO_PANNEAU_CONFIG.api) || "";
  var convId = null;
  var convKind = null;      // 'principale' | 'parallele'
  var convTitre = "";
  var etatConnu = false;
  var root = null, msgsEl = null, etatEl = null, inputEl = null, sendBtn = null;
  var titreEl = null, tiroirEl = null;
+  var versionEl = null, versionConnue = "", versionMaj = 0;

  function domaine() {
    try { return localStorage.getItem("draco_domain") || "pro"; } catch (e) { return "pro"; }
@@ -251,7 +256,7 @@
      '  <span class="d-titre">Discussion principale</span>' +
      '  <button type="button" class="d-btn" data-disc="liste">☰ Discussions</button>' +
      '  <button type="button" class="d-btn" data-disc="nouvelle">＋ Nouvelle</button>' +
-      '  <button type="button" class="d-btn" data-disc="console" title="Ouvrir la console Spark (agent.dracodev.net) en pleine page par-dessus l\'application, sur cette discussion">Console ⤢</button>' +
+      '  <button type="button" class="d-btn" data-disc="console" title="Ouvrir la console Spark en pleine page par-dessus l\'application, sur cette discussion">Console ⤢</button>' +
      '</div>' +
      '<div class="draco-discussions" hidden></div>' +
      '<div class="draco-panneau-outils">' +
@@ -264,6 +269,7 @@
      '  <input type="text" placeholder="Écrire à Spark…" autocomplete="off" aria-label="Message à Spark">' +
      '  <button type="submit">Envoyer</button></form>' +
      '  <div class="draco-panneau-note">Conversation réelle, sous-agents (J3) et missions longues (J5) vers les exécuteurs configurés ; toute écriture dans les apps passe par une approbation.</div>' +
+      '  <div class="draco-panneau-version" style="margin-top:6px;font-size:11.5px;opacity:.6" hidden></div>' +
      '</div>';
    document.body.appendChild(root);
    msgsEl = root.querySelector(".draco-panneau-msgs");
@@ -272,6 +278,7 @@
    sendBtn = root.querySelector("button[type=submit]");
    titreEl = root.querySelector(".d-titre");
    tiroirEl = root.querySelector(".draco-discussions");
+    versionEl = root.querySelector(".draco-panneau-version");
    root.querySelector(".fermer").addEventListener("click", fermer);
    root.querySelector('[data-disc="liste"]').addEventListener("click", basculerTiroir);
    root.querySelector('[data-disc="nouvelle"]').addEventListener("click", nouvelleDiscussion);
@@ -326,8 +333,43 @@
    titreEl.title = titreEl.textContent;
  }

+  /* ── Version du service : lue en direct dans la santé de
+   * l'agent (GET /healthz → champ « version », la même source que
+   * la console) à l'origine que le panneau connaît déjà. Cache de
+   * session (5 min), rafraîchie à l'ouverture du panneau, au même
+   * rythme que la vérification d'identité. Jamais de valeur codée
+   * en dur : source injoignable ou réponse illisible = la ligne
+   * reste masquée — pas de fausse version, pas d'erreur visible. */
+  function afficherVersion() {
+    if (!versionEl) return;
+    if (versionConnue) {
+      versionEl.textContent = "Service d'agents v" + versionConnue;
+      versionEl.hidden = false;
+    }
+  }
+  function chargerVersion() {
+    if (!API || !versionEl) return;
+    if (versionConnue && Date.now() - versionMaj < 300000) { afficherVersion(); return; }
+    fetch(API + "/healthz")
+      .then(function (r) { if (!r.ok) throw new Error("HTTP " + r.status); return r.json(); })
+      .then(function (d) {
+        if (d && typeof d.version === "string" && /^[0-9]+\.[0-9]+\.[0-9]+/.test(d.version)) {
+          versionConnue = d.version;
+          versionMaj = Date.now();
+          afficherVersion();
+        }
+      })
+      .catch(function () { /* service injoignable : rien d'affiché */ });
+  }
+
  function verifierIdentite() {
    if (etatConnu) return;
+    if (!API) {
+      majEtat("err", "Panneau Spark non configuré");
+      ajouterMsg("sys", "Adresse du service d'agents absente : l'app hôte ne l'a pas injectée (DRACO_PANNEAU_CONFIG / AGENT_URL).");
+      etatConnu = true;
+      return;
+    }
    fetch(API + "/api/v1/me", { credentials: "include" })
      .then(function (r) {
        if (r.status === 401) {
@@ -346,7 +388,7 @@
      })
      .catch(function () {
        majEtat("err", "Service d'agents injoignable");
-        ajouterMsg("sys", "Le service d'agents (agent.dracodev.net) ne répond pas. Vérifie que le conteneur dracodev-agent est démarré.");
+        ajouterMsg("sys", "Le service d'agents (" + API + ") ne répond pas. Vérifie que le conteneur dracodev-agent est démarré.");
      });
  }

@@ -802,6 +844,7 @@
    root.classList.add("open");
    appliquerTheme();
    verifierIdentite();
+    chargerVersion();
    setTimeout(function () { inputEl.focus(); }, 300);
  }
  function fermer() { if (root) root.classList.remove("open"); }
@@ -0,0 +1,190 @@
+// Mes issues — filtrage instantané côté client (0.33.0).
+// Aucune requête réseau : les lignes portent leurs facettes en
+// attributs data-*, le moteur ne fait que comparer des chaînes
+// normalisées. Les filtres structurels (projet, colonnes,
+// étiquette, tri) persistent en localStorage ; la recherche
+// texte, elle, est éphémère.
+(() => {
+    const search = document.getElementById('my-search');
+    if (!search) return; // page sans résultats : rien à filtrer
+    const repoSel = document.getElementById('my-repo');
+    const labelSel = document.getElementById('my-label');
+    const sortSel = document.getElementById('my-sort');
+    const chipsBox = document.getElementById('my-col-chips');
+    const countEl = document.getElementById('my-count');
+    const resetBtn = document.getElementById('my-reset');
+    const emptyBox = document.getElementById('my-empty');
+    const emptyReset = document.getElementById('my-empty-reset');
+    const STORE_KEY = 'kanbante-my-filters';
+
+    const norm = (s) => (s || '')
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '');
+
+    const state = {
+        q: '',
+        repo: '',
+        label: '',
+        cols: new Set(),
+        sort: 'recent',
+    };
+
+    // ── Persistance des filtres structurels ────────────────
+    try {
+        const saved = JSON.parse(localStorage.getItem(STORE_KEY) || '{}');
+        if (saved.repo) state.repo = saved.repo;
+        if (saved.label) state.label = saved.label;
+        if (Array.isArray(saved.cols)) state.cols = new Set(saved.cols);
+        if (saved.sort) state.sort = saved.sort;
+    } catch { /* stockage indisponible : état par défaut */ }
+
+    function persist() {
+        try {
+            localStorage.setItem(STORE_KEY, JSON.stringify({
+                repo: state.repo,
+                label: state.label,
+                cols: [...state.cols],
+                sort: state.sort,
+            }));
+        } catch { /* sans gravité */ }
+    }
+
+    // Refléter l'état restauré dans les contrôles.
+    if (state.repo) repoSel.value = state.repo;
+    if (state.label) labelSel.value = state.label;
+    sortSel.value = state.sort;
+    // Un filtre restauré peut ne plus exister (projet disparu) :
+    // dans ce cas le select retombe à « tous » tout seul.
+    if (repoSel.value !== state.repo) state.repo = repoSel.value;
+    if (labelSel.value !== state.label) state.label = labelSel.value;
+
+    const groups = [...document.querySelectorAll('.focus-group')];
+    const allRows = [...document.querySelectorAll('.issue-row')];
+    allRows.forEach((row) => {
+        row._search = norm(row.dataset.search);
+        row._labels = norm(row.dataset.labels).split(' ').filter(Boolean);
+        row._title = norm(row.dataset.title);
+    });
+
+    function syncChips() {
+        chipsBox.querySelectorAll('.filter-chip').forEach((chip) => {
+            const col = chip.dataset.col;
+            const on = col === '' ? state.cols.size === 0 : state.cols.has(col);
+            chip.classList.toggle('on', on);
+            if (col !== '') chip.setAttribute('aria-pressed', on ? 'true' : 'false');
+        });
+    }
+
+    function sortRows() {
+        const mode = state.sort;
+        if (mode === 'repo') {
+            const main = document.querySelector('.focus-main');
+            [...groups].sort((a, b) =>
+                a.dataset.repo.localeCompare(b.dataset.repo)
+            ).forEach((g) => main.appendChild(g));
+        }
+        groups.forEach((group) => {
+            const box = group.querySelector('.issue-results');
+            const rows = [...box.querySelectorAll('.issue-row')];
+            const by = {
+                recent: (a, b) => (b.dataset.updated || '').localeCompare(a.dataset.updated || ''),
+                oldest: (a, b) => (a.dataset.updated || '').localeCompare(b.dataset.updated || ''),
+                title: (a, b) => a._title.localeCompare(b._title),
+                repo: (a, b) => a._title.localeCompare(b._title),
+            }[mode];
+            rows.sort(by).forEach((r) => box.appendChild(r));
+        });
+    }
+
+    function apply() {
+        const q = norm(state.q).trim();
+        let visible = 0;
+        groups.forEach((group) => {
+            let groupVisible = 0;
+            group.querySelectorAll('.issue-row').forEach((row) => {
+                const okText = !q || row._search.includes(q);
+                const okRepo = !state.repo || group.dataset.repo === state.repo;
+                const okCol = state.cols.size === 0 || state.cols.has(row.dataset.column);
+                const okLabel = !state.label
+                    || row._labels.includes(norm(state.label));
+                const ok = okText && okRepo && okCol && okLabel;
+                row.hidden = !ok;
+                if (ok) groupVisible++;
+            });
+            group.hidden = groupVisible === 0;
+            const badge = group.querySelector('[data-group-count]');
+            if (badge) badge.textContent = groupVisible;
+            visible += groupVisible;
+        });
+        countEl.textContent = visible === allRows.length
+            ? `${visible} issue${visible > 1 ? 's' : ''}`
+            : `${visible} sur ${allRows.length} issues`;
+        const filtering = q || state.repo || state.label
+            || state.cols.size > 0;
+        resetBtn.hidden = !filtering;
+        emptyBox.hidden = visible !== 0;
+        syncChips();
+        persist();
+    }
+
+    function resetAll() {
+        state.q = '';
+        search.value = '';
+        state.repo = '';
+        repoSel.value = '';
+        state.label = '';
+        labelSel.value = '';
+        state.cols.clear();
+        sortSel.value = 'recent';
+        state.sort = 'recent';
+        sortRows();
+        apply();
+        search.focus();
+    }
+
+    // ── Événements ─────────────────────────────────────────
+    let raf = 0;
+    search.addEventListener('input', () => {
+        cancelAnimationFrame(raf);
+        raf = requestAnimationFrame(() => {
+            state.q = search.value;
+            apply();
+        });
+    });
+    search.addEventListener('keydown', (e) => {
+        if (e.key === 'Escape') {
+            search.value = '';
+            state.q = '';
+            apply();
+        }
+    });
+    repoSel.addEventListener('change', () => { state.repo = repoSel.value; apply(); });
+    labelSel.addEventListener('change', () => { state.label = labelSel.value; apply(); });
+    sortSel.addEventListener('change', () => {
+        state.sort = sortSel.value;
+        sortRows();
+        apply();
+    });
+    chipsBox.addEventListener('click', (e) => {
+        const chip = e.target.closest('.filter-chip');
+        if (!chip) return;
+        const col = chip.dataset.col;
+        if (col === '') state.cols.clear();
+        else if (state.cols.has(col)) state.cols.delete(col);
+        else state.cols.add(col);
+        apply();
+    });
+    resetBtn.addEventListener('click', resetAll);
+    emptyReset?.addEventListener('click', resetAll);
+    document.addEventListener('keydown', (e) => {
+        if (e.key !== '/') return;
+        const tag = document.activeElement?.tagName;
+        if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') return;
+        e.preventDefault();
+        search.focus();
+    });
+
+    sortRows();
+    apply();
+})();
@@ -13,6 +13,7 @@
    var ACTIONS = [
        { icon: '🏠', label: 'Projets — dashboard', href: '/' },
        { icon: '🎯', label: 'Focus — en cours, QA, révision', href: '/focus' },
+        { icon: '🛩️', label: 'En vol partout — encours tous projets, par colonne', href: '/inflight' },
        { icon: '🌅', label: "Focus du jour — les 3 cartes d'aujourd'hui", href: '/today' },
        { icon: '🔮', label: 'Prévisions — on finit quand ?', href: '/forecast' },
        { icon: '🗣️', label: 'Standup automatique — hier, aujourd\'hui, blocages', href: '/standup' },
@@ -0,0 +1,27 @@
+// Page Projet — écritures de jalons (0.35.0, issue #26).
+// Les formulaires data-ms-form sont interceptés : POST vers
+// l'API Kanbante (qui écrit dans la forge), puis rechargement
+// pour refléter l'état réel.
+(() => {
+    const csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
+    document.querySelectorAll('form[data-ms-form]').forEach((form) => {
+        form.addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const confirmMsg = form.dataset.confirm;
+            if (confirmMsg && !window.confirm(confirmMsg)) return;
+            const fd = new FormData(form);
+            fd.append('csrf_token', csrf);
+            const btn = form.querySelector('button[type="submit"]');
+            if (btn) btn.disabled = true;
+            try {
+                const r = await fetch(form.dataset.action, { method: 'POST', body: fd });
+                const data = await r.json().catch(() => ({}));
+                if (!r.ok || !data.ok) throw new Error(data.error || ('HTTP ' + r.status));
+                window.location.reload();
+            } catch (err) {
+                if (btn) btn.disabled = false;
+                window.alert('❌ ' + err.message);
+            }
+        });
+    });
+})();
@@ -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
+);
@@ -359,15 +359,64 @@ class FakeGitea:
        else:
            self.starred.discard(f"{owner}/{repo}")

-    async def get_milestones(self, owner, repo, state="open"):
-        return [
+    @property
+    def _milestones(self):
+        return self.__dict__.setdefault(
+            "milestones_store",
            {
-                "id": 1, "title": "Sprint 1",
-                "due_on": "2026-10-20T00:00:00Z",
-                "open_issues": 1, "closed_issues": 1,
-            }
+                "Projets/demo": [
+                    {
+                        "id": 1, "title": "Sprint 1",
+                        "description": "",
+                        "due_on": "2026-10-20T00:00:00Z",
+                        "state": "open",
+                        "open_issues": 1, "closed_issues": 1,
+                    }
+                ]
+            },
+        )
+
+    async def get_milestones(self, owner, repo, state="open"):
+        items = self._milestones.get(f"{owner}/{repo}", [])
+        return [
+            dict(m) for m in items
+            if state == "all" or m.get("state", "open") == state
        ]

+    async def create_milestone(
+        self, owner, repo, title, description="", due_on=None
+    ):
+        store = self._milestones.setdefault(f"{owner}/{repo}", [])
+        milestone = {
+            "id": 100 + len(store),
+            "title": title,
+            "description": description,
+            "due_on": due_on,
+            "state": "open",
+            "open_issues": 0, "closed_issues": 0,
+        }
+        store.append(milestone)
+        return dict(milestone)
+
+    async def update_milestone(
+        self, owner, repo, milestone_id, title=None, description=None,
+        due_on=None, clear_due=False, state=None,
+    ):
+        for m in self._milestones.get(f"{owner}/{repo}", []):
+            if m["id"] == milestone_id:
+                if title is not None:
+                    m["title"] = title
+                if description is not None:
+                    m["description"] = description
+                if clear_due:
+                    m["due_on"] = None
+                elif due_on:
+                    m["due_on"] = due_on
+                if state is not None:
+                    m["state"] = state
+                return dict(m)
+        raise AssertionError("jalon introuvable dans le faux")
+
    async def create_issue(self, owner, repo, title, body=""):
        self._next_number += 1
        issue = _issue(self._next_number, title)
@@ -0,0 +1,236 @@
+// Tests unitaires (node:test) du module partagé draco-alertes.js.
+// Exécutés dans la sandbox : node --test draco-alertes.test.js
+// Copie vendangée byte-identique de Projets/dracodev-commons
+// ui/alertes/ (chantier 5) — seul le require change selon l'hôte.
+// Hôte : Kanbante
+// Aucune donnée inventée : les payloads reprennent la forme exacte
+// des API réelles (Flowdeck /api/notifications, TikTak
+// /api/notifications, Kanbante /api/events). Le payload console
+// n'est qu'un EXEMPLE DE FORMAT (voir README commons) : aucun
+// endpoint console n'est publié sur agent-commun main au moment
+// du chantier.
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const t = require("../static/js/draco-alertes.js");
+
+function sampleResults() {
+  return {
+    flowdeck: { items: t.normalizeFlowdeck("https://flowdeck.dracodev.net/", {
+      notifications: [
+        { id: 1, ntype: "mention", title: "Mention budget", message: "voir page", url: "/collections/3", is_read: 0, created_at: "2026-10-28T10:00:00" },
+        { id: 2, ntype: "reminder", title: "Rappel lu", message: "", url: "", is_read: 1, created_at: "2026-10-27T09:00:00" },
+      ], unread: 1,
+    }) },
+    tiktak: { items: t.normalizeTiktak("https://tiktak.dracodev.net/", [
+      { id: 7, kind: "reminder", title: "Rappel tâche", body: "tache", task_id: 42, is_read: 0, created_at: "2026-10-28T08:00:00" },
+      { id: 8, kind: "share", title: "Partage lu", body: "", task_id: null, is_read: 1, created_at: "2026-10-26T08:00:00" },
+    ]) },
+    kanbante: { items: t.normalizeKanbante("https://kanbante.dracodev.net/", {
+      events: [
+        { id: 9, repo_full_name: "Projets/fusion-trois-apps", issue_number: 69, event_type: "commented", from_column: "", to_column: "", created_at: "2026-10-28T11:50:00" },
+        { id: 10, repo_full_name: "Projets/fusion-trois-apps", issue_number: 69, event_type: "moved", from_column: "todo", to_column: "review", created_at: "2026-10-28T12:00:00" },
+      ],
+    }) },
+    obsigate: { items: [] },
+    console: { items: [], sourceMissing: true },
+  };
+}
+function allOf(results) {
+  const all = [];
+  for (const app of ["obsigate", "flowdeck", "tiktak", "kanbante", "console"]) {
+    (results[app] && results[app].items || []).forEach((a) => all.push(a));
+  }
+  return all;
+}
+
+test("ordre des onglets : Tout, apps, Console Spark, Historique", () => {
+  assert.deepEqual(t.TABS, ["tout", "obsigate", "flowdeck", "tiktak", "kanbante", "console", "historique"]);
+  assert.equal(t.TAB_LABELS.console, "Console Spark");
+});
+
+test("resolveUrls: config explicite > hote -dev > href > defaut prod, agent inclus", () => {
+  const prod = t.resolveUrls({ hostname: "tiktak.dracodev.net", tabHrefs: {} });
+  assert.equal(prod.tiktak, "https://tiktak.dracodev.net/");
+  assert.equal(prod.agent, "https://agent.dracodev.net/");
+  const dev = t.resolveUrls({ hostname: "tiktak-dev.dracodev.net", tabHrefs: {} });
+  assert.equal(dev.flowdeck, "https://flowdeck-dev.dracodev.net/");
+  assert.equal(dev.obsigate, "https://og-dev.dracodev.net/");
+  assert.equal(dev.agent, "https://agent-dev.dracodev.net/");
+  const explicit = t.resolveUrls({
+    hostname: "tiktak-dev.dracodev.net",
+    configUrls: { flowdeck: "https://flowdeck.dracodev.net/" },
+  });
+  assert.equal(explicit.flowdeck, "https://flowdeck.dracodev.net/");
+  const href = t.resolveUrls({
+    hostname: "example.org",
+    tabHrefs: { kanbante: "https://kanbante-dev.dracodev.net/", agent: "https://agent.dracodev.net/" },
+  });
+  assert.equal(href.kanbante, "https://kanbante-dev.dracodev.net/");
+  assert.equal(href.agent, "https://agent.dracodev.net/");
+  const token = t.resolveUrls({ hostname: "x", tabHrefs: { tiktak: "{{URL_TIKTAK}}" } });
+  assert.equal(token.tiktak, "https://tiktak.dracodev.net/");
+  assert.equal(t.isDevHost("tiktak-dev.dracodev.net.evil.com"), false);
+  assert.equal(t.isDevHost("x-dev.dracodev.net"), true);
+});
+
+test("normalizeFlowdeck: non lues actives, lien = base + url", () => {
+  const items = t.normalizeFlowdeck("https://flowdeck.dracodev.net/", {
+    notifications: [
+      { id: 1, ntype: "mention", title: "Mention", message: "voir page", url: "/collections/3", is_read: 0, created_at: "2026-10-28T10:00:00" },
+      { id: 2, ntype: "reminder", title: "Rappel", message: "", url: "", is_read: 1, created_at: "2026-10-27T09:00:00" },
+    ], unread: 1,
+  });
+  assert.equal(items.length, 2);
+  assert.equal(items[0].active, true);
+  assert.equal(items[0].state, "active");
+  assert.equal(items[0].url, "https://flowdeck.dracodev.net/collections/3");
+  assert.equal(items[1].active, false);
+  assert.equal(items[1].url, "https://flowdeck.dracodev.net/");
+});
+
+test("normalizeTiktak: lien tache, sinon page notifications", () => {
+  const items = t.normalizeTiktak("https://tiktak.dracodev.net/", [
+    { id: 7, kind: "reminder", title: "Rappel", body: "tache", task_id: 42, is_read: 0, created_at: "2026-10-28T08:00:00" },
+    { id: 8, kind: "share", title: "Partage", body: "", task_id: null, is_read: 1, created_at: "2026-10-26T08:00:00" },
+  ]);
+  assert.equal(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);
+});
+
+test("scopeAlerts: Tout et onglets apps = actives seulement ; Historique = fermees seulement", () => {
+  const r = sampleResults();
+  const all = allOf(r);
+  const tout = t.scopeAlerts(all, "tout", r);
+  assert.equal(tout.items.length, 2);
+  assert.ok(tout.items.every((a) => a.active));
+  assert.equal(tout.items[0].date, "2026-10-28T10:00:00"); // date decroissante
+  const fd = t.scopeAlerts(all, "flowdeck", r);
+  assert.equal(fd.items.length, 1);
+  assert.equal(fd.items[0].app, "flowdeck");
+  const hist = t.scopeAlerts(all, "historique", r);
+  assert.equal(hist.items.length, 4); // 1 FD lue + 1 TK lue + 2 KB
+  assert.ok(hist.items.every((a) => !a.active));
+  const og = t.scopeAlerts(all, "obsigate", r);
+  assert.equal(og.items.length, 0);
+  const cs = t.scopeAlerts(all, "console", r);
+  assert.equal(cs.items.length, 0);
+  assert.equal(cs.consoleMissing, true);
+});
+
+test("scopeAlerts: une section en echec remonte aussi dans Historique (pas avalee)", () => {
+  const r = sampleResults();
+  r.flowdeck = { items: [], error: "Application injoignable depuis cet hôte (TypeError)." };
+  const hist = t.scopeAlerts(allOf(r), "historique", r);
+  assert.equal(hist.errors.length, 1);
+  assert.equal(hist.errors[0].app, "flowdeck");
+  const tout = t.scopeAlerts(allOf(r), "tout", r);
+  assert.equal(tout.errors.length, 1);
+});
+
+test("countByTab: compteurs par onglet sur l'echantillon", () => {
+  const r = sampleResults();
+  const c = t.countByTab(allOf(r), r);
+  assert.deepEqual(c, {
+    tout: 2, obsigate: 0, flowdeck: 1, tiktak: 1,
+    kanbante: 0, console: 0, historique: 4,
+  });
+});
+
+test("filterAlerts: titre + contexte, insensible a la casse, sans melanger actifs/historique", () => {
+  const r = sampleResults();
+  const all = allOf(r);
+  const tout = t.scopeAlerts(all, "tout", r).items;
+  assert.equal(t.filterAlerts(tout, "budget").length, 1);
+  assert.equal(t.filterAlerts(tout, "BUDGET").length, 1);
+  assert.equal(t.filterAlerts(tout, "voir page").length, 1); // contexte (detail)
+  assert.equal(t.filterAlerts(tout, "tache").length, 1);
+  // « Rappel lu » est une alerte fermee : absente de Tout meme filtree.
+  assert.equal(t.filterAlerts(tout, "Rappel lu").length, 0);
+  const hist = t.scopeAlerts(all, "historique", r).items;
+  assert.equal(t.filterAlerts(hist, "Rappel lu").length, 1);
+  assert.equal(t.filterAlerts(tout, "").length, tout.length);
+});
+
+test("presentation identique: meta Kanbante sans type brut anglais ; date illisible = sans date", () => {
+  const kb = t.normalizeKanbante("https://kanbante.dracodev.net/", {
+    events: [{ id: 1, repo_full_name: "R", issue_number: 1, event_type: "moved", from_column: "todo", to_column: "review", created_at: "2026-10-28T12:00:00" }],
+  })[0];
+  assert.ok(!t.metaLine(kb).includes("moved"));
+  assert.match(t.metaLine(kb), /Kanbante · .* · Déplacée/);
+  assert.equal(t.displayState({ active: true }), "Active");
+  assert.equal(t.displayState({ active: false, app: "flowdeck" }), "Lue");
+  const sansDate = { app: "tiktak", active: true, title: "x", detail: "", date: "nimporte-quoi", kind: "", url: "https://x/" };
+  assert.match(t.metaLine(sansDate), /sans date/);
+});
+
+test("hash URL: parse + round-trip, onglet inconnu rejete", () => {
+  assert.equal(t.parseAlertTab("#alertes=historique"), "historique");
+  assert.equal(t.parseAlertTab("#alertes=console"), "console");
+  assert.equal(t.parseAlertTab("#alertes"), "tout");
+  assert.equal(t.parseAlertTab("#autre"), null);
+  assert.equal(t.parseAlertTab("#alertes=nimporte"), null);
+  assert.equal(t.parseAlertTab(""), null);
+  for (const tab of t.TABS) assert.equal(t.parseAlertTab(t.hashForTab(tab)), tab);
+  assert.equal(t.hashForTab("nimporte"), "#alertes=tout");
+});
+
+test("normalizeConsole (FORMAT EXEMPLE): statuts reels -> actif/ferme, lien console par defaut", () => {
+  const items = t.normalizeConsole("https://agent.dracodev.net/", {
+    alerts: [
+      { id: "m1", title: "Mission en pause budget", detail: "budget épuisé", status: "pause_budget", created_at: "2026-10-28T09:00:00" },
+      { id: "m2", title: "Accès requis", detail: "jeton manquant", status: "acces_requis", created_at: "2026-10-28T09:30:00" },
+      { id: "a1", title: "Approbation en attente", status: "en_attente", url: "/approbations", created_at: "2026-10-28T10:00:00" },
+      { id: "m3", title: "Mission terminée", status: "terminee", created_at: "2026-10-27T10:00:00" },
+      { id: "m4", title: "Sans statut", created_at: "2026-10-27T11:00:00" },
+    ],
+  });
+  assert.equal(items.length, 5);
+  assert.equal(items[0].active, true);
+  assert.equal(items[1].active, true);
+  assert.equal(items[2].active, true);
+  assert.equal(items[2].url, "https://agent.dracodev.net/approbations");
+  assert.equal(items[3].active, false);
+  assert.equal(items[4].active, true); // statut inconnu : expose en active, jamais masque
+  assert.equal(items[0].url, "https://agent.dracodev.net/");
+  const r = sampleResults();
+  r.console = { items };
+  const c = t.countByTab(allOf(r), r);
+  assert.equal(c.console, 4);
+  assert.equal(c.tout, 6);
+  assert.equal(c.historique, 5);
+});
+
+test("consoleSourceUrl: null sans configuration (aucune URL devineee)", () => {
+  assert.equal(t.consoleSourceUrl({}), null);
+  assert.equal(t.consoleSourceUrl({ consoleUrl: "https://agent-dev.dracodev.net/api/alertes" }),
+    "https://agent-dev.dracodev.net/api/alertes");
+});
@@ -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");
@@ -0,0 +1,227 @@
+"""Tests du client de distribution coffre ObsiGate (Phase 4, issue ObsiGate #22).
+
+Aucune instance ObsiGate réelle n'est contactée : le « faux endpoint » est
+un ``httpx.MockTransport`` local, et toutes les valeurs distribuées dans
+ces tests sont fictives (``TEST-VALUE-XXXX``), jamais des secrets réels.
+"""
+
+import hashlib
+import hmac
+import json
+
+import httpx
+import pytest
+
+import app.main as main
+from app import models
+from app.coffre_client import (
+    CoffreAccesRefuse,
+    CoffreConfig,
+    CoffreContexteManquant,
+    CoffreIndisponible,
+    CoffreNonConfigure,
+    CoffreReferenceInvalide,
+    distribuer,
+    distribuer_async,
+    est_reference,
+    parse_reference,
+    usage_distribue,
+)
+
+# Configuration fictive, réservée aux tests.
+CONFIG_TEST = CoffreConfig(
+    base_url="https://obsigate.test",
+    jeton_consommateur="TEST-CONSUMER-TOKEN",
+)
+REFERENCE_TEST = "coffre:TEST-SLUG/TEST-NOM"
+VALEUR_TEST = "TEST-VALUE-XXXX"
+
+
+def _transport_faux(statut=200, corps=None, verifier=None):
+    def handler(request: httpx.Request) -> httpx.Response:
+        if verifier is not None:
+            verifier(request)
+        return httpx.Response(statut, json=corps if corps is not None else {})
+
+    return httpx.MockTransport(handler)
+
+
+def _verifier_requete(request: httpx.Request):
+    assert request.url.path == "/api/coffres/distribuer"
+    assert request.headers["Authorization"] == "Bearer TEST-CONSUMER-TOKEN"
+    corps = json.loads(request.content.decode())
+    assert corps["reference"] == REFERENCE_TEST
+    assert corps["contexte_type"] == "webhook"
+    assert corps["contexte_id"] == "gitea"
+
+
+@pytest.mark.parametrize(
+    "reference, attendu",
+    [
+        ("coffre:personnel/gitea", True),
+        ("coffre:TEST-SLUG/TEST-NOM", True),
+        ("coffre:a/b/c", False),  # un seul « / » après le préfixe
+        ("coffre:/nom", False),
+        ("coffre:slug/", False),
+        ("coffre:slug", False),
+        ("gitea", False),
+        ("", False),
+        (None, False),
+    ],
+)
+def test_reference_validation(reference, attendu):
+    assert est_reference(reference) is attendu
+    if attendu:
+        assert parse_reference(reference)[0]
+    else:
+        with pytest.raises(CoffreReferenceInvalide):
+            parse_reference(reference or "")
+
+
+def test_distribuer_succes_sync():
+    transport = _transport_faux(
+        200,
+        {"reference": REFERENCE_TEST, "valeur": VALEUR_TEST, "version": 1},
+        verifier=_verifier_requete,
+    )
+    assert (
+        distribuer(REFERENCE_TEST, "webhook", "gitea", config=CONFIG_TEST, transport=transport)
+        == VALEUR_TEST
+    )
+
+
+async def test_distribuer_succes_async():
+    transport = _transport_faux(
+        200,
+        {"reference": REFERENCE_TEST, "valeur": VALEUR_TEST, "version": 1},
+        verifier=_verifier_requete,
+    )
+    assert (
+        await distribuer_async(
+            REFERENCE_TEST, "webhook", "gitea", config=CONFIG_TEST, transport=transport
+        )
+        == VALEUR_TEST
+    )
+
+
+@pytest.mark.parametrize(
+    "statut, detail, message_attendu",
+    [
+        (403, "octroi_revoque", "ré-accorder"),
+        (403, "octroi_expire", "renouveler"),
+        (403, "octroi_absent", "octroi"),
+        (401, "consommateur_revoque", "ré-accorder"),
+        (401, "consommateur_invalide", "invalide"),
+        (410, "secret_expire", "expiré"),
+    ],
+)
+def test_distribuer_refus_sans_repli(statut, detail, message_attendu):
+    transport = _transport_faux(statut, {"detail": detail})
+    with pytest.raises(CoffreAccesRefuse) as excinfo:
+        distribuer(REFERENCE_TEST, "webhook", "gitea", config=CONFIG_TEST, transport=transport)
+    assert message_attendu in str(excinfo.value)
+    assert VALEUR_TEST not in str(excinfo.value)
+
+
+def test_distribuer_indisponible_503_et_reseau():
+    transport = _transport_faux(503, {"detail": "kek_absente"})
+    with pytest.raises(CoffreIndisponible):
+        distribuer(REFERENCE_TEST, "webhook", "gitea", config=CONFIG_TEST, transport=transport)
+
+    def _panne(request: httpx.Request):
+        raise httpx.ConnectError("faux ObsiGate injoignable", request=request)
+
+    with pytest.raises(CoffreIndisponible):
+        distribuer(
+            REFERENCE_TEST, "webhook", "gitea",
+            config=CONFIG_TEST, transport=httpx.MockTransport(_panne),
+        )
+
+
+def test_distribuer_sans_valeur_malgre_200():
+    transport = _transport_faux(200, {"reference": REFERENCE_TEST})
+    with pytest.raises(CoffreIndisponible):
+        distribuer(REFERENCE_TEST, "webhook", "gitea", config=CONFIG_TEST, transport=transport)
+
+
+def test_distribuer_reference_invalide_sans_appel():
+    def _interdit(request: httpx.Request):
+        raise AssertionError("aucun appel HTTP ne doit partir")
+
+    with pytest.raises(CoffreReferenceInvalide):
+        distribuer("valeur-brute", "webhook", "gitea",
+                   config=CONFIG_TEST, transport=httpx.MockTransport(_interdit))
+
+
+def test_distribuer_contexte_manquant_sans_appel():
+    with pytest.raises(CoffreContexteManquant):
+        distribuer(REFERENCE_TEST, "", "gitea", config=CONFIG_TEST)
+
+
+def test_distribuer_non_configure(monkeypatch):
+    monkeypatch.delenv("KANBANTE_OBSIGATE_URL", raising=False)
+    monkeypatch.delenv("KANBANTE_COFFRE_CONSOMMATEUR_TOKEN", raising=False)
+    with pytest.raises(CoffreNonConfigure):
+        distribuer(REFERENCE_TEST, "webhook", "gitea")
+
+
+def test_usage_distribue_ne_conserve_que_le_resultat():
+    transport = _transport_faux(200, {"valeur": VALEUR_TEST})
+    # Le bloc ne sert qu'à l'usage : ici, dériver un HMAC, comme le ferait
+    # la vérification d'un webhook. Seul le résultat de l'usage est
+    # conservé après le bloc, jamais la valeur distribuée.
+    with usage_distribue(
+        REFERENCE_TEST, "webhook", "gitea",
+        config=CONFIG_TEST, transport=transport,
+    ) as valeur:
+        signature = hmac.new(valeur.encode(), b"corps-test", hashlib.sha256).hexdigest()
+    assert len(signature) == 64
+
+
+def test_webhook_reference_octroi_revoque_sans_repli(client, monkeypatch):
+    """Référence webhook + octroi révoqué -> 401 explicite, sans repli."""
+    models.create_connection(
+        "coffre-webhook", "gitea", "Coffre webhook", "https://gitea.test",
+        token_encrypted="", account_login="", webhook_secret=REFERENCE_TEST,
+    )
+
+    async def _refuse(*args, **kwargs):
+        raise CoffreAccesRefuse("Accès révoqué dans ObsiGate pour cette référence.")
+
+    monkeypatch.setattr(main.coffre_client, "distribuer_async", _refuse)
+    reponse = client.post(
+        "/webhooks/coffre-webhook",
+        content=b"{}",
+        headers={"x-gitea-signature": "0" * 64},
+    )
+    assert reponse.status_code == 401
+    assert "ObsiGate" in reponse.json()["error"]
+
+
+def test_webhook_reference_distribuee_puis_oubliee(client, monkeypatch):
+    """Référence webhook distribuée -> HMAC vérifié, valeur non persistée."""
+    models.create_connection(
+        "coffre-webhook-ok", "gitea", "Coffre webhook OK", "https://gitea.test",
+        token_encrypted="", account_login="", webhook_secret=REFERENCE_TEST,
+    )
+
+    async def _distribue(reference, contexte_type, contexte_id):
+        assert reference == REFERENCE_TEST
+        assert contexte_type == "webhook"
+        assert contexte_id == "coffre-webhook-ok"
+        return VALEUR_TEST
+
+    monkeypatch.setattr(main.coffre_client, "distribuer_async", _distribue)
+    corps = b"{}"
+    signature = hmac.new(VALEUR_TEST.encode(), corps, hashlib.sha256).hexdigest()
+    reponse = client.post(
+        "/webhooks/coffre-webhook-ok",
+        content=corps,
+        headers={"x-gitea-signature": signature},
+    )
+    assert reponse.status_code == 200
+    # La valeur distribuée n'a jamais été persistée : la ligne stocke
+    # toujours la référence, jamais la valeur fictive.
+    ligne = models.get_connection_by_slug("coffre-webhook-ok")
+    assert ligne["webhook_secret"] == REFERENCE_TEST
+    assert VALEUR_TEST not in (ligne["webhook_secret"] or "")
@@ -0,0 +1,70 @@
+"""Fusion #69 — Alertes unifiées (chantier 2 + chantier 5, Kanbante).
+
+Kanbante n'a pas de table de notifications : sa source réelle est le
+journal d'événements, déjà exposé par GET /api/events (aucun nouvel
+endpoint). Kanbante ne porte aucun état lu/non lu : ses événements
+sont donc tous de l'historique et ne sont jamais comptés comme
+actifs par le panneau. Couverts ici : placeholder disparu, module
+servi, CORS limité à /api/events pour les seules origines soeurs.
+"""
+
+SOEUR = "https://flowdeck.dracodev.net"
+
+
+def test_barre_alertes_sans_placeholder_et_module_servi(client):
+    r = client.get("/")
+    assert r.status_code == 200
+    assert "Alertes unifiées : arrive avec la fédération" not in r.text
+    assert "draco-alertes.js" in r.text
+    assert "draco-alertes.css" in r.text
+    js = client.get("/static/js/draco-alertes.js").text
+    assert "DRACO_ALERTES" in js
+    assert "api/events" in js
+
+
+def test_events_forme(client):
+    r = client.get("/api/events")
+    assert r.status_code == 200
+    body = r.json()
+    assert body["ok"] is True
+    assert isinstance(body["events"], list)
+
+
+def test_cors_events_soeur_preflight_get_et_tiers(client):
+    r = client.options("/api/events",
+                       headers={"Origin": SOEUR,
+                                "Access-Control-Request-Method": "GET"})
+    assert r.status_code == 200
+    assert r.headers.get("access-control-allow-origin") == SOEUR
+    assert r.headers.get("access-control-allow-credentials") == "true"
+    r2 = client.get("/api/events", headers={"Origin": SOEUR})
+    assert r2.status_code == 200
+    assert r2.headers.get("access-control-allow-origin") == SOEUR
+    r3 = client.options("/api/events",
+                        headers={"Origin": "https://evil.example",
+                                 "Access-Control-Request-Method": "GET"})
+    assert "access-control-allow-origin" not in r3.headers
+    # Correctif 2026-10-28 : une origine sœur dev passe aussi.
+    r4 = client.options("/api/events",
+                        headers={"Origin": "https://tiktak-dev.dracodev.net",
+                                 "Access-Control-Request-Method": "GET"})
+    assert r4.status_code == 200
+    assert r4.headers.get("access-control-allow-origin") == "https://tiktak-dev.dracodev.net"
+    assert r4.headers.get("access-control-allow-credentials") == "true"
+
+
+def test_chantier5_onglet_console_spark_et_alertes_onglets(client):
+    """Chantier 5 : onglet Console Spark en dernier dans la barre, et
+    vue Alertes en onglets (module + styles vendangés depuis commons)."""
+    r = client.get("/")
+    assert r.status_code == 200
+    nav = r.text.split('<nav class="draco-apptabs"')[1].split("</nav>")[0]
+    assert nav.index('data-app="kanbante"') < nav.index('data-app="agent"')
+    assert "Console Spark" in nav
+    js = client.get("/static/js/draco-alertes.js").text
+    assert "draco-alertes-tab" in js
+    assert "historique" in js
+    assert "source indisponible" in js
+    css = client.get("/static/css/draco-alertes.css").text
+    assert "draco-alertes-tab" in css
+    assert "draco-alertes-filtre" in css
@@ -15,10 +15,171 @@ def test_barre_presente_sur_le_dashboard(client):
    assert "draco-barre.css" in r.text
    assert "draco-barre.js" in r.text
    assert 'window.DRACO_BAR_CONFIG' in r.text
-    # Les quatre applications de la barre, aux URL publiques.
+    # Les quatre applications de la barre, aux URL publiques par
+    # défaut (noms officiels/prod, issus de la configuration).
    for url in ("https://og.dracodev.net/", "https://flowdeck.dracodev.net/",
                "https://tiktak.dracodev.net/", "https://kanbante.dracodev.net/"):
        assert url in r.text
+    # L'adresse du service d'agents est injectée au panneau.
+    assert 'window.DRACO_PANNEAU_CONFIG = { api: "https://agent.dracodev.net" }' in r.text
+
+
+def test_barre_et_panneau_urls_par_configuration(monkeypatch, fake_gitea):
+    # Dev/prod (0.32.0) : la dev déclare ses noms en -dev par
+    # l'environnement ; aucun nom public n'est codé en dur.
+    from fastapi.testclient import TestClient
+
+    import app.main as main
+
+    monkeypatch.setenv("DRACO_SSO_URL", "https://og-dev.dracodev.net")
+    monkeypatch.setenv("DRACO_FLOWDECK_URL", "https://flowdeck-dev.dracodev.net")
+    monkeypatch.setenv("DRACO_TIKTAK_URL", "https://tiktak-dev.dracodev.net")
+    monkeypatch.setenv("KANBANTE_PUBLIC_URL", "https://kanbante-dev.dracodev.net")
+    monkeypatch.setenv("AGENT_URL", "https://agent-dev.dracodev.net")
+    with TestClient(main.app) as client:
+        r = client.get("/")
+        assert r.status_code == 200
+        for url in ("https://og-dev.dracodev.net/",
+                    "https://flowdeck-dev.dracodev.net/",
+                    "https://tiktak-dev.dracodev.net/",
+                    "https://kanbante-dev.dracodev.net/"):
+            assert url in r.text
+        assert 'api: "https://agent-dev.dracodev.net"' in r.text
+        # Le JS statique du panneau ne contient aucun nom en dur :
+        # il lit l'adresse injectée par l'hôte.
+        js = client.get("/static/js/draco-panneau.js").text
+        assert "DRACO_PANNEAU_CONFIG" in js
+        assert "dracodev.net" not in js
+
+
+def test_config_agent_evenements_derive_de_agent_url(monkeypatch):
+    from app.config import _env_settings
+
+    monkeypatch.setenv("AGENT_URL", "https://agent-dev.dracodev.net")
+    monkeypatch.delenv("AGENT_EVENEMENTS_URL", raising=False)
+    s = _env_settings()
+    assert s.agent_url == "https://agent-dev.dracodev.net"
+    assert s.agent_evenements_url == (
+        "https://agent-dev.dracodev.net/api/v1/evenements"
+    )
+    # L'URL d'événements explicite garde la priorité (override compose).
+    monkeypatch.setenv(
+        "AGENT_EVENEMENTS_URL", "https://exemple.invalid/journal"
+    )
+    assert _env_settings().agent_evenements_url == (
+        "https://exemple.invalid/journal"
+    )
+
+
+# ── Dérivation d'environnement des URL sœurs (0.32.1) ──
+# Sur la dev, seul AGENT_EVENEMENTS_URL est posé : les URL sœurs
+# doivent suivre son suffixe (-dev) sans quatre variables de plus.
+_ENV_URLS_SOEURS = (
+    "DRACO_SSO_URL",  # ObsiGate (émettrice SSO)
+    "DRACO_FLOWDECK_URL",
+    "DRACO_TIKTAK_URL",
+    "KANBANTE_PUBLIC_URL",  # Kanbante elle-même
+    "AGENT_URL",
+)
+
+_DEFAUTS_OFFICIELS = (
+    "https://og.dracodev.net",
+    "https://flowdeck.dracodev.net",
+    "https://tiktak.dracodev.net",
+    "https://kanbante.dracodev.net",
+)
+
+_URLS_DEV = (
+    "https://og-dev.dracodev.net",
+    "https://flowdeck-dev.dracodev.net",
+    "https://tiktak-dev.dracodev.net",
+    "https://kanbante-dev.dracodev.net",
+)
+
+
+def _nettoyer_env_soeurs(monkeypatch):
+    for nom in _ENV_URLS_SOEURS:
+        monkeypatch.delenv(nom, raising=False)
+
+
+def _urls_soeurs(settings):
+    return (
+        settings.sso_url,
+        settings.flowdeck_url,
+        settings.tiktak_url,
+        settings.public_url,
+    )
+
+
+def test_config_urls_soeurs_derivees_du_seul_agent_evenements(monkeypatch):
+    from app.config import _env_settings
+
+    _nettoyer_env_soeurs(monkeypatch)
+    monkeypatch.setenv(
+        "AGENT_EVENEMENTS_URL",
+        "https://agent-dev.dracodev.net/api/v1/evenements",
+    )
+    assert _urls_soeurs(_env_settings()) == _URLS_DEV
+
+
+def test_barre_urls_soeurs_derivees_du_seul_agent_evenements(
+    monkeypatch, fake_gitea
+):
+    from fastapi.testclient import TestClient
+
+    import app.main as main
+
+    _nettoyer_env_soeurs(monkeypatch)
+    monkeypatch.setenv(
+        "AGENT_EVENEMENTS_URL",
+        "https://agent-dev.dracodev.net/api/v1/evenements",
+    )
+    with TestClient(main.app) as client:
+        r = client.get("/")
+        assert r.status_code == 200
+        for url in _URLS_DEV:
+            assert f"{url}/" in r.text
+
+
+def test_config_url_soeur_explicite_gagne_sur_la_derivation(monkeypatch):
+    from app.config import _env_settings
+
+    _nettoyer_env_soeurs(monkeypatch)
+    monkeypatch.setenv(
+        "AGENT_EVENEMENTS_URL",
+        "https://agent-dev.dracodev.net/api/v1/evenements",
+    )
+    monkeypatch.setenv(
+        "DRACO_FLOWDECK_URL", "https://flowdeck.example.test"
+    )
+    s = _env_settings()
+    assert s.flowdeck_url == "https://flowdeck.example.test"
+    # Les autres sœurs restent dérivées de l'environnement.
+    assert s.sso_url == "https://og-dev.dracodev.net"
+    assert s.tiktak_url == "https://tiktak-dev.dracodev.net"
+    assert s.public_url == "https://kanbante-dev.dracodev.net"
+
+
+def test_config_hote_agent_hors_motif_reste_aux_defauts(monkeypatch):
+    from app.config import _env_settings
+
+    _nettoyer_env_soeurs(monkeypatch)
+    for url_agent in (
+        "https://agent.example.com/api/v1/evenements",
+        "https://agent-dev.autre-domaine.net/api/v1/evenements",
+        "http://192.168.30.101:8790/api/v1/evenements",
+        "http://127.0.0.1:8790/api/v1/evenements",
+    ):
+        monkeypatch.setenv("AGENT_EVENEMENTS_URL", url_agent)
+        assert _urls_soeurs(_env_settings()) == _DEFAUTS_OFFICIELS
+
+
+def test_config_aucun_env_reste_aux_defauts_officiels(monkeypatch):
+    from app.config import _env_settings
+
+    _nettoyer_env_soeurs(monkeypatch)
+    monkeypatch.delenv("AGENT_EVENEMENTS_URL", raising=False)
+    assert _urls_soeurs(_env_settings()) == _DEFAUTS_OFFICIELS


 def test_statiques_de_la_barre_servis(client):
@@ -62,3 +223,200 @@ def test_pas_de_barre_sur_le_login(monkeypatch, fake_gitea):
        r = client.get("/login")
        assert r.status_code == 200
        assert "draco-bar" not in r.text
+
+
+# ── Résolution par requête et base de l'agent dérivée (0.32.2) ──
+# Couche fautive corrigée : la dérivation 0.32.1 ne couvrait que les
+# URL sœurs depuis AGENT_EVENEMENTS_URL — jamais agent_url, donc le
+# panneau visait le défaut prod (agent injoignable : la prod n'est
+# pas installée) et la console était une page morte sur la dev.
+# Aucune résolution ne tenait compte de l'hôte de la requête, et
+# aucune CSP n'énonçait l'origine de l'agent.
+_ENV_RESOLUTION = _ENV_URLS_SOEURS + ("AGENT_EVENEMENTS_URL",)
+
+
+def _nettoyer_env_resolution(monkeypatch):
+    for nom in _ENV_RESOLUTION:
+        monkeypatch.delenv(nom, raising=False)
+
+
+def test_config_base_agent_derivee_du_seul_agent_evenements(monkeypatch):
+    # Le cas réel de la dev : seul le journal est déclaré en -dev.
+    # La base du service (panneau/console) doit suivre, sinon
+    # l'iframe de la console charge l'agent prod, injoignable.
+    from app.config import _env_settings
+
+    _nettoyer_env_resolution(monkeypatch)
+    monkeypatch.setenv(
+        "AGENT_EVENEMENTS_URL",
+        "https://agent-dev.dracodev.net/api/v1/evenements",
+    )
+    s = _env_settings()
+    assert s.agent_url == "https://agent-dev.dracodev.net"
+    assert _urls_soeurs(s) == _URLS_DEV
+
+
+def test_config_derivation_elargie_a_la_base_du_service(monkeypatch):
+    # Élargie : si l'URL d'événements est hors motif mais que la
+    # base du service suit le motif, les sœurs dérivent de la base.
+    from app.config import _env_settings
+
+    _nettoyer_env_resolution(monkeypatch)
+    monkeypatch.setenv("AGENT_URL", "https://agent-dev.dracodev.net")
+    monkeypatch.setenv(
+        "AGENT_EVENEMENTS_URL", "https://journal.example.test/evenements"
+    )
+    s = _env_settings()
+    assert s.agent_url == "https://agent-dev.dracodev.net"
+    assert s.agent_evenements_url == (
+        "https://journal.example.test/evenements"
+    )
+    assert _urls_soeurs(s) == _URLS_DEV
+
+
+def test_suffixe_environnement_requete_motif_ferme():
+    from app.config import suffixe_environnement_requete
+
+    assert suffixe_environnement_requete("kanbante-dev.dracodev.net") == "-dev"
+    assert suffixe_environnement_requete("kanbante.dracodev.net") == ""
+    assert suffixe_environnement_requete("og-dev.dracodev.net") == "-dev"
+    assert suffixe_environnement_requete("agent-dev.dracodev.net:8790") == "-dev"
+    assert suffixe_environnement_requete("Kanbante-Dev.Dracodev.Net") == "-dev"
+    # Hors motif : jamais de suffixe inventé depuis un hôte arbitraire.
+    assert suffixe_environnement_requete("192.168.30.101:8082") is None
+    assert suffixe_environnement_requete("127.0.0.1") is None
+    assert suffixe_environnement_requete("kanbante-dev.autre-domaine.net") is None
+    assert suffixe_environnement_requete("dev.dracodev.net") is None
+    assert suffixe_environnement_requete("testserver") is None
+    assert suffixe_environnement_requete("") is None
+    assert suffixe_environnement_requete(None) is None
+
+
+def test_requete_hote_dev_sans_env_tout_en_dev(monkeypatch, fake_gitea):
+    # Aucune variable d'environnement : barre, panneau (source de
+    # l'iframe de la console) et CSP entièrement en -dev, cohérents.
+    from fastapi.testclient import TestClient
+
+    import app.main as main
+
+    _nettoyer_env_resolution(monkeypatch)
+    with TestClient(main.app) as client:
+        r = client.get("/", headers={"Host": "kanbante-dev.dracodev.net"})
+        assert r.status_code == 200
+        for url in _URLS_DEV:
+            assert f"{url}/" in r.text
+        # Source de l'iframe du panneau : l'origine injectée au JS.
+        assert 'api: "https://agent-dev.dracodev.net"' in r.text
+        # La CSP de la même réponse énonce la même origine résolue.
+        assert r.headers["content-security-policy"] == (
+            "frame-src 'self' https://agent-dev.dracodev.net"
+        )
+        # Aucun nom prod ne subsiste dans le rendu.
+        for url in _DEFAUTS_OFFICIELS:
+            assert f"{url}/" not in r.text
+        assert 'api: "https://agent.dracodev.net"' not in r.text
+
+
+def test_requete_hote_prod_sans_env_noms_officiels(monkeypatch, fake_gitea):
+    from fastapi.testclient import TestClient
+
+    import app.main as main
+
+    _nettoyer_env_resolution(monkeypatch)
+    with TestClient(main.app) as client:
+        r = client.get("/", headers={"Host": "kanbante.dracodev.net"})
+        assert r.status_code == 200
+        for url in _DEFAUTS_OFFICIELS:
+            assert f"{url}/" in r.text
+        assert 'api: "https://agent.dracodev.net"' in r.text
+        assert r.headers["content-security-policy"] == (
+            "frame-src 'self' https://agent.dracodev.net"
+        )
+
+
+def test_requete_hote_lan_repli_configuration(monkeypatch, fake_gitea):
+    # Hôte hors motif (LAN/IP) : repli sur la configuration, ici
+    # sans variable — donc les défauts officiels, jamais devinés.
+    from fastapi.testclient import TestClient
+
+    import app.main as main
+
+    _nettoyer_env_resolution(monkeypatch)
+    with TestClient(main.app) as client:
+        r = client.get("/", headers={"Host": "192.168.30.101:8082"})
+        assert r.status_code == 200
+        for url in _DEFAUTS_OFFICIELS:
+            assert f"{url}/" in r.text
+        assert 'api: "https://agent.dracodev.net"' in r.text
+        assert r.headers["content-security-policy"] == (
+            "frame-src 'self' https://agent.dracodev.net"
+        )
+
+
+def test_requete_hote_lan_repli_derivation_configuration(
+    monkeypatch, fake_gitea
+):
+    # Hôte hors motif mais configuration en -dev (journal seul) :
+    # le repli est la dérivation de configuration, panneau inclus.
+    from fastapi.testclient import TestClient
+
+    import app.main as main
+
+    _nettoyer_env_resolution(monkeypatch)
+    monkeypatch.setenv(
+        "AGENT_EVENEMENTS_URL",
+        "https://agent-dev.dracodev.net/api/v1/evenements",
+    )
+    with TestClient(main.app) as client:
+        r = client.get("/", headers={"Host": "192.168.30.101:8082"})
+        assert r.status_code == 200
+        for url in _URLS_DEV:
+            assert f"{url}/" in r.text
+        assert 'api: "https://agent-dev.dracodev.net"' in r.text
+        assert r.headers["content-security-policy"] == (
+            "frame-src 'self' https://agent-dev.dracodev.net"
+        )
+
+
+def test_requete_explicite_gagne_sur_hote(monkeypatch, fake_gitea):
+    # L'explicite reste prioritaire, URL par URL : Flowdeck et
+    # l'agent explicites gagnent sur l'hôte dev ; les autres
+    # sœurs suivent l'hôte.
+    from fastapi.testclient import TestClient
+
+    import app.main as main
+
+    _nettoyer_env_resolution(monkeypatch)
+    monkeypatch.setenv("DRACO_FLOWDECK_URL", "https://flowdeck.example.test")
+    monkeypatch.setenv("AGENT_URL", "https://agent.example.test")
+    with TestClient(main.app) as client:
+        r = client.get("/", headers={"Host": "kanbante-dev.dracodev.net"})
+        assert r.status_code == 200
+        assert "https://flowdeck.example.test/" in r.text
+        assert "https://flowdeck-dev.dracodev.net/" not in r.text
+        assert 'api: "https://agent.example.test"' in r.text
+        # La CSP consomme l'origine explicite, comme l'iframe.
+        assert r.headers["content-security-policy"] == (
+            "frame-src 'self' https://agent.example.test"
+        )
+        for url in (
+            "https://og-dev.dracodev.net/",
+            "https://tiktak-dev.dracodev.net/",
+            "https://kanbante-dev.dracodev.net/",
+        ):
+            assert url in r.text
+
+
+def test_resolution_sans_requete_inchangee(monkeypatch):
+    # Contextes sans requête : la résolution par configuration
+    # seule, comme avant (défauts officiels sans environnement).
+    from app.config import _env_settings, resoudre_urls_draco
+
+    _nettoyer_env_resolution(monkeypatch)
+    urls = resoudre_urls_draco()
+    assert urls.sso_url == "https://og.dracodev.net"
+    assert urls.flowdeck_url == "https://flowdeck.dracodev.net"
+    assert urls.tiktak_url == "https://tiktak.dracodev.net"
+    assert urls.public_url == "https://kanbante.dracodev.net"
+    assert urls.agent_url == "https://agent.dracodev.net"
+    assert _env_settings().agent_url == "https://agent.dracodev.net"
@@ -97,7 +97,20 @@ def test_pont_inerte_sans_secret(monkeypatch, fake_gitea):


 def test_bouton_sso_sur_la_page_login(client_sso):
+    # Défauts = noms officiels (DRACO_SSO_URL / KANBANTE_PUBLIC_URL).
    r = client_sso.get("/login")
    assert r.status_code == 200
    assert "og.dracodev.net/sso/authorize" in r.text
    assert "kanbante.dracodev.net%2Fauth%2Fdraco" in r.text
+
+
+def test_bouton_sso_par_configuration(client_sso, monkeypatch):
+    # Dev : l'émettrice et le return_to suivent l'environnement.
+    monkeypatch.setenv("DRACO_SSO_URL", "https://og-dev.dracodev.net")
+    monkeypatch.setenv(
+        "KANBANTE_PUBLIC_URL", "https://kanbante-dev.dracodev.net"
+    )
+    r = client_sso.get("/login")
+    assert r.status_code == 200
+    assert "og-dev.dracodev.net/sso/authorize" in r.text
+    assert "kanbante-dev.dracodev.net%2Fauth%2Fdraco" in r.text
@@ -1,9 +1,11 @@
-"""Écritures MCP minimales (0.26.0) : create_issue + add_comment.
+"""Écritures MCP minimales : create_issue + add_comment (0.26.0),
+move_issue (0.36.0).

-Le service d'agents doit pouvoir proposer des cartes et commenter
-via Kanbante, sans passer par l'interface web. Les deux outils
-réutilisent les services existants (création via _do_capture →
-client de forge, commentaire via client.create_comment) et sont
+Le service d'agents doit pouvoir proposer des cartes, commenter
+et déplacer des cartes via Kanbante, sans passer par l'interface
+web. Les trois outils réutilisent les services existants
+(création via _do_capture → client de forge, commentaire via
+client.create_comment, déplacement via _do_move_card) et sont
 gardés par la même authentification que les lectures /mcp :
 session, Basic ou jeton d'API kbt_ — jamais l'interface web.
 """
@@ -145,6 +147,131 @@ def test_mcp_write_tools_are_listed(client):
    )


+# ── Déplacement de carte (0.36.0) ──────────────────────────
+
+def _seed_carte_todo(fake_gitea, number=1):
+    """Place la carte dans « À faire », étiquette kanban:todo
+    miroir posée (la carte garde son étiquette « bug »)."""
+    etiquette = {"id": 950, "name": "kanban:todo", "color": "3b82f6"}
+    fake_gitea.repo_labels["Projets/demo"]["kanban:todo"] = etiquette
+    issue = next(
+        i for i in fake_gitea.issues["Projets/demo"]
+        if i["number"] == number
+    )
+    issue["labels"].append(etiquette)
+    models.move_issue("Projets/demo", number, "todo")
+    return issue
+
+
+def test_mcp_move_issue_moves_card_and_replaces_label(client, fake_gitea):
+    issue = _seed_carte_todo(fake_gitea)
+    r = _call(client, "move_issue", {
+        "owner": "Projets", "repo": "demo", "number": 1,
+        "column": "review",
+    })
+    result, text = _result_text(r)
+    assert result["isError"] is False
+    payload = json.loads(text)
+    assert payload["from_column"] == "todo"
+    assert payload["column"] == "review"
+    assert payload["label_sync"] == "ok"
+    # Étiquette kanban remplacée, les autres préservées.
+    noms = [l["name"] for l in issue["labels"]]
+    assert "kanban:review" in noms
+    assert "kanban:todo" not in noms
+    assert "bug" in noms
+    assert ("remove", 1, "kanban:todo") in fake_gitea.label_ops
+    assert ("add", 1, "kanban:review") in fake_gitea.label_ops
+    # Le board suit le déplacement (lecture MCP relue).
+    board = json.loads(_result_text(_call(
+        client, "get_board", {"owner": "Projets", "repo": "demo"}
+    ))[1])
+    assert any(c["number"] == 1 for c in board["review"])
+    assert not any(c["number"] == 1 for c in board["todo"])
+    # Journal : déplacement tracé avec la source « mcp ».
+    events = models.get_events(repo_full_name="Projets/demo", limit=10)
+    moved = [e for e in events if e["event_type"] == "moved"]
+    assert moved and moved[0]["source"] == "mcp"
+    assert moved[0]["from_column"] == "todo"
+    assert moved[0]["to_column"] == "review"
+
+
+def test_mcp_move_issue_accepts_french_labels(client, fake_gitea):
+    _seed_carte_todo(fake_gitea)
+    for libelle, cle in (
+        ("En cours", "in_progress"),
+        ("Révision", "review"),
+        ("kanban:qa", "qa"),
+        ("À faire", "todo"),
+    ):
+        r = _call(client, "move_issue", {
+            "owner": "Projets", "repo": "demo", "number": 1,
+            "column": libelle,
+        })
+        result, text = _result_text(r)
+        assert result["isError"] is False, (libelle, text)
+        assert json.loads(text)["column"] == cle
+
+
+def test_mcp_move_issue_refuses_done_before_any_write(client, fake_gitea):
+    _seed_carte_todo(fake_gitea)
+    for libelle in ("done", "Terminé"):
+        r = _call(client, "move_issue", {
+            "owner": "Projets", "repo": "demo", "number": 1,
+            "column": libelle,
+        })
+        result, text = _result_text(r)
+        assert result["isError"] is True
+        assert "Terminé" in text
+    # Aucune écriture : ni étiquette, ni état, ni journal.
+    assert fake_gitea.label_ops == []
+    assert fake_gitea.state_changes == []
+    events = models.get_events(repo_full_name="Projets/demo", limit=10)
+    assert not [e for e in events if e["event_type"] == "moved"]
+
+
+def test_mcp_move_issue_errors(client, fake_gitea):
+    # Colonne inconnue : erreur propre, avec les colonnes valides.
+    r = _call(client, "move_issue", {
+        "owner": "Projets", "repo": "demo", "number": 1,
+        "column": "nimporte",
+    })
+    result, text = _result_text(r)
+    assert result["isError"] is True
+    assert "Colonnes valides" in text and "review" in text
+    # Issue inconnue, puis dépôt inconnu.
+    for arguments in (
+        {"owner": "Projets", "repo": "demo", "number": 999,
+         "column": "review"},
+        {"owner": "Projets", "repo": "inexistant", "number": 1,
+         "column": "review"},
+    ):
+        result, text = _result_text(_call(client, "move_issue", arguments))
+        assert result["isError"] is True
+        assert "inconnu" in text
+    # Une pull request n'est pas une carte.
+    r = _call(client, "move_issue", {
+        "owner": "Projets", "repo": "demo", "number": 2,
+        "column": "review",
+    })
+    result, text = _result_text(r)
+    assert result["isError"] is True
+    assert "pull request" in text
+    assert fake_gitea.label_ops == []
+
+
+def test_mcp_move_issue_is_listed(client):
+    r = client.post("/mcp", json={
+        "jsonrpc": "2.0", "id": 1, "method": "tools/list",
+    })
+    tools = {t["name"]: t for t in r.json()["result"]["tools"]}
+    assert tools["move_issue"]["inputSchema"]["required"] == [
+        "owner", "repo", "number", "column",
+    ]
+    info = client.get("/mcp").json()
+    assert "move_issue" in info["write_tools"]
+
+
 # ── Garde par jeton kbt_ (auth active) ─────────────────────

@pytest.fixture()
@@ -97,11 +97,15 @@ def test_metrics_counts_and_cycle_time():


 def test_column_entry_times_ignores_comments():
+    # Capturer l'horodatage UNE fois : _days_ago() réévalué à
+    # l'assertion basculait d'une seconde une fois sur ~N
+    # (échec CI 2333 du 2026-10-26, run jumeau vert).
+    entry = _days_ago(3)
    models.log_event("a/b", 1, "moved", to_column="todo",
-                     created_at=_days_ago(3))
+                     created_at=entry)
    models.log_event("a/b", 1, "commented", created_at=_days_ago(0))
    times = models.column_entry_times("a/b")
-    assert times[1] == _days_ago(3)
+    assert times[1] == entry


 # ── Panneau détail ─────────────────────────────────────────
@@ -95,9 +95,11 @@ def test_board_page_has_editor_and_assets_ui(client, fake_gitea):
    assert 'id="detail-edit-form"' in page.text
    assert 'id="detail-assets"' in page.text
    assert 'id="asset-form"' in page.text
-    # Création avec description dépliable.
+    # Création avec description dépliable (0.31.1 : <details>
+    # natif plutôt qu'un bouton piloté en JS).
    assert 'id="new-issue-body"' in page.text
-    assert 'id="new-issue-desc-toggle"' in page.text
+    assert 'id="new-issue-desc"' in page.text
+    assert 'class="composer"' in page.text


 async def test_gitea_download_follows_browser_download_url():
@@ -0,0 +1,39 @@
+"""Palier 22 (0.33.0): barre de filtres de la page Mes issues —
+facettes serveur, lignes annotées, moteur client chargé."""
+
+
+def test_my_page_has_filter_bar_and_facets(client):
+    r = client.get("/my")
+    assert r.status_code == 200
+    # La barre et ses contrôles.
+    assert 'id="my-filters"' in r.text
+    assert 'id="my-search"' in r.text
+    assert 'id="my-repo"' in r.text
+    assert 'id="my-label"' in r.text
+    assert 'id="my-sort"' in r.text
+    assert 'id="my-col-chips"' in r.text
+    assert 'id="my-count"' in r.text
+    assert 'id="my-reset"' in r.text
+    # Facettes avec compteurs (démo : 1 issue assignée,
+    # étiquette « bug »).
+    assert "Projets/demo (1)" in r.text
+    assert "bug (1)" in r.text
+    # Le moteur de filtrage est chargé, versionné.
+    assert "/static/js/my.js?v=" in r.text
+
+
+def test_my_rows_carry_filter_attributes(client):
+    r = client.get("/my")
+    # Attributs data-* consommés par le moteur client.
+    assert 'data-column="backlog"' in r.text
+    assert 'data-search="#1 Tâche un Projets/demo bug"' in r.text
+    assert 'data-updated="2026-09-02T09:00:00Z"' in r.text
+    assert 'data-repo="Projets/demo"' in r.text
+    # Chips de colonnes présentes, avec compteurs.
+    assert 'data-col="backlog"' in r.text
+    assert 'data-col=""' in r.text  # « Toutes les colonnes »
+
+
+def test_my_empty_state_present_but_hidden(client):
+    r = client.get("/my")
+    assert 'id="my-empty" hidden' in r.text
@@ -0,0 +1,72 @@
+"""Palier 23 (0.34.0, issue #24): vue « En vol partout » —
+l'encours tous projets, regroupé par colonne, plus vieilles
+cartes d'abord."""
+
+from datetime import datetime, timedelta, timezone
+
+from app import models
+
+
+def _days_ago(days: int) -> str:
+    return (datetime.now(timezone.utc) - timedelta(days=days)).strftime(
+        "%Y-%m-%d %H:%M:%S"
+    )
+
+
+def test_inflight_groups_by_column_with_project(client):
+    models.move_issue("Projets/demo", 5, "in_progress")
+    models.move_issue("Projets/demo", 1, "review")
+    r = client.get("/inflight")
+    assert r.status_code == 200
+    assert "2 cartes en vol" in r.text
+    assert "Tâche focus" in r.text
+    assert "Tâche un" in r.text
+    # Le projet est indiqué sur la carte.
+    assert "Projets/demo" in r.text
+    # Groupes par colonne, pas par projet.
+    assert "🚧 En cours" in r.text
+    assert "🔍 Révision" in r.text
+    # L'âge dans la colonne est affiché.
+    assert "dans la colonne" in r.text
+
+
+def test_inflight_excludes_backlog_and_todo(client):
+    models.move_issue("Projets/demo", 5, "todo")
+    r = client.get("/inflight")
+    assert r.status_code == 200
+    assert "Tâche focus" not in r.text
+    assert "Rien en vol" in r.text
+
+
+def test_inflight_oldest_first(client):
+    # Deux cartes en cours : entrée il y a 10 j et il y a 2 j.
+    models.move_issue("Projets/demo", 5, "in_progress")
+    models.move_issue("Projets/demo", 1, "in_progress")
+    models.log_event(
+        "Projets/demo", 5, "moved", to_column="in_progress",
+        created_at=_days_ago(10),
+    )
+    models.log_event(
+        "Projets/demo", 1, "moved", to_column="in_progress",
+        created_at=_days_ago(2),
+    )
+    r = client.get("/inflight")
+    assert r.status_code == 200
+    assert r.text.index("Tâche focus") < r.text.index("Tâche un")
+
+
+def test_inflight_closed_issue_disappears(client, fake_gitea):
+    models.move_issue("Projets/demo", 5, "in_progress")
+    issue = next(
+        i for i in fake_gitea.issues["Projets/demo"] if i["number"] == 5
+    )
+    issue["state"] = "closed"
+    r = client.get("/inflight")
+    assert r.status_code == 200
+    assert "Tâche focus" not in r.text
+
+
+def test_inflight_nav_and_page_chrome(client):
+    r = client.get("/inflight")
+    assert 'href="/inflight"' in r.text  # menu latéral Pilotage
+    assert "En vol partout" in r.text
@@ -0,0 +1,77 @@
+"""Palier 24 (0.35.0, issue #26): jalons en écriture —
+créer, modifier (titre/échéance), fermer, depuis Kanbante."""
+
+from tests.conftest import csrf_from
+
+
+def test_milestone_create_via_api(client, fake_gitea):
+    token = csrf_from(client)
+    r = client.post(
+        "/api/repos/Projets/demo/milestones",
+        data={
+            "title": "Version 2.0",
+            "description": "Le gros morceau",
+            "due_on": "2027-01-31",
+            "csrf_token": token,
+        },
+    )
+    assert r.status_code == 201
+    payload = r.json()
+    assert payload["ok"] is True
+    assert payload["milestone"]["title"] == "Version 2.0"
+    assert payload["milestone"]["due_on"] == "2027-01-31T12:00:00Z"
+    titles = [
+        m["title"] for m in fake_gitea._milestones["Projets/demo"]
+    ]
+    assert "Version 2.0" in titles
+
+
+def test_milestone_create_rejects_bad_date(client, fake_gitea):
+    token = csrf_from(client)
+    avant = len(fake_gitea._milestones["Projets/demo"])
+    r = client.post(
+        "/api/repos/Projets/demo/milestones",
+        data={
+            "title": "Jalon invalide",
+            "due_on": "31/01/2027",
+            "csrf_token": token,
+        },
+    )
+    assert r.status_code == 400
+    # Rien d'écrit côté forge.
+    assert len(fake_gitea._milestones["Projets/demo"]) == avant
+
+
+def test_milestone_update_title_and_clear_due(client, fake_gitea):
+    token = csrf_from(client)
+    r = client.post(
+        "/api/repos/Projets/demo/milestones/1/update",
+        data={"title": "Sprint 1 — prolongé", "due_on": "", "csrf_token": token},
+    )
+    assert r.status_code == 200
+    sprint = fake_gitea._milestones["Projets/demo"][0]
+    assert sprint["title"] == "Sprint 1 — prolongé"
+    assert sprint["due_on"] is None  # échéance retirée
+
+
+def test_milestone_close(client, fake_gitea):
+    token = csrf_from(client)
+    r = client.post(
+        "/api/repos/Projets/demo/milestones/1/close",
+        data={"csrf_token": token},
+    )
+    assert r.status_code == 200
+    assert fake_gitea._milestones["Projets/demo"][0]["state"] == "closed"
+    # La page Projet ne liste plus le jalon fermé parmi les ouverts.
+    page = client.get("/project/Projets/demo")
+    assert "Version" in page.text  # la page répond toujours
+    assert 'data-action="/api/repos/Projets/demo/milestones"' in page.text
+
+
+def test_project_page_has_milestone_management(client):
+    page = client.get("/project/Projets/demo")
+    assert page.status_code == 200
+    assert "Nouveau jalon" in page.text
+    assert "Modifier / fermer" in page.text
+    assert 'name="due_on"' in page.text
+    assert "/static/js/project.js?v=" in page.text
@@ -0,0 +1,36 @@
+"""Palier 25 (0.37.0): tri « En attente de revue » du dashboard —
+les projets (section Épinglés incluse) s'ordonnent par le nombre
+de cartes dans la colonne de validation."""
+
+from app import models
+
+
+def test_dashboard_sort_offers_review_mode(client):
+    r = client.get("/")
+    assert r.status_code == 200
+    assert '<option value="review">🔍 En attente de revue ↓</option>' in r.text
+
+
+def test_dashboard_cards_carry_review_count(client):
+    # Aucune carte en révision au départ.
+    r = client.get("/")
+    assert 'data-review="0"' in r.text
+    # Une carte passe en Révision : le compteur de SA carte monte.
+    models.move_issue("Projets/demo", 5, "review")
+    models.move_issue("Projets/demo", 1, "review")
+    r = client.get("/")
+    assert 'data-review="2"' in r.text
+
+
+def test_dashboard_js_knows_review_mode(client):
+    # Le moteur de tri partagé est servi tel quel : le mode
+    # 'review' doit y figurer (tri décroissant sur data-review).
+    r = client.get("/static/js/dashboard.js")
+    assert r.status_code == 200
+    assert "mode === 'review'" in r.text
+    assert "data-review" in r.text
+    # Le sens : les modes numeriques trient en ka - kb (cles
+    # niees = plus grand compteur d\'abord). Sans cette
+    # branche, le comparateur generique inversait le tri :
+    # bug attrape en navigateur reel sur le tri historique.
+    assert "return ka - kb" in r.text
@@ -121,7 +121,7 @@ def test_mcp_initialize_and_tools_list(client):
    assert names == [
        "list_projects", "get_board", "get_issue", "get_focus",
        "search_issues", "get_activity", "get_metrics",
-        "create_issue", "add_comment",
+        "create_issue", "add_comment", "move_issue",
    ]


@@ -167,8 +167,11 @@ def test_mcp_info_endpoint(client):
    assert r.status_code == 200
    # 0.26.0 : écritures minimales ajoutées — le serveur n'est
    # plus en lecture seule, et il le déclare honnêtement.
+    # 0.36.0 : move_issue s'ajoute aux écritures déclarées.
    assert r.json()["read_only"] is False
-    assert r.json()["write_tools"] == ["create_issue", "add_comment"]
+    assert r.json()["write_tools"] == [
+        "create_issue", "add_comment", "move_issue",
+    ]


 # ── Board : gestion des étiquettes ────────────────────────
@@ -0,0 +1,109 @@
+"""Tests de la recherche fédérée Kanbante (fusion #68).
+
+Fonctions pures de app/recherche.py uniquement : aucune base, aucun
+serveur, aucune forge.
+"""
+
+from app.recherche import (
+    cors_headers_for,
+    groupes_vers_json,
+    is_dev_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/",
+}
+
+
+def test_is_dev_host():
+    assert is_dev_host("kanbante-dev.dracodev.net") is True
+    assert is_dev_host("kanbante.dracodev.net") is False
+    assert is_dev_host("x-dev.dracodev.net.evil") is False
+    assert is_dev_host(None) 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():
+    # Correctif 2026-10-28 : 8 origines officielles, prod ET dev,
+    # quelle que soit la résolution.
+    assert sister_origins(RESOLVED_DEV) == {
+        "https://og.dracodev.net",
+        "https://flowdeck.dracodev.net",
+        "https://tiktak.dracodev.net",
+        "https://kanbante.dracodev.net",
+        "https://og-dev.dracodev.net",
+        "https://flowdeck-dev.dracodev.net",
+        "https://tiktak-dev.dracodev.net",
+        "https://kanbante-dev.dracodev.net",
+    }
+
+
+def test_cors_headers():
+    headers = cors_headers_for("https://tiktak-dev.dracodev.net", RESOLVED_DEV)
+    assert headers["Access-Control-Allow-Origin"] == "https://tiktak-dev.dracodev.net"
+    assert headers["Access-Control-Allow-Credentials"] == "true"
+    assert cors_headers_for("https://evil.example", RESOLVED_DEV) is None
+    assert cors_headers_for("https://og-dev.dracodev.net.evil.example",
+                            RESOLVED_DEV) is None
+    # Autre environnement autorisé (correctif 2026-10-28).
+    assert cors_headers_for("https://og.dracodev.net",
+                            RESOLVED_DEV) is not None
+
+
+def test_preflight_headers():
+    headers = preflight_headers("https://og-dev.dracodev.net", RESOLVED_DEV)
+    assert headers["Access-Control-Allow-Methods"] == "GET, OPTIONS"
+    assert preflight_headers("https://evil.example", RESOLVED_DEV) is None
+
+
+def test_groupes_vers_json_tronque_et_filtre():
+    groups = [{
+        "full_name": "Projets/site",
+        "rows": [
+            {"issue": {"number": 12, "title": "Bug", "state": "open",
+                        "body": "x" * 500, "labels": [{"name": "bug", "color": "ff0000"}],
+                        "token_secret": "ne-doit-pas-sortir"},
+             "column": "in_progress"},
+            {"issue": {"number": 13, "title": "Autre", "state": "closed",
+                        "body": "", "labels": []},
+             "column": "done"},
+        ],
+    }]
+    data, total = groupes_vers_json(groups, limit=1)
+    assert total == 1
+    assert len(data[0]["rows"]) == 1
+    row = data[0]["rows"][0]
+    assert row["issue"]["number"] == 12
+    assert len(row["issue"]["body"]) == 160
+    assert "token_secret" not in row["issue"]
+    assert row["issue"]["labels"] == [{"name": "bug", "color": "ff0000"}]
+    assert row["column"] == "in_progress"
+
+
+def test_groupes_vers_json_vide():
+    assert groupes_vers_json([], limit=20) == ([], 0)
+    assert groupes_vers_json(None, limit=20) == ([], 0)
+
+
+def test_sister_origins_hote_requete():
+    # Correctif 2026-10-28 : configuration muette, quel que soit
+    # l'hôte de la requête, prod ET dev passent.
+    assert "https://og-dev.dracodev.net" in sister_origins(
+        {}, request_host="kanbante-dev.dracodev.net"
+    )
+    assert "https://og.dracodev.net" in sister_origins(
+        {}, request_host="kanbante-dev.dracodev.net"
+    )
+    assert "https://og-dev.dracodev.net" in sister_origins(
+        {}, request_host="kanbante.dracodev.net"
+    )
Author	SHA1	Message	Date
bruno	fb61169c23	Rebase chantier 5 sur main post-#37/#38 : tests/test_draco_alertes.py (contenu #39 intact) CI / test (push) Failing after 0s Details CI / test (pull_request) Failing after 1s Details	2026-10-28 14:27:38 -04:00
bruno	16403821de	Rebase chantier 5 sur main post-#37/#38 : tests/draco-alertes.test.js (contenu #39 intact) CI / test (push) Failing after 1s Details	2026-10-28 14:27:35 -04:00
bruno	49bf9b32bf	Rebase chantier 5 sur main post-#37/#38 : static/js/draco-barre.js (contenu #39 intact) CI / test (push) Failing after 0s Details	2026-10-28 14:27:32 -04:00
bruno	53d1d2c29d	Rebase chantier 5 sur main post-#37/#38 : static/js/draco-alertes.js (contenu #39 intact) CI / test (push) Failing after 0s Details	2026-10-28 14:27:29 -04:00
bruno	e723366755	Rebase chantier 5 sur main post-#37/#38 : static/css/draco-barre.css (contenu #39 intact) CI / test (push) Failing after 1s Details	2026-10-28 14:27:27 -04:00
bruno	fc70d125d4	Rebase chantier 5 sur main post-#37/#38 : static/css/draco-alertes.css (contenu #39 intact) CI / test (push) Failing after 0s Details	2026-10-28 14:27:24 -04:00
bruno	0336f19f0f	Rebase chantier 5 sur main post-#37/#38 : _draco_bar.html (contenu #39 intact) CI / test (push) Failing after 0s Details	2026-10-28 14:27:18 -04:00
bruno	8f437e3a3e	Merge pull request 'Recherche partout (#68 , chantier 2+3) : onglets, Tout voir sur place, focus, mise en page' (#38 ) from recherche-onglets-ux-68 into main CI / test (push) Failing after 0s Details	2026-10-28 14:25:40 -04:00
bruno	00676834e8	Merge pull request 'CORS recherche/alertes : allowlist soeurs prod+dev explicites (fusion #68/#69)' (#37 ) from cors-recherche-alertes-68-69 into main CI / test (push) Failing after 1s Details	2026-10-28 14:25:24 -04:00
bruno	0e78ae3c60	Recherche partout (#68 , chantier 2+3) : onglets, Tout voir sur place, focus, mise en page CI / test (push) Failing after 0s Details CI / test (pull_request) Failing after 0s Details	2026-10-28 13:49:44 -04:00
bruno	b72d2607a8	Recherche partout (#68 , chantier 2+3) : onglets, Tout voir sur place, focus, mise en page CI / test (push) Failing after 0s Details	2026-10-28 13:49:42 -04:00
bruno	2235d0be02	Recherche partout (#68 , chantier 2+3) : onglets, Tout voir sur place, focus, mise en page CI / test (push) Failing after 0s Details	2026-10-28 13:49:38 -04:00
bruno	699600eda3	Recherche partout (#68 , chantier 2+3) : onglets, Tout voir sur place, focus, mise en page CI / test (push) Failing after 1s Details	2026-10-28 13:49:35 -04:00
bruno	3c4bbbf2f1	Tests CORS alertes : origine dev autorisee en preflight CI / test (push) Failing after 1s Details CI / test (pull_request) Failing after 0s Details	2026-10-28 13:45:35 -04:00
bruno	7556cd0bee	Tests CORS recherche : prod+dev autorises, tiers refuse CI / test (push) Failing after 1s Details	2026-10-28 13:45:33 -04:00
bruno	aa98eb6866	CORS alertes (fusion #69 ) : allowlist /api/events prod+dev CI / test (push) Failing after 0s Details	2026-10-28 13:45:30 -04:00
bruno	409e67d57b	CORS recherche/alertes (fusion #68/#69) : allowlist soeurs prod+dev explicites CI / test (push) Failing after 3m51s Details	2026-10-28 13:45:27 -04:00
bruno	1234429a46	Bump 0.37.3 (programme Fusion #68/#69/#70) CI / test (push) Failing after 1s Details	2026-10-28 13:00:18 -04:00
bruno	f7a0597575	Bump 0.37.3 (programme Fusion #68/#69/#70) CI / test (push) Failing after 0s Details	2026-10-28 13:00:13 -04:00
bruno	e89f7903e1	Merge pull request 'Fusion #69 : Alertes unifiées (panneau + pastille, agrégation à la demande)' (#36 ) from alertes-unifiees-69-rebase into main CI / test (push) Failing after 0s Details	2026-10-28 12:47:35 -04:00
bruno	938f8b5eb5	Fusion #69 : alertes unifiées (rebase sur main post-#70 et post-#68) CI / test (push) Failing after 1s Details CI / test (pull_request) Failing after 1s Details	2026-10-28 12:47:12 -04:00
bruno	5f365b4b9f	Fusion #69 : alertes unifiées (rebase sur main post-#70 et post-#68) CI / test (push) Failing after 0s Details	2026-10-28 12:47:09 -04:00
bruno	d867fbffbf	Fusion #69 : alertes unifiées (rebase sur main post-#70 et post-#68) CI / test (push) Failing after 1s Details	2026-10-28 12:47:06 -04:00
bruno	b90941111a	Fusion #69 : alertes unifiées (rebase sur main post-#70 et post-#68) CI / test (push) Failing after 0s Details	2026-10-28 12:47:03 -04:00
bruno	35f1cccd03	Fusion #69 : alertes unifiées (rebase sur main post-#70 et post-#68) CI / test (push) Failing after 3m45s Details	2026-10-28 12:46:59 -04:00
bruno	f29a640d9a	Fusion #69 : alertes unifiées (rebase sur main post-#70 et post-#68) CI / test (push) Failing after 1s Details	2026-10-28 12:46:55 -04:00
bruno	cf98880fc8	Merge pull request 'Recherche partout (#68 ) : page de résultats unifiée + endpoint JSON /api/search' (#35 ) from recherche-partout-68 into main CI / test (push) Failing after 2s Details	2026-10-28 12:40:46 -04:00
bruno	6e86b09327	Merge pull request 'fusion #70 : retirer le bouton trois points, Console Spark au menu marque' (#33 ) from fusion-70-barre-console-spark into main CI / test (push) Failing after 0s Details	2026-10-28 12:39:54 -04:00
bruno	d41a79a9ed	Recherche partout (#68 ) : JS compatible ESM (test ObsiGate) CI / test (push) Failing after 1s Details CI / test (pull_request) Failing after 3s Details	2026-10-28 12:18:15 -04:00
bruno	725f78cb68	Recherche partout (#68 ) : test hôte de la requête CI / test (push) Failing after 1s Details CI / test (pull_request) Failing after 1s Details	2026-10-28 12:13:08 -04:00
bruno	39750851b0	Recherche partout (#68 ) : CORS résolue avec l'hôte de la requête (ordre middlewares) CI / test (push) Failing after 1s Details CI / test (pull_request) Failing after 0s Details	2026-10-28 12:13:03 -04:00
bruno	b2d2fd1eee	Recherche partout (#68 ) : palette de la barre -> /recherche CI / test (push) Successful in 3m50s Details CI / test (pull_request) Successful in 4m0s Details	2026-10-28 12:08:18 -04:00
bruno	0de3b65869	Recherche partout (#68 ) : routes /recherche + /api/search, draco sur /api/search, CORS bornée CI / test (push) Failing after 1s Details	2026-10-28 12:08:14 -04:00
bruno	903616a8cd	Recherche partout (#68 ) : tests Node du JS CI / test (push) Failing after 2s Details	2026-10-28 12:07:59 -04:00
bruno	e5282079b8	Recherche partout (#68 ) : tests module recherche CI / test (push) Failing after 1s Details	2026-10-28 12:07:45 -04:00
bruno	a30fa9d8f3	Recherche partout (#68 ) : JSON de recherche + CORS bornée CI / test (push) Failing after 1s Details	2026-10-28 12:07:41 -04:00
bruno	61f299305a	Recherche partout (#68 ) : gabarit de la page CI / test (push) Failing after 3s Details	2026-10-28 12:07:39 -04:00
bruno	ecf7f09fc5	Recherche partout (#68 ) : styles de la page CI / test (push) Failing after 0s Details	2026-10-28 12:07:35 -04:00
bruno	9772ecdcf6	Recherche partout (#68 ) : page de résultats unifiée — JS client CI / test (push) Failing after 1s Details	2026-10-28 12:07:31 -04:00
bruno	f503331773	fusion #70 : vendanger CSS sans menu trois points CI / test (push) Failing after 1s Details CI / test (pull_request) Failing after 0s Details	2026-10-28 12:02:07 -04:00
bruno	c75ef7764f	fusion #70 : vendanger barre sans trois points, Console Spark, fermeture/focus corriges CI / test (push) Failing after 2s Details	2026-10-28 12:02:01 -04:00
bruno	961556fb78	fusion #70 : retirer le bouton trois points et la branche menu morte CI / test (push) Failing after 11m13s Details	2026-10-28 12:01:57 -04:00
bruno	7a68606aa7	Bump 0.37.2 (CHANGELOG.md) CI / test (push) Failing after 2s Details	2026-10-28 10:37:42 -04:00
bruno	8015d22a06	Bump 0.37.2 (app/config.py) CI / test (push) Failing after 0s Details	2026-10-28 10:37:39 -04:00
bruno	39b5fd88f9	Merge pull request 'barre-apps v0.1.6 : vendange (dérivation -dev, menu •••, avatar compte)' (#32 ) from barre-apps-v0.1.6-kanbante into main CI / test (push) Failing after 1s Details	2026-10-28 10:34:14 -04:00
bruno	f5b007f286	barre-apps v0.1.6 : CSS vendange (menus, avatar bouton) CI / test (push) Failing after 1s Details CI / test (pull_request) Failing after 1s Details	2026-10-28 10:31:27 -04:00
bruno	2b9b852308	barre-apps v0.1.6 : JS vendange (derivation -dev, menus) CI / test (push) Failing after 2s Details	2026-10-28 10:31:23 -04:00
bruno	d3886b6bf5	barre-apps v0.1.6 : fragment (avatar bouton compte, menu par defaut demande, cfg.user initiale) CI / test (push) Failing after 1s Details	2026-10-28 10:31:19 -04:00
bruno	671ee68c96	Merge pull request '[Coffre Secrets] Secret webhook par reference ObsiGate (Phase 4)' (#31 ) from feat/coffre-reference-obsigate into main CI / test (push) Successful in 3m50s Details	2026-10-28 00:15:20 -04:00
bruno	c46d6dc519	coffre(obsigate#22): webhook distribue le secret reference a chaque appel, sans repli; validation reference admin CI / test (push) Failing after 0s Details CI / test (pull_request) Failing after 1s Details	2026-10-27 23:52:37 -04:00
bruno	4184ba0272	coffre(obsigate#22): formulaire admin accepte une reference coffre pour le secret webhook CI / test (push) Failing after 1s Details	2026-10-27 23:52:34 -04:00
bruno	751e2f4f44	coffre(obsigate#22): documentation inventaire, migration webhook, limites CI / test (push) Failing after 1s Details	2026-10-27 23:52:28 -04:00
bruno	975aff33a5	coffre(obsigate#22): tests client de distribution (faux endpoint, valeurs fictives) CI / test (push) Failing after 1s Details	2026-10-27 23:52:25 -04:00
bruno	003e44f55e	coffre(obsigate#22): client de distribution generique (reference, contexte, sans cache ni log de valeur) CI / test (push) Failing after 1s Details	2026-10-27 23:52:19 -04:00
Spark	53f54b1b79	feat(0.37.1): version du service d'agents visible dans le panneau Spark (mode sidebar) — fusion #64 CI / test (push) Failing after 1s Details	2026-10-26 16:49:25 +00:00
Spark	80fc260a40	feat(0.37.0): tri dashboard « En attente de revue » + sens des tris numériques corrigé CI / test (push) Successful in 2m27s Details - Nouveau critère 🔍 En attente de revue ↓ (compteur de la colonne review exposé en data-review sur les cartes) ; s'applique à toutes les grilles, Épinglés en tête, préférence mémorisée comme les autres tris. - Correctif attrapé au contrôle navigateur réel : le tri « Issues ouvertes ↓ » historique triait croissant — le comparateur inversait les clés numériques. Modes open et review en ka - kb : plus grand compteur en premier. Vérifié sur données réelles (Épinglés : 196, 95, 32, 5, 4). - 299 tests verts (3 nouveaux, palier 25).	2026-10-26 11:19:53 -04:00
Spark	8ad3a86e60	feat(0.36.0): outil MCP move_issue — déplacement de carte par le service d'agents CI / test (push) Failing after 1m27s Details Le serveur MCP n'exposait en écriture que create_issue et add_comment : un déplacement approuvé côté service d'agents (kanbante.move_card, vague H3) aurait échoué faute d'outil. - move_issue (owner, repo, number, column) réutilise le service de déplacement de l'interface (_do_move_card, extrait de POST /api/move sans changement de comportement) : board local, journal source « mcp », miroir d'étiquette kanban:* remplacée, autres étiquettes préservées. - Colonne acceptée par clé, par étiquette de forge ou par libellé français affiché (définitions de l'espace). - Garde doctrine : la cible done (« Terminé ») est refusée avant toute écriture — les agents s'arrêtent en Révision. - Erreurs propres : colonne inconnue (liste des valides), dépôt/issue inconnu, pull request refusée. - 296 tests verts (5 nouveaux + épingles de la liste d'outils mises à jour).	2026-10-26 15:06:02 +00:00
Spark	a92353f8ef	feat(0.35.0): jalons en écriture depuis la page Projet (issue #26 ) CI / test (push) Successful in 2m22s Details - Clients : create_milestone / update_milestone (cache invalidé) ; GitHub hérite des mêmes endpoints. - API Kanbante : création, modification (titre/échéance, échéance vidée = retirée), fermeture ; CSRF, validation de date avant toute écriture, erreurs forge en 502. - Page Projet : formulaire 'Nouveau jalon' + édition/ fermeture par jalon (project.js versionné). - Échéance à midi UTC : à minuit, le fuseau de l'instance Gitea faisait reculer la date affichée d'un jour (réel). - 291 tests verts (5 nouveaux, palier 24) ; cycle réel complet sur Projets/kanbante (jalons smoke #37/#38 créés, dates vérifiées, fermés).	2026-10-26 10:53:29 -04:00
Spark	8c889878ee	feat(0.34.0): vue « En vol partout » /inflight (issue #24 ) CI / test (push) Successful in 2m24s Details - L'encours (colonnes en vol de l'espace) tous projets actifs, regroupé PAR colonne, trié par âge décroissant dans la colonne (pipeline _card_ages du board). - En-tête : total + compteurs par colonne + limite WIP globale (somme des projets qui en définissent). - Entrées Pilotage (menu latéral) et palette Ctrl+K ; SSE /api/stream via live.js comme les autres vues. - Réutilise _collect_focus_groups : aucun appel forge en plus. 286 tests verts (5 nouveaux, palier 23) ; vérifié en Chromium réel (356 cartes en vol sur les vraies données, dont la carte #24 elle-même).	2026-10-26 10:48:45 -04:00
Spark	dfb4e595ff	fix(test): horodatage capturé une fois (flake CI, écart d'1 s) CI / test (push) Successful in 2m23s Details test_column_entry_times_ignores_comments évaluait _days_ago(3) à la création puis à l'assertion : une bascule de seconde entre les deux faisait échouer le run CI 2333 alors que le run jumeau (tag v0.33.0) et la suite locale passaient.	2026-10-26 10:23:06 -04:00
Spark	9fe35f6c8f	feat(0.33.0): filtrage professionnel sur Mes issues (/my) CI / test (push) Successful in 2m26s Details - Barre de filtres en carte : recherche texte (titre, projet, #numéro, étiquettes ; accents/casse ignorés, raccourci /), listes Projet et Étiquette avec compteurs, chips de colonnes colorées multi-sélection, 4 tris. - Facettes calculées côté serveur ; filtrage instantané côté client (attributs data-*), compteur en direct, compteurs de section, état vide + réinitialisation. - Filtres structurels persistés en localStorage. - 281 tests verts (3 nouveaux, palier 22) ; vérifié en Chromium réel sur les vraies données (467 issues : recherche 'agent' -> 24 résultats instantanés).	2026-10-26 10:20:37 -04:00
Spark	d419fe3086	fix(0.32.2): résolution par requête des URL dracodev, base agent dérivée et CSP du panneau CI / test (push) Successful in 2m21s Details La dérivation 0.32.1 ne couvrait que les URL sœurs depuis AGENT_EVENEMENTS_URL, jamais agent_url : sur la dev, le panneau visait le défaut prod (agent injoignable, prod non installée), console morte. Désormais, pour tout rendu à une requête (barre, iframe du panneau, CSP frame-src) : explicite > hôte public au motif fermé dracodev > dérivation élargie (événements ou base du service) > défaut officiel. Contextes sans requête inchangés sinon ; aucun SSO ajouté.	2026-10-26 02:07:46 +00:00
Spark	65c467bc90	fix(0.32.1): URL sœurs dracodev dérivées de l'environnement de l'agent CI / test (push) Successful in 2m58s Details	2026-10-25 23:49:33 +00:00
Spark	4a97e0d0dc	refactor: noms publics dracodev par configuration (dev/prod) CI / test (push) Successful in 2m22s Details	2026-10-25 18:02:21 +00:00
Spark	7852d860fe	fix(0.31.1): compositeur de création refait, description en <details> natif CI / test (push) Successful in 2m13s Details - Carte compositeur : en-tête + colonne d'arrivée, champ pleine largeur, bouton primaire ; neutralise le display:flex imposé par .board-toolbar aux formulaires. - 'Ajouter une description' devient un <details> natif : aucun JS requis, insensible au cache et aux erreurs de scripts (le bouton 0.31.0 pouvait rester inerte). - Assets du board versionnés (?v=APP_VERSION) contre les mélanges de cache après redéploiement ; Ctrl+Entrée. - Vérifié en Chromium réel sur le vrai board (captures contrôlées) ; 261 tests verts.	2026-10-23 09:48:17 -04:00