feat: HUB-21 — réglages généraux du Hub consommés par ObsiGate (bannière + drapeau recherche_partout) #229

Merge pull request 'ObsiGate 2.85.1 — HUB-19 : propagation des rôles du Hub (consommatrice, registre D3(a)) (#228 )' (#69 ) from hub19-roles-obsigate-2-85-1 into main
feat: HUB-19 — rôles du Hub consommés par ObsiGate (registre D3(a)) #228
2026-11-06 17:02:04 +00:00 · 2026-11-06 11:31:25 -05:00 · 2026-11-06 16:30:30 +00:00 · 2026-11-06 11:25:26 -05:00 · 2026-11-06 11:08:04 -05:00 · 2026-11-06 11:08:01 -05:00
40 changed files with 3260 additions and 63 deletions
@@ -130,6 +130,7 @@ DEEPSEEK_MODEL=deepseek-chat
 # DRACO_TIKTAK_URL=https://tiktak.dracodev.net
 # DRACO_KANBANTE_URL=https://kanbante.dracodev.net
 # DRACO_SHAARIT_URL=https://shaarit.dracodev.net
+# DRACO_HUB_URL=https://hub.dracodev.net
 # DRACO_GITEA_URL=https://git.dracodev.net

 # ── Fusion — émission d'événements vers le service d'agents (#220) ──
@@ -6,7 +6,7 @@ Format basé sur [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/),
 et [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

 > **En cours de développement** : les changements à venir sont listés dans la section
-> [Unreleased](#unreleased). La dernière version livrée est **2.83.1**.
+> [Unreleased](#unreleased). La dernière version livrée est **2.85.2**.

 ---

@@ -14,6 +14,57 @@ et [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

 ---

+## [2.85.2] — 2026-11-06
+
+- **HUB-21 — Consommation des réglages généraux du Hub par ObsiGate (propagation du pilote TikTak 0.61.22, liste fermée D6(a), #229)** : nouveau client `backend/hub_reglages.py` — consultation côté serveur de `GET {hub}/api/reglages/effectifs` (endpoint public, aucun cookie, `Accept: application/json`, délai 2 s), forme validée strictement, cache mémoire 60 s sur le patron du pilote (horodatage posé avant l'appel : un échec conserve l'ancien cache, pas de rafale) ; URL du Hub résolue comme la barre commune (`draco_config.app_url("hub")` — jamais d'URL dev figée). Toute erreur (réseau, statut, JSON, forme) = **repli intégral** sur les défauts actuels. **Bannière** : fragment injecté côté serveur sous la barre commune (page principale `_index_html` et page `/recherche`), texte échappé (jamais de HTML injecté), bouton fermer avec mémorisation du texte fermé en `sessionStorage` (clé `obsigate_banniere_masquee`) ; bannière vide = aucun fragment, zéro changement visuel ; styles `.banniere-hub*` dans `frontend/style.css` (variables CSS du thème). **Drapeau `recherche_partout`** : `serve_recherche_page` remplace le jeton `{{RECHERCHE_PARTOUT}}` rendu en `data-recherche-partout` du `<main id="recherche">` de `frontend/recherche.html` ; si faux, le JS vendangé `frontend/js/recherche.js` (même modification dans les 4 hôtes applicatifs) n'interroge plus les sœurs ni la console — la recherche locale ObsiGate continue ; vrai ou Hub muet = comportement actuel. **`domaine_defaut` non consommé** : ObsiGate n'a pas de notion de domaine propre — le sélecteur de domaine de la barre commune pilote le panneau Spark, pas les vues d'ObsiGate ; la valeur est lue et validée par le client, sans effet local. Le libellé « Fermer l'annonce » est un attribut d'accessibilité du fragment injecté côté serveur (patron des autres hôtes), pas un texte d'interface du SPA : pas de clé i18n ajoutée. Fiche : `docs/features/hub-reglages-obsigate-229.md`. Tests : `tests/test_hub_reglages.py` (client : contrat exact, forme inattendue, erreurs, cache 60 s, ancien cache sans rafale ; intégration : bannière présente et échappée sur `/` et `/recherche`, absente si vide ou Hub muet, attribut du drapeau selon la valeur) ; `tests/frontend/recherche.test.mjs` étendu (`federationAutorisee`).
+## [2.85.1] — 2026-11-06
+
+- **HUB-19 — Propagation des rôles du Hub à ObsiGate (suite du pilote ShaarIt, fusion Hub v2 §2.2, décision D3(a), #228)** : ObsiGate, à la fois émettrice et consommatrice du SSO, consomme à son tour le registre des rôles du Hub. Nouveau client `backend/hub_roles.py` : à l'ouverture de session draco (validation locale `draco_session.user_for_draco`), consultation de `GET {hub}/api/roles/obsigate` (en-tête Cookie complet relayé, `Accept: application/json`, délai 2 s), cache mémoire 60 s par `sub` sur le patron du pilote (horodatage posé avant l'appel : un échec conserve l'ancien cache, pas de rafale) ; URL du Hub résolue comme la barre commune (`draco_config.app_url("hub")` : `DRACO_HUB_URL` explicite, dérivation par l'hôte sœur, défaut officiel — jamais d'URL dev figée). **Effets, sessions établies par draco seulement** : niveau connu `aucun` → session draco refusée, `require_auth` répond 403 avec un message explicite en français (l'authentification native d'ObsiGate — l'émettrice, son accès propre est le secours — n'est jamais touchée) ; routes d'administration `/api/auth/admin/*` : nouvelle garde `require_admin_hub` — canal draco + rôle connu ⇒ niveau `administrateur` du registre exigé, sessions natives et rôle inconnu (Hub injoignable ou en erreur) ⇒ règles actuelles inchangées, aucun verrouillage nouveau, et le registre n'élève aucun privilège local. Validation locale du jeton, émission, révocations et renouvellement inchangés ; aucun rôle dans le jeton. Aucun impact frontend (pas d'i18n). Fiche : `docs/features/hub-roles-obsigate-228.md`. Tests : `tests/test_hub_roles.py` (client : parsing/cache/repli/résolution d'URL ; intégration : refus draco, garde admin). **Hypothèse de version** : branche depuis le main 2.84.1, cible 2.85.1 — rebasée sur la 2.85.0 (PR « API sessions HUB-22 » fusionnée d'abord) avant fusion.
+## [2.85.0] — 2026-11-06
+
+- **HUB-22 — API machine des sessions draco (vague C du plan Hub v2.1, #227)** : trois nouvelles routes sous la garde machine existante (`DRACO_ADMIN_MACHINE_KEY`, en-têtes `X-Draco-Machine-Key` / `X-Draco-Actor` ; 401 sans clé valide, 404 si l'API n'est pas configurée ou le compte inconnu) — `GET /api/admin/machine/comptes/{username}/sessions` liste les sessions actives du compte (`jti`, `exp`, `expire_le` en ISO 8601 UTC, `revoquee`), `POST …/sessions/{jti}/revoquer` révoque une session (404 si le `jti` n'est pas dans l'ensemble actif de ce compte — jamais de révocation cross-utilisateur) et `POST …/sessions/revoquer-toutes` révoque toutes les sessions (déconnexion globale, **sans désactiver le compte**). Backend : `draco_session.issued_sessions_for_user()` (sessions actives triées par expiration, purge des expirés au passage) et `revoke_one_for_user()` (appartenance au `sub` vérifiée avant révocation), sur le registre des émissions de HUB-13 et la même clé d'identité (`id`, à défaut `username`). Écritures journalisées dans `data/audit.log` (`session_revoquee`, `sessions_revoquees`). Fiche : `docs/features/hub-sessions-machine-227.md`. Tests : `tests/test_comptes_machine.py` (`TestSessions`), `tests/test_draco_session.py`.
+
+---
+
+## [2.84.1] — 2026-11-06
+
+- **HUB-18 — Thème commun (fusion #132)** : barre commune re-vendangée **verbatim** en **v0.5.0** depuis dracodev-commons (branche `hub18-theme-commun`, PR commons #12) — `frontend/draco-barre.js` seul change côté barre (CSS et fragment inchangés). La barre apprend la préférence de thème du profil du Hub (`GET <hub>/api/profil/theme`, cookie draco ; `<hub>` = URL résolue de la barre, jamais figée) et l'applique à l'ouverture : cache `localStorage` `draco-theme-hub` (TTL 12 h) appliqué synchrone, puis fetch asynchrone non bloquant ; `sombre`/`clair` posent `data-theme`, `systeme` le retire (`prefers-color-scheme` décide). **Repli intégral** si le Hub ne répond pas, répond non-OK ou `theme: null` : le comportement actuel (choix local, puis système) reste seul maître. Initialisation propre à ObsiGate dans `frontend/app.js` : `initTheme()` écoute l'événement `draco:theme` de la barre et route le mode effectif par `applyTheme()` — icône et libellé du bouton de thème et feuilles highlight.js restent synchronisés, le mode appliqué devient le choix local mémorisé (`obsigate-theme`), et le bouton de bascule reste fonctionnel pour la session. Garde ajoutée à `tests/test_draco_barre.py`.
+
+---
+
+## [2.84.0] — 2026-11-06
+
+- **HUB-13 — API d'administration des comptes, machine-à-machine (fusion #127, #226)** : nouvelles routes `/api/admin/machine/comptes` (liste, profil étendu, création, modification, désactivation/réactivation, suppression, réinitialisation du mot de passe et du MFA), protégées par la clé machine dédiée `DRACO_ADMIN_MACHINE_KEY` (en-tête `X-Draco-Machine-Key`, distincte de `DRACO_SSO_MACHINE_KEY` ; aucune session utilisateur ne les ouvre ; API inerte si la clé n'est pas configurée). Le profil étendu expose nom d'utilisateur, nom affiché, langue, avatar (valeur + présence), rôle global, état actif, MFA activé oui/non — jamais le secret TOTP ni le haché du mot de passe. La désactivation arrête l'émission de nouveaux jetons et révoque les `jti` draco actifs : `draco_session` tient désormais un registre des émissions (`data/draco_issued.json`) et `revoke_all_for_user()` révoque via la liste existante ; le repère `password_changed_at` (BUG-028) est aussi avancé. Nouveau champ utilisateur `must_change_password` : posé à la création machine et à la réinitialisation du mot de passe, signalé par la connexion et `GET /api/auth/me`, effacé au changement effectif. Chaque action est journalisée dans `data/audit.log` (acteur = identité de service `X-Draco-Actor`, action, compte cible, horodatage). Fiche : `docs/features/hub-api-admin-comptes-226.md`. Tests : `tests/test_comptes_machine.py`.
+
+---
+
+## [2.83.5] — 2026-11-05
+
+- **Barre commune v0.4.1 — correctif des icônes invisibles du menu compte (fusion #125)** : seul `frontend/draco-barre.js` change, re-vendangé **verbatim** depuis dracodev-commons (branche `menu-compte-icones-svg-ns-v0-4-1`, PR commons #11) ; le CSS est inchangé. En v0.4.0, `menuIcone()` créait le `<svg>` des icônes et ses primitives via `document.createElement()` — espace de noms **HTML**, jamais dessinés par le navigateur : les libellés du menu compte étaient décalés d'un cran d'icône, sans aucun glyphe. La v0.4.1 crée tout via `document.createElementNS()` (espace de noms SVG). Glyphes, CSS et comportements inchangés. Garde ajoutée à `tests/test_draco_barre.py`.
+
+---
+
+## [2.83.4] — 2026-11-05
+
+- **Barre commune v0.4.0 — icônes monoline du menu compte (HUB-11, fusion #125)** : `frontend/draco-barre.js` et `frontend/draco-barre.css` re-vendangés **verbatim** depuis dracodev-commons v0.4.0 (branche `menu-compte-icones-v0-4-0`, PR commons #10). Les items du menu compte — **Télécharger**, **À Propos**, **Aides**, **Profil**, **Déconnexion** — reçoivent des **icônes SVG monoline** (contour, trait fin, `currentColor`, ~18 px) dans le style des icônes du rail de la console Spark ; aucun emoji. L'en-tête d'identité reste sans icône ; les liens Hub et le relais « Déconnexion » sont inchangés. Garde ajoutée à `tests/test_draco_barre.py`.
+
+---
+
+## [2.83.3] — 2026-11-04
+
+- **Barre commune v0.3.0 — liens Hub du menu compte (HUB-1, fusion #115)** : `frontend/draco-barre.js` et `frontend/draco-barre.css` re-vendangés **verbatim** depuis dracodev-commons v0.3.0 (branche `hub-menu-compte-v0-3-0`, PR commons #9). Le menu compte gagne les liens **Télécharger**, **À Propos**, **Aides** et **Profil** (devenu un lien, plus un relais) vers le Hub. Branchement hôte : `backend/draco_config.py` gagne la clé `hub` (défaut officiel `https://hub.dracodev.net`, variable `DRACO_HUB_URL`, dérivation `-dev` → `hub-dev` depuis l'hôte de l'agent), servie dans `window.DRACO_URLS` ; `frontend/index.html` la passe en `urls.hub` de `DRACO_BAR_CONFIG`. « Déconnexion » reste relayée, inchangée. Aucun nouvel onglet : le Hub n'apparaît que dans le menu compte.
+
+---
+
+## [2.83.2] — 2026-11-04
+
+- **Recherche fédérée — ShaarIt, 5e source de « Rechercher partout »** (demande de Bruno, 2026-11-04 ; contrat dracodev-commons v0.2.1, `contrats/recherche-federee.md`) : `frontend/js/recherche.js` **re-vendangé verbatim** depuis la source canonique de commons (`ui/recherche/`) — ShaarIt devient une source de la page `/recherche` comme les autres (bases prod/dev, onglet, normaliseur : lien profond canonique `{base}shaare/<shorturl>`, contexte « Bookmark · privé · tags », repli recherche native `/?q=`). Le fichier reste strictement identique chez les cinq hôtes.
+- **Page `/recherche`** : onglet et section « ShaarIt — bookmarks », `data-base-shaarit` rendu par le jeton `{{URL_SHAARIT}}` (déjà résolu par la route depuis la 2.83.1) ; la CSP `connect-src` de la page ajoute l'origine ShaarIt résolue (`backend/main.py`).
+- **CORS de recherche** (`backend/recherche_cors.py`) : origines officielles ShaarIt prod et dev ajoutées aux listes explicites, `shaarit` ajoutée aux clés sœurs résolues — `GET /api/search` d'ObsiGate devient lisible depuis les pages de ShaarIt, et réciproquement.
+- Tests : `tests/frontend/recherche.test.mjs` porté à 5 sections (normaliseur ShaarIt inclus) ; `tests/test_recherche_cors.py` — allowlist attendue à 12 origines.
+
+---
+
 ## [2.83.1] — 2026-11-03

 - **Barre commune (dracodev-commons v0.2.0 vendangée, @70c837a)** : nouvel onglet **ShaarIt** (bookmarks, réécriture Rust de Shaarli) après Kanbante et avant l'onglet Console Spark — `frontend/draco-barre.css` et `frontend/draco-barre.js` remplacés **verbatim** par la v0.2.0 (hachages vérifiés), logo `frontend/img/logos/shaarit.svg` ajouté tel quel ; le fragment porté dans `frontend/index.html` et `frontend/recherche.html` (jeton `{{URL_SHAARIT}}` remplacé par la route `/recherche`). L'URL ShaarIt suit le **même mécanisme** que les autres apps : `backend/draco_config.py` gagne la clé `shaarit` (défaut officiel `https://shaarit.dracodev.net`, variable `DRACO_SHAARIT_URL`, dérivation `-dev` → `shaarit-dev` depuis l'hôte de l'agent), servie dans `window.DRACO_URLS` et réécrite sur l'onglet comme les autres.
@@ -4,7 +4,7 @@

 **Porte d'entrée web ultra-léger pour vos vaults Obsidian** — Accédez, naviguez et recherchez dans toutes vos notes Obsidian depuis n'importe quel appareil via une interface web moderne et responsive.

-[![Version](https://img.shields.io/badge/Version-2.83.1-blue.svg)]()
+[![Version](https://img.shields.io/badge/Version-2.85.2-blue.svg)]()
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Docker](https://img.shields.io/badge/Docker-Ready-blue.svg)](https://www.docker.com/)
 [![Python](https://img.shields.io/badge/Python-3.11+-green.svg)](https://www.python.org/)
@@ -977,8 +977,8 @@ Ce projet est sous licence **MIT** — voir le fichier [LICENSE](LICENSE) pour l

 ## 📝 Changelog

-Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.83.1).
+Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.85.2).

 ---

-*Projet : ObsiGate | Version : 2.83.1 | Dernière mise à jour : Septembre 2026*
+*Projet : ObsiGate | Version : 2.85.2 | Dernière mise à jour : Septembre 2026*
@@ -2,7 +2,7 @@

 **Ultra-light web gateway for your Obsidian vaults** — Access, browse, and search all your Obsidian notes from any device via a modern, responsive web interface.

-[![Version](https://img.shields.io/badge/Version-2.83.1-blue.svg)]()
+[![Version](https://img.shields.io/badge/Version-2.85.2-blue.svg)]()
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Docker](https://img.shields.io/badge/Docker-Ready-blue.svg)](https://www.docker.com/)
 [![Python](https://img.shields.io/badge/Python-3.11+-green.svg)](https://www.python.org/)
@@ -1152,8 +1152,8 @@ This project is licensed under the **MIT License** - see the [LICENSE](LICENSE)

 ## 📝 Changelog

-See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.83.1).
+See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.85.2).

 ---

-*Project: ObsiGate | Version: 2.83.1 | Last updated: September 2026*
+*Project: ObsiGate | Version: 2.85.2 | Last updated: September 2026*
@@ -1 +1 @@
-2.83.1
+2.85.2
@@ -154,6 +154,35 @@ def log_coffre_event(
    _write_entry(entry)


+def log_compte_admin(
+    acteur: str,
+    action: str,
+    cible: str,
+    ip: str | None = None,
+    details: dict | None = None,
+):
+    """Journal d'une action d'administration de compte (HUB-13, fusion #127).
+
+    ``acteur`` est l'identité de service appelante (API machine des
+    comptes, en-tête ``X-Draco-Actor``), ``cible`` le compte visé.
+    Règle absolue : ``details`` ne contient jamais de mot de passe, de
+    secret TOTP ni de jeton — seulement des métadonnées (champs
+    modifiés, nombre de jti révoqués…). Le champ ``username`` reprend
+    l'acteur pour rester filtrable par l'écran d'audit existant.
+    """
+    entry: dict = {
+        "timestamp": datetime.now(UTC).isoformat(),
+        "action": action,
+        "username": acteur,
+        "acteur": acteur,
+        "cible": cible,
+        "ip": ip or "unknown",
+    }
+    if details:
+        entry["details"] = details
+    _write_entry(entry)
+
+
 def get_recent_entries(limit: int = 100, action: str | None = None) -> list:
    """Read the most recent audit log entries.

@@ -141,9 +141,26 @@ def _draco_fallback(request: Request) -> dict | None:
    return user


-def require_auth(current_user=Depends(get_current_user)):
+def require_auth(request: Request, current_user=Depends(get_current_user)):
    """Dependency: require a valid authenticated user."""
    if not current_user:
+        # HUB-19 (#228) : la session draco a été refusée parce que le
+        # registre des rôles du Hub attribue le niveau « aucun » à ce
+        # compte pour ObsiGate — réponse explicite, distincte du 401
+        # générique. L'authentification native n'est pas concernée :
+        # ce refus ne naît que sur le chemin draco (user_for_draco).
+        if getattr(request.state, "role_hub_refuse", None) == "aucun":
+            raise HTTPException(
+                status_code=403,
+                detail=(
+                    "Accès refusé : le registre des rôles du Hub attribue "
+                    "le niveau « aucun » à votre compte pour ObsiGate, "
+                    "l'accès par la session draco est donc refusé. "
+                    "L'administrateur de la suite peut modifier ce niveau "
+                    "dans la matrice des rôles du Hub. L'accès natif "
+                    "d'ObsiGate (son propre identifiant) reste possible."
+                ),
+            )
        raise HTTPException(
            status_code=401,
            detail="Authentification requise",
@@ -159,6 +176,31 @@ def require_admin(current_user=Depends(require_auth)):
    return current_user


+def require_admin_hub(current_user=Depends(require_admin)):
+    """Dependency: admin + garde du registre des rôles du Hub (HUB-19, #228).
+
+    Pour les routes d'administration des comptes (``/api/auth/admin/*``) :
+    quand la requête est authentifiée par le **canal draco** (``_draco_sub``
+    présent) et que le rôle du Hub est **connu** (``_hub_role`` non None),
+    le niveau ``administrateur`` du registre est exigé — le rôle local ne
+    suffit plus. Session native, ou rôle inconnu (Hub injoignable) :
+    règles actuelles inchangées.
+    """
+    if current_user.get("_draco_sub"):
+        role_hub = current_user.get("_hub_role")
+        if role_hub is not None and role_hub != "administrateur":
+            raise HTTPException(
+                status_code=403,
+                detail=(
+                    "Accès réservé au niveau « administrateur » d'ObsiGate "
+                    "dans le registre des rôles du Hub (votre niveau actuel : "
+                    f"« {role_hub} »). L'administrateur de la suite peut "
+                    "l'accorder dans la matrice des rôles du Hub."
+                ),
+            )
+    return current_user
+
+
 def is_home_vault(vault_name: str) -> bool:
    """Un dossier personnel (#194) : vault « home-<user> »."""
    return vault_name.startswith("home-")
@@ -40,7 +40,7 @@ from .mfa import (
    verify_recovery_code,
    verify_totp,
 )
-from .middleware import is_auth_enabled, require_admin, require_auth
+from .middleware import is_auth_enabled, require_admin_hub, require_auth
 from .password import hash_password, validate_password_strength, verify_password
 from .user_store import (
    create_user,
@@ -298,6 +298,8 @@ def _issue_tokens(user: dict, username: str, remember_me: bool, response: Respon
            "role": user["role"],
            "vaults": user["vaults"],
            "avatar": user.get("avatar"),
+            # HUB-13 : mot de passe temporaire — changement forcé signalé.
+            "must_change_password": bool(user.get("must_change_password")),
        },
    }

@@ -433,6 +435,8 @@ async def get_me(current_user=Depends(require_auth)):
        "language": current_user.get("language", "fr"),
        "last_login": current_user.get("last_login"),
        "avatar": current_user.get("avatar"),
+        # HUB-13 : mot de passe temporaire — changement forcé signalé.
+        "must_change_password": bool(current_user.get("must_change_password")),
    }


@@ -487,7 +491,11 @@ async def change_password(
    assert user is not None, f"User {current_user['username']} not found"
    if not verify_password(req.current_password, user["password_hash"]):
        raise HTTPException(400, "Mot de passe actuel incorrect")
-    update_user(current_user["username"], {"password": req.new_password})
+    # HUB-13 : le changement effectif efface le marqueur de changement forcé.
+    update_user(current_user["username"], {
+        "password": req.new_password,
+        "must_change_password": False,
+    })
    updated = get_user(current_user["username"])
    result: dict = {"message": "Mot de passe mis à jour"}
    if updated is not None:
@@ -949,9 +957,13 @@ async def mfa_recovery_login(body: MfaRecoveryRequest, response: Response, reque


 # ── Admin endpoints ───────────────────────────────────────────────────
+# Garde `require_admin_hub` (HUB-19, #228) : `require_admin` + — pour
+# une requête authentifiée par le canal draco dont le rôle du Hub est
+# connu — exigence du niveau « administrateur » du registre des rôles.
+# Sessions natives et rôle inconnu : règles actuelles inchangées.

@router.get("/admin/users")
-async def list_users(admin=Depends(require_admin)):
+async def list_users(admin=Depends(require_admin_hub)):
    """List all users (admin only). Password hashes are never included."""
    return get_all_users()

@@ -959,7 +971,7 @@ async def list_users(admin=Depends(require_admin)):
@router.post("/admin/users")
 async def create_user_endpoint(
    req: CreateUserRequest,
-    admin=Depends(require_admin),
+    admin=Depends(require_admin_hub),
 ):
    """Create a new user (admin only)."""
    try:
@@ -986,7 +998,7 @@ async def create_user_endpoint(
 async def update_user_endpoint(
    username: str,
    req: UpdateUserRequest,
-    admin=Depends(require_admin),
+    admin=Depends(require_admin_hub),
 ):
    """Update a user (admin only)."""
    updates = req.dict(exclude_none=True)
@@ -999,7 +1011,7 @@ async def update_user_endpoint(
@router.delete("/admin/users/{username}")
 async def delete_user_endpoint(
    username: str,
-    admin=Depends(require_admin),
+    admin=Depends(require_admin_hub),
 ):
    """Delete a user (admin only). Cannot delete own account."""
    if username == admin["username"]:
@@ -80,8 +80,16 @@ def create_user(
    role: str = "user",
    vaults: list[str] | None = None,
    display_name: str | None = None,
+    must_change_password: bool = False,
 ) -> dict:
-    """Create a new user. Raises ValueError if username already taken."""
+    """Create a new user. Raises ValueError if username already taken.
+
+    ``must_change_password`` (HUB-13) marque un mot de passe temporaire
+    (création/réinitialisation par l'administration machine) : le
+    changement est forcé à la première connexion. Les comptes créés
+    avant ce champ n'en portent pas — ils valent ``False`` partout où
+    le champ est lu via ``.get(..., False)``.
+    """
    with _users_lock:
        data = _read()
        if username in data["users"]:
@@ -95,6 +103,7 @@ def create_user(
            "role": role,
            "vaults": vaults or [],
            "active": True,
+            "must_change_password": bool(must_change_password),  # HUB-13
            "language": "fr",  # default UI language
            "avatar": None,  # profile picture data-URL (#113)
            "created_at": datetime.now(UTC).isoformat(),
@@ -18,6 +18,9 @@ Variables (voir ``.env.example``) :
 - ``DRACO_TIKTAK_URL``    — base publique de TikTak.
 - ``DRACO_KANBANTE_URL``  — base publique de Kanbante.
 - ``DRACO_SHAARIT_URL``   — base publique de ShaarIt (barre v0.2.0).
+- ``DRACO_HUB_URL``       — base publique du Hub (barre v0.3.0,
+  HUB-1 : liens Télécharger / À Propos / Aides / Profil du menu
+  compte ; le Hub n'a pas d'onglet dans la barre).
 - ``DRACO_GITEA_URL``     — base publique de Gitea (les cartes
  Kanbante *sont* des issues Gitea, contrat liens-profonds) ;
  distincte de ``OBSIGATE_GITEA_URL`` (source connectée de
@@ -52,6 +55,7 @@ DEFAUTS: dict[str, str] = {
    "tiktak": "https://tiktak.dracodev.net",
    "kanbante": "https://kanbante.dracodev.net",
    "shaarit": "https://shaarit.dracodev.net",
+    "hub": "https://hub.dracodev.net",
    "gitea": "https://git.dracodev.net",
 }

@@ -62,6 +66,7 @@ _VARIABLES: dict[str, str] = {
    "tiktak": "DRACO_TIKTAK_URL",
    "kanbante": "DRACO_KANBANTE_URL",
    "shaarit": "DRACO_SHAARIT_URL",
+    "hub": "DRACO_HUB_URL",
    "gitea": "DRACO_GITEA_URL",
 }

@@ -75,6 +80,7 @@ _SLUGS_HOTE: dict[str, str] = {
    "tiktak": "tiktak",
    "kanbante": "kanbante",
    "shaarit": "shaarit",
+    "hub": "hub",
 }

 # Premier label de l'hôte de l'agent : ``agent`` suivi d'un suffixe
@@ -19,6 +19,27 @@
 #                               vide = cookie lié à l'hôte, utile en dev)
 #   DRACO_SSO_MACHINE_KEY       clé machine protégeant la lecture de la
 #                               liste de révocation (GET /api/sso/revocations)
+#
+# Registre des émissions (HUB-13, fusion #127) : chaque jti émis est
+# consigné par `sub` dans data/draco_issued.json (jti -> exp, purgé à
+# l'expiration) pour que l'administration des comptes puisse révoquer
+# toutes les sessions draco d'un utilisateur (désactivation,
+# suppression, réinitialisation du mot de passe) via revoke().
+# HUB-22 (#227) ajoute la lecture de ce registre
+# (issued_sessions_for_user) et la révocation unitaire contrôlée par
+# appartenance (revoke_one_for_user), exposées par l'API machine des
+# sessions (backend/routers/comptes_machine.py).
+#
+# Rôles du Hub (HUB-19, #228) : à l'ouverture de session draco,
+# `user_for_draco` consulte en plus le registre des rôles du Hub
+# (`backend/hub_roles.py`, contrat D3(a) posé par le pilote ShaarIt) :
+# niveau connu ``aucun`` → la session draco est refusée (l'authenti-
+# fication native d'ObsiGate, émettrice, n'est jamais touchée) ;
+# niveau connu → il est joint au dict utilisateur (``_hub_role``)
+# pour que les routes d'administration du canal draco exigent
+# ``administrateur`` ; rôle inconnu (Hub injoignable) → comportement
+# actuel, aucun verrouillage nouveau. Aucun rôle dans le jeton :
+# validation locale, émission et révocations sont inchangées.

 from __future__ import annotations

@@ -40,10 +61,12 @@ ALGORITHM = "HS256"
 TOKEN_TTL_SECONDS = 12 * 3600          # durée de vie du jeton (design §5.2)
 RENEWAL_WINDOW_SECONDS = 2 * 3600      # réémettre si exp - now < 2 h
 REVOKED_FILE = Path("data/draco_revoked.json")
+ISSUED_FILE = Path("data/draco_issued.json")
 ALLOWED_RETURN_SUFFIX = "dracodev.net"

 _lock = threading.Lock()
 _revoked: dict[str, int] | None = None  # jti -> exp (chargé paresseusement)
+_issued: dict[str, dict[str, int]] | None = None  # sub -> {jti -> exp}


 def _secret() -> str:
@@ -108,6 +131,115 @@ def revoked_list() -> list[dict]:
                for jti, exp in _load_revoked().items() if exp > now]


+# ── Registre des émissions (par utilisateur) ────────────────────────────
+
+def _load_issued() -> dict[str, dict[str, int]]:
+    global _issued
+    if _issued is None:
+        try:
+            data = json.loads(ISSUED_FILE.read_text(encoding="utf-8"))
+            _issued = {
+                str(sub): {str(j): int(e) for j, e in tokens.items()}
+                for sub, tokens in data.items()
+                if isinstance(tokens, dict)
+            } if isinstance(data, dict) else {}
+        except (OSError, ValueError):
+            _issued = {}
+    return _issued
+
+
+def _save_issued() -> None:
+    ISSUED_FILE.parent.mkdir(parents=True, exist_ok=True)
+    tmp = ISSUED_FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(_issued or {}), encoding="utf-8")
+    tmp.replace(ISSUED_FILE)
+
+
+def _register_issued(sub: str, jti: str, exp: int) -> None:
+    """Consigne un jti émis pour ``sub`` (purge des expirés au passage)."""
+    if not sub:
+        return
+    try:
+        with _lock:
+            store = _load_issued()
+            now = int(time.time())
+            for key in list(store.keys()):
+                store[key] = {j: e for j, e in store[key].items() if e > now}
+                if not store[key]:
+                    del store[key]
+            store.setdefault(sub, {})[jti] = int(exp)
+            _save_issued()
+    except Exception:  # le registre ne casse jamais une émission
+        logger.warning("Registre des émissions draco non écrit", exc_info=True)
+
+
+def revoke_all_for_user(sub: str) -> int:
+    """Révoque tous les jti draco actifs émis pour ``sub``.
+
+    Retourne le nombre de jti révoqués. Utilisé par l'administration
+    des comptes (HUB-13) : désactivation, suppression, réinitialisation
+    du mot de passe.
+    """
+    if not sub:
+        return 0
+    with _lock:
+        store = _load_issued()
+        tokens = store.pop(str(sub), {})
+        now = int(time.time())
+        actifs = {j: e for j, e in tokens.items() if e > now}
+        if tokens:
+            _save_issued()
+    for jti, exp in actifs.items():
+        revoke(jti, exp)
+    return len(actifs)
+
+
+def issued_sessions_for_user(sub: str) -> list[dict]:
+    """Sessions draco actives émises pour ``sub`` (HUB-22, #227).
+
+    Retourne ``[{jti, exp, revoquee}]`` triée par ``exp`` croissant,
+    où ``revoquee`` indique si le ``jti`` figure déjà dans la liste des
+    révocations. Les entrées expirées de cet utilisateur sont purgées
+    du registre au passage (même patron que ``_register_issued``).
+    """
+    if not sub:
+        return []
+    with _lock:
+        store = _load_issued()
+        now = int(time.time())
+        tokens = store.get(str(sub), {})
+        actifs = {j: e for j, e in tokens.items() if e > now}
+        if len(actifs) != len(tokens):
+            if actifs:
+                store[str(sub)] = actifs
+            else:
+                store.pop(str(sub), None)
+            _save_issued()
+        revoques = _load_revoked()
+        entrees = sorted(actifs.items(), key=lambda kv: kv[1])
+    return [{"jti": jti, "exp": exp, "revoquee": jti in revoques}
+            for jti, exp in entrees]
+
+
+def revoke_one_for_user(sub: str, jti: str) -> bool:
+    """Révoque un seul ``jti`` draco de ``sub`` (HUB-22, #227).
+
+    Ne révoque (via ``revoke``) que si le ``jti`` appartient bien à
+    l'ensemble émis de ce ``sub`` et n'est pas expiré — jamais de
+    révocation d'une session d'un autre utilisateur. Retourne ``True``
+    si la révocation a eu lieu, ``False`` sinon.
+    """
+    if not sub or not jti:
+        return False
+    with _lock:
+        store = _load_issued()
+        exp = store.get(str(sub), {}).get(jti)
+        if exp is None or exp <= int(time.time()):
+            return False
+    revoke(jti, exp)
+    return True
+
+
 # ── Émission / vérification ─────────────────────────────────────────────

 def issue_token(user: dict) -> tuple[str, str, int]:
@@ -122,7 +254,9 @@ def issue_token(user: dict) -> tuple[str, str, int]:
        "exp": exp,
        "jti": jti,
    }
-    return jwt.encode(claims, _secret(), algorithm=ALGORITHM), jti, exp
+    token = jwt.encode(claims, _secret(), algorithm=ALGORITHM)
+    _register_issued(str(claims["sub"]), jti, exp)
+    return token, jti, exp


 def decode_claims(token: str) -> dict | None:
@@ -211,6 +345,28 @@ def user_for_draco(request) -> dict | None:
        user["_token_vaults"] = candidate.get("vaults", [])
        user["_token_scope"] = "full"
        user["_draco_sub"] = sub
+        # HUB-19 (#228) : rôle du registre du Hub pour ce porteur.
+        # Niveau connu « aucun » → pas de session établie par draco :
+        # le refus est consigné sur la requête pour que `require_auth`
+        # réponde un message explicite en français (et non un simple
+        # 401 générique). Rôle connu → joint au dict (`_hub_role`) ;
+        # rôle inconnu → `_hub_role` vaut None et le comportement
+        # actuel s'applique, sans verrouillage nouveau.
+        from backend import hub_roles
+
+        cookie = ""
+        try:
+            cookie = request.headers.get("cookie", "") or ""
+        except Exception:  # un objet requête minimal (tests) ne casse rien
+            cookie = ""
+        role = hub_roles.role_pour(sub, cookie)
+        if role == "aucun":
+            try:
+                request.state.role_hub_refuse = "aucun"
+            except Exception:  # pas d'état mutable : refus quand même
+                pass
+            return None
+        user["_hub_role"] = role
        return user
    return None

@@ -0,0 +1,154 @@
+# backend/hub_reglages.py
+# Hub HUB-21 (propagation) — Réglages généraux du Hub consommés par
+# ObsiGate, sur le patron posé par l'hôte pilote TikTak (0.61.22).
+#
+# Le Hub expose ``GET {hub}/api/reglages/effectifs`` — endpoint
+# **public** (aucun cookie relayé), ``Accept: application/json``,
+# délai 2 s. Réponse 200, forme figée (liste fermée D6(a)) :
+# ``{"recherche_partout": bool, "banniere": str,
+# "domaine_defaut": "pro"|"famille"|"perso"|null,
+# "ttl_secondes": 60}``.
+#
+# Cache mémoire 60 s, horodatage posé **avant** l'appel : un échec
+# conserve l'ancien cache et ne déclenche pas de rafale de requêtes
+# vers un Hub en panne.
+#
+# **Repli intégral** : Hub injoignable, en erreur ou réponse de forme
+# inattendue → les **défauts actuels** (``recherche_partout: true``,
+# ``banniere: ""``, ``domaine_defaut: null``), c'est-à-dire le
+# comportement d'ObsiGate avant HUB-21. Ce module ne lève jamais.
+#
+# Consommation chez ObsiGate :
+# - ``banniere`` : injectée côté serveur sous la barre commune
+#   (page principale et page /recherche), texte échappé ;
+# - ``recherche_partout`` : posé en attribut ``data-recherche-partout``
+#   de la page /recherche — si faux, la partie fédérée est désactivée
+#   (la recherche locale ObsiGate continue) ;
+# - ``domaine_defaut`` : **non consommé** — ObsiGate n'a pas de
+#   notion de domaine propre ; le sélecteur de domaine de la barre
+#   commune pilote le panneau Spark, pas les vues d'ObsiGate. La
+#   valeur est lue et validée, sans effet local.
+#
+# URL du Hub : `draco_config.app_url("hub")` — la même résolution que
+# la barre commune (#223) : variable explicite d'abord, dérivation
+# par l'hôte sœur ensuite, défaut officiel enfin. Jamais d'URL dev
+# figée.
+
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+import urllib.request
+
+logger = logging.getLogger("obsigate.hub_reglages")
+
+#: Réglages par défaut = comportement actuel d'ObsiGate (repli).
+DEFAUTS = {"recherche_partout": True, "banniere": "", "domaine_defaut": None}
+
+#: Domaines reconnus du contrat D6(a).
+DOMAINES = ("pro", "famille", "perso")
+
+#: TTL du cache, aligné sur ``ttl_secondes`` annoncé par le Hub (60 s).
+CACHE_TTL_SECONDS = 60
+
+#: Délai maximal de la consultation du Hub (contrat : 2 s).
+DELAI_SECONDS = 2
+
+_lock = threading.Lock()
+_cache: dict | None = None          # derniers réglages validés
+_cache_at: float | None = None      # horodatage (monotone) du dernier appel
+
+
+def _hub_url() -> str:
+    """Base publique du Hub, résolue comme pour la barre commune."""
+    from backend.draco_config import app_url
+
+    return app_url("hub")
+
+
+def _valider(donnees) -> dict | None:
+    """Valide la forme figée du contrat ; ``None`` si inattendue."""
+    if not isinstance(donnees, dict):
+        return None
+    recherche = donnees.get("recherche_partout")
+    banniere = donnees.get("banniere")
+    domaine = donnees.get("domaine_defaut")
+    if not isinstance(recherche, bool):
+        return None
+    if not isinstance(banniere, str):
+        return None
+    if domaine is not None and domaine not in DOMAINES:
+        return None
+    return {
+        "recherche_partout": recherche,
+        "banniere": banniere,
+        "domaine_defaut": domaine,
+    }
+
+
+def _consulter_hub(url: str) -> dict | None:
+    """Appelle le Hub et retourne les réglages validés, ou ``None``.
+
+    Toute erreur (réseau, délai dépassé, statut ≠ 200, JSON
+    illisible, forme hors contrat) retourne ``None`` : repli.
+    Endpoint public : aucun cookie n'est relayé.
+    """
+    requete = urllib.request.Request(
+        url, method="GET", headers={"Accept": "application/json"})
+    try:
+        with urllib.request.urlopen(requete, timeout=DELAI_SECONDS) as reponse:
+            if reponse.status != 200:
+                return None
+            donnees = json.loads(reponse.read().decode("utf-8"))
+    except Exception:  # les réglages ne cassent jamais une page
+        return None
+    return _valider(donnees)
+
+
+def reglages_effectifs() -> dict:
+    """Réglages généraux effectifs pour ObsiGate.
+
+    Réponse du Hub validée et mise en cache 60 s ; à défaut (Hub
+    muet, en erreur ou forme inattendue), l'ancien cache s'il
+    existe, sinon les défauts actuels. Ne lève jamais.
+    """
+    global _cache, _cache_at
+    with _lock:
+        if _cache is not None and _cache_at is not None \
+                and time.monotonic() - _cache_at < CACHE_TTL_SECONDS:
+            return dict(_cache)
+        # Horodatage posé AVANT l'appel (patron du pilote) : l'ancien
+        # cache reste en vigueur, un échec ne déclenche pas de rafale.
+        _cache_at = time.monotonic()
+    url = f"{_hub_url().rstrip('/')}/api/reglages/effectifs"
+    reglages = _consulter_hub(url)
+    if reglages is None:
+        logger.warning(
+            "Réglages généraux du Hub indisponibles (%s) — "
+            "comportement actuel conservé", url)
+        with _lock:
+            return dict(_cache) if _cache is not None else dict(DEFAUTS)
+    with _lock:
+        _cache = reglages
+        _cache_at = time.monotonic()
+    return dict(reglages)
+
+
+def banniere() -> str:
+    """Texte de la bannière d'annonce (``""`` = aucune bannière)."""
+    return reglages_effectifs()["banniere"]
+
+
+def recherche_partout() -> bool:
+    """Drapeau de la recherche fédérée (défaut actuel : actif)."""
+    return bool(reglages_effectifs()["recherche_partout"])
+
+
+def reinitialiser_cache() -> None:
+    """Vide le cache (tests)."""
+    global _cache, _cache_at
+    with _lock:
+        _cache = None
+        _cache_at = None
@@ -0,0 +1,126 @@
+# backend/hub_roles.py
+# Hub HUB-19 (propagation, #228) — Rôles par application : consommation
+# du registre du Hub par ObsiGate, sur le contrat posé par l'hôte
+# pilote ShaarIt (0.7.0, décision D3(a) du plan Hub v2).
+#
+# À l'ouverture de session draco (validation locale du cookie partagé,
+# `draco_session.user_for_draco`), ObsiGate demande au Hub le niveau
+# du porteur pour l'application `obsigate` :
+# ``GET {hub}/api/roles/obsigate``, en relayant l'en-tête Cookie
+# complet de la requête, ``Accept: application/json``, délai 2 s.
+# Réponse 200 : ``{"app", "sub", "role", "explicite",
+# "ttl_secondes": 60}``, rôle ∈ {aucun, utilisateur, administrateur}.
+#
+# Cache mémoire par `sub`, TTL 60 s, sur le patron du pilote (et du
+# cache de révocations draco) : l'horodatage est posé **avant**
+# l'appel — un échec conserve l'ancien cache et ne déclenche pas de
+# rafale de requêtes vers un Hub en panne.
+#
+# **Repli obligatoire** : Hub injoignable, en erreur ou réponse
+# illisible → rôle **inconnu** (``None``) et l'appelant garde son
+# comportement actuel. Le registre ne crée jamais un verrouillage
+# nouveau.
+#
+# URL du Hub : `draco_config.app_url("hub")` — la même résolution que
+# la barre commune (#223) : variable explicite `DRACO_HUB_URL` d'abord,
+# dérivation par l'hôte sœur (suffixe d'environnement de l'hôte de
+# l'agent) ensuite, défaut officiel enfin. Jamais d'URL dev figée.
+
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+import urllib.request
+
+logger = logging.getLogger("obsigate.hub_roles")
+
+#: Identifiant d'ObsiGate dans le registre des applications du Hub.
+APP = "obsigate"
+
+#: Niveaux reconnus du registre (contrat D3(a)).
+ROLES = ("aucun", "utilisateur", "administrateur")
+
+#: TTL du cache, aligné sur ``ttl_secondes`` annoncé par le Hub (60 s).
+CACHE_TTL_SECONDS = 60
+
+#: Délai maximal de la consultation du Hub (contrat : 2 s).
+DELAI_SECONDS = 2
+
+_lock = threading.Lock()
+_cache: dict[str, str] = {}          # sub -> rôle connu
+_cache_at: float | None = None       # horodatage (monotone) du dernier appel
+
+
+def _hub_url() -> str:
+    """Base publique du Hub, résolue comme pour la barre commune."""
+    from backend.draco_config import app_url
+
+    return app_url("hub")
+
+
+def _consulter_hub(url: str, cookie: str) -> str | None:
+    """Appelle le Hub et retourne le rôle validé, ou ``None``.
+
+    Toute erreur (réseau, délai dépassé, statut ≠ 200, JSON illisible,
+    rôle hors contrat) retourne ``None`` : rôle inconnu, repli.
+    ``cookie`` est l'en-tête Cookie complet de la requête, relayé tel
+    quel — c'est lui qui prouve l'identité du porteur au Hub.
+    """
+    requete = urllib.request.Request(
+        url,
+        method="GET",
+        headers={"Cookie": cookie, "Accept": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(requete, timeout=DELAI_SECONDS) as reponse:
+            if reponse.status != 200:
+                return None
+            donnees = json.loads(reponse.read().decode("utf-8"))
+    except Exception:  # le registre ne casse jamais une ouverture de session
+        return None
+    if not isinstance(donnees, dict):
+        return None
+    role = donnees.get("role")
+    return role if role in ROLES else None
+
+
+def role_pour(sub: str, cookie: str) -> str | None:
+    """Niveau connu pour ce `sub` : un des ``ROLES`` si le Hub a
+    répondu, ``None`` si le rôle est inconnu (Hub injoignable/erreur)
+    — repli = comportement actuel de l'appelant.
+
+    `cookie` est l'en-tête Cookie complet de la requête d'origine,
+    relayé tel quel au Hub.
+    """
+    global _cache_at
+    if not sub:
+        return None
+    with _lock:
+        if _cache_at is not None \
+                and time.monotonic() - _cache_at < CACHE_TTL_SECONDS \
+                and sub in _cache:
+            return _cache[sub]
+        # Horodatage posé AVANT l'appel (patron du pilote) : l'ancien
+        # cache reste en vigueur, un échec ne déclenche pas de rafale.
+        _cache_at = time.monotonic()
+    url = f"{_hub_url().rstrip('/')}/api/roles/{APP}"
+    role = _consulter_hub(url, cookie)
+    if role is None:
+        logger.warning(
+            "Registre des rôles du Hub indisponible (%s) — "
+            "comportement actuel conservé", url)
+        return None
+    with _lock:
+        _cache[sub] = role
+        _cache_at = time.monotonic()
+    return role
+
+
+def reinitialiser_cache() -> None:
+    """Vide le cache des rôles (tests, redémarrage à chaud)."""
+    global _cache_at
+    with _lock:
+        _cache.clear()
+        _cache_at = None
@@ -550,6 +550,7 @@ from backend.auth.router import router as auth_router
 from backend.bookslm_routes import router as bookslm_router
 from backend.routers.backups import router as backups_router
 from backend.routers.coffres import router as coffres_router
+from backend.routers.comptes_machine import router as comptes_machine_router
 from backend.routers.config import _load_config
 from backend.routers.config import router as config_router
 from backend.routers.conflicts import router as conflicts_router
@@ -585,6 +586,7 @@ app.include_router(backups_router)  # ROADMAP #85 T4 — Backups
 app.include_router(conflicts_router)  # ROADMAP #85 T8 — Conflicts
 app.include_router(config_router)  # ROADMAP #85 T7 — Config
 app.include_router(coffres_router)  # Coffre Secrets Phase 1b — JAMAIS dans vaults.py
+app.include_router(comptes_machine_router)  # HUB-13 (fusion #127) — Admin des comptes, machine-à-machine
 app.include_router(file_chat_router)  # ROADMAP #169 — Chat par fichier
 app.include_router(files_read_router)  # ROADMAP #85 T6a — Files read
 app.include_router(files_media_router)  # ROADMAP #85 T6c — Media/export
@@ -857,6 +859,49 @@ def _html_with_nonce(request: Request, name: str) -> str:
    )


+def _fragment_banniere_hub() -> str:
+    """Bandeau d'annonce des réglages généraux du Hub (HUB-21).
+
+    Retourne le fragment HTML à insérer sous la barre commune, ou
+    ``""`` quand le Hub n'annonce rien (bannière vide ou Hub muet —
+    repli intégral du client :mod:`backend.hub_reglages`). Le texte
+    est **échappé** (jamais de HTML injecté). Le petit script inline
+    (le nonce CSP est ajouté par l'appelant via ``inject_csp_nonce``)
+    révèle le bandeau sauf si le même texte a déjà été fermé dans la
+    session du navigateur (``sessionStorage``, clé
+    ``obsigate_banniere_masquee``) : une nouvelle annonce réapparaît.
+    """
+    import html as _html
+
+    from backend import hub_reglages
+
+    texte = hub_reglages.banniere()
+    if not texte:
+        return ""
+    return (
+        '<div class="banniere-hub" id="banniere-hub" role="status" hidden>'
+        f'<span class="banniere-hub-texte">{_html.escape(texte)}</span>'
+        '<button type="button" class="banniere-hub-fermer"'
+        ' id="banniere-hub-fermer" aria-label="Fermer l\'annonce">✕</button>'
+        "</div>"
+        "<script>(function(){try{"
+        'var b=document.getElementById("banniere-hub");if(!b)return;'
+        'var t=b.querySelector(".banniere-hub-texte").textContent;'
+        'if(sessionStorage.getItem("obsigate_banniere_masquee")===t)'
+        "{b.remove();return;}"
+        "b.hidden=false;"
+        'document.getElementById("banniere-hub-fermer")'
+        '.addEventListener("click",function(){'
+        'try{sessionStorage.setItem("obsigate_banniere_masquee",t);}'
+        "catch(e){}"
+        "b.remove();});"
+        "}catch(e){"
+        'var b2=document.getElementById("banniere-hub");'
+        "if(b2)b2.hidden=false;"
+        "}})();</script>"
+    )
+
+
 def _index_html(request: Request) -> str:
    """``index.html`` + injection des URL publiques de l'écosystème (#223).

@@ -884,6 +929,15 @@ def _index_html(request: Request) -> str:
        html = html.replace("</head>", script + "</head>", 1)
    else:  # repli défensif : tout en tête de document
        html = script + html
+    # Bannière d'annonce du Hub (HUB-21) : sous la barre commune,
+    # juste avant son rappel ; vide = aucun changement visuel.
+    fragment = _fragment_banniere_hub()
+    if fragment:
+        marqueur = '<div class="draco-bar-rappel"'
+        if marqueur in html:
+            html = html.replace(marqueur, fragment + marqueur, 1)
+        elif "</header>" in html:
+            html = html.replace("</header>", "</header>" + fragment, 1)
    return inject_csp_nonce(html, request.state.csp_nonce)

 if FRONTEND_DIR.exists():
@@ -987,6 +1041,15 @@ if FRONTEND_DIR.exists():
        if not recherche_file.exists():
            raise HTTPException(status_code=404, detail="Recherche page not found")
        html = recherche_file.read_text(encoding="utf-8")
+        # Drapeau « Rechercher partout » des réglages généraux du Hub
+        # (HUB-21) : faux = la partie fédérée de la page est désactivée
+        # par le JS vendangé, la recherche locale continue ; Hub muet
+        # = défaut actuel (actif).
+        from backend import hub_reglages
+
+        html = html.replace(
+            "{{RECHERCHE_PARTOUT}}",
+            "true" if hub_reglages.recherche_partout() else "false")
        urls = urls_publiques()
        for jeton, cle in (
            ("{{URL_OBSIGATE}}", "obsigate"),
@@ -1006,11 +1069,16 @@ if FRONTEND_DIR.exists():
            html = html.replace("</head>", script + "</head>", 1)
        else:
            html = script + html
+        # Bannière d'annonce du Hub (HUB-21) : sous la barre commune ;
+        # vide = aucun changement visuel.
+        fragment = _fragment_banniere_hub()
+        if fragment and "</header>" in html:
+            html = html.replace("</header>", "</header>" + fragment, 1)
        html = inject_csp_nonce(html, request.state.csp_nonce)
        soeurs = " ".join(sorted({
            origin_of(urls.get(cle, "")) or ""
            for cle in ("obsigate", "flowdeck", "tiktak", "kanbante",
-                        "agent")
+                        "shaarit", "agent")
        } - {""}))
        csp = (
            "default-src 'self'; "
@@ -43,6 +43,7 @@ PROD_ORIGINS = frozenset({
    "https://flowdeck.dracodev.net",
    "https://tiktak.dracodev.net",
    "https://kanbante.dracodev.net",
+    "https://shaarit.dracodev.net",
 })

 DEV_ORIGINS = frozenset({
@@ -50,6 +51,7 @@ DEV_ORIGINS = frozenset({
    "https://flowdeck-dev.dracodev.net",
    "https://tiktak-dev.dracodev.net",
    "https://kanbante-dev.dracodev.net",
+    "https://shaarit-dev.dracodev.net",
 })

 AGENT_ORIGINS = frozenset({
@@ -59,7 +61,7 @@ AGENT_ORIGINS = frozenset({


 # Clés de draco_config.urls_publiques() qui sont des applications sœurs.
-_SOEUR_KEYS = ("obsigate", "flowdeck", "tiktak", "kanbante")
+_SOEUR_KEYS = ("obsigate", "flowdeck", "tiktak", "kanbante", "shaarit")


 def is_dev_host(hostname: str | None) -> bool:
@@ -0,0 +1,424 @@
+# backend/routers/comptes_machine.py
+# HUB-13 (fusion #127) — API d'administration des comptes, machine-à-machine.
+#
+# Le Hub (interface d'administration des utilisateurs) administre les
+# comptes dont ObsiGate reste le magasin (décisions D1(a)/D2(a) du plan
+# Hub v2) via ces routes, en lecture et en écriture : lister, lire le
+# profil étendu, créer, modifier, désactiver/réactiver, supprimer,
+# réinitialiser le mot de passe et le MFA.
+#
+# HUB-22 (#227, vague C du plan Hub v2.1) ajoute, sous la même garde et
+# avec la même journalisation, les routes « sessions » : lister les
+# sessions draco actives d'un compte, en révoquer une (par son `jti`,
+# jamais celle d'un autre compte) ou toutes (déconnexion globale, sans
+# désactiver le compte), via le registre des émissions de HUB-13.
+#
+# Emplacement : ``/api/admin/machine/comptes`` — dans l'espace
+# d'administration existant (``/api/admin/…``), avec un segment
+# ``machine`` explicite qui le distingue des routes d'administration par
+# session (``/api/auth/admin/users``, garde ``require_admin``). Aucune
+# session utilisateur — même administratrice — n'ouvre ces routes :
+# seule la clé machine dédiée les protège.
+#
+# Authentification machine (même famille que ``GET /api/sso/revocations``) :
+#   DRACO_ADMIN_MACHINE_KEY   clé dédiée à cette API (en-tête
+#                             ``X-Draco-Machine-Key``). Distincte de
+#                             ``DRACO_SSO_MACHINE_KEY`` : le périmètre
+#                             (écriture de comptes) est plus sensible que
+#                             la seule lecture des révocations (plan §3).
+#                             Sans elle, l'API est inerte (404, comme la
+#                             liste de révocations non configurée).
+#   X-Draco-Actor             identité de service appelante, facultative
+#                             (défaut ``service-machine``) — consignée
+#                             comme acteur dans le journal d'audit.
+#
+# Chaque action est journalisée côté ObsiGate dans le journal d'audit
+# existant (``data/audit.log``, voir backend.audit.log_compte_admin).
+
+from __future__ import annotations
+
+import hmac
+import logging
+import os
+import re
+import time
+from datetime import UTC, datetime
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel, validator
+
+from backend import draco_session
+from backend.audit import log_compte_admin
+from backend.auth.password import validate_password_strength
+from backend.auth.user_store import (
+    create_user,
+    delete_user,
+    get_all_users,
+    get_user,
+    update_user,
+)
+from backend.services.net import get_client_ip
+
+logger = logging.getLogger("obsigate.comptes_machine")
+
+router = APIRouter(prefix="/api/admin/machine/comptes", tags=["admin"])
+
+#: Variable d'environnement portant la clé machine dédiée à cette API.
+MACHINE_KEY_ENV = "DRACO_ADMIN_MACHINE_KEY"
+#: En-tête de la clé machine (même nom que pour /api/sso/revocations).
+MACHINE_KEY_HEADER = "X-Draco-Machine-Key"
+#: En-tête facultatif : identité de service appelante (journal d'audit).
+ACTOR_HEADER = "X-Draco-Actor"
+#: Acteur consigné quand l'appelant ne se nomme pas.
+DEFAULT_ACTOR = "service-machine"
+
+
+# ── Garde machine ───────────────────────────────────────────────────────
+
+def require_machine_admin(request: Request) -> str:
+    """Exige la clé machine dédiée ; retourne l'identité de service.
+
+    Jamais de repli sur une session utilisateur : sans en-tête valide,
+    la réponse est 401 (ou 404 si l'API n'est pas configurée, patron de
+    ``GET /api/sso/revocations``).
+    """
+    machine_key = os.environ.get(MACHINE_KEY_ENV, "")
+    if not machine_key:
+        raise HTTPException(404, "Non configuré")
+    provided = request.headers.get(MACHINE_KEY_HEADER, "")
+    if not provided or not hmac.compare_digest(provided, machine_key):
+        raise HTTPException(401, "Clé machine invalide")
+    actor = (request.headers.get(ACTOR_HEADER, "") or "").strip()
+    return actor[:64] if actor else DEFAULT_ACTOR
+
+
+# ── Profil étendu (liste blanche — jamais de secret) ────────────────────
+
+def _profil(user: dict) -> dict:
+    """Profil étendu d'un compte, sûr à exposer à un service.
+
+    Liste blanche stricte : ni ``password_hash``, ni secret TOTP
+    (``mfa_secret``/``mfa_secret_pending``), ni codes de récupération,
+    ni identifiants WebAuthn ne sortent — seul l'état MFA (oui/non)
+    est exposé. L'avatar suit le modèle existant : la valeur stockée
+    (data-URL ou ``None``, comme ``GET /api/auth/me``) plus le booléen
+    de présence ``avatar_present`` pour les listes légères.
+    """
+    return {
+        "id": user.get("id"),
+        "username": user.get("username"),
+        "display_name": user.get("display_name"),
+        "language": user.get("language", "fr"),
+        "avatar": user.get("avatar"),
+        "avatar_present": bool(user.get("avatar")),
+        "role": user.get("role"),
+        "active": bool(user.get("active")),
+        "vaults": user.get("vaults", []),
+        "mfa_enabled": bool(user.get("mfa_enabled")),
+        "mfa_method": user.get("mfa_method"),
+        "must_change_password": bool(user.get("must_change_password")),
+        "created_at": user.get("created_at"),
+        "last_login": user.get("last_login"),
+    }
+
+
+def _compte_ou_404(username: str) -> dict:
+    user = get_user(username)
+    if user is None:
+        raise HTTPException(404, "Compte introuvable")
+    return user
+
+
+def _identifiant_sessions(user: dict) -> str:
+    """Clé du registre des émissions draco pour un compte.
+
+    C'est le ``sub`` des jetons draco : l'identifiant du compte
+    (``id``), à défaut son nom d'utilisateur — exactement la clé
+    qu'utilise ``_revoquer_sessions`` depuis HUB-13.
+    """
+    return str(user.get("id") or user.get("username") or "")
+
+
+def _revoquer_sessions(user: dict) -> int:
+    """Révoque les sessions d'un compte ; retourne le nombre de jti draco.
+
+    Les ``jti`` du cookie partagé émis pour ce compte sont révoqués via
+    le mécanisme existant (``draco_session.revoke``, exposé aux autres
+    applications par ``GET /api/sso/revocations``). Les jetons natifs
+    sont invalidés par le garde ``password_changed_at`` (BUG-028),
+    avancé par l'appelant (désactivation, réinitialisation du mot de
+    passe) ou par le drapeau ``active`` tant que le compte est inactif.
+    """
+    return draco_session.revoke_all_for_user(_identifiant_sessions(user))
+
+
+def _audit(request: Request, acteur: str, action: str, cible: str,
+           details: dict | None = None) -> None:
+    log_compte_admin(acteur, action, cible,
+                     ip=get_client_ip(request), details=details)
+
+
+# ── Modèles de requête ──────────────────────────────────────────────────
+
+class CreerCompteRequest(BaseModel):
+    username: str
+    password: str
+    display_name: str | None = None
+    role: str = "user"
+    vaults: list[str] = []
+
+    @validator("password")
+    def password_valid(cls, v):
+        return validate_password_strength(v)
+
+    @validator("username")
+    def username_valid(cls, v):
+        if not re.match(r"^[a-zA-Z0-9_-]{2,32}$", v):
+            raise ValueError("2-32 caractères alphanumériques, _ ou -")
+        return v.lower()
+
+    @validator("role")
+    def role_valid(cls, v):
+        if v not in ("admin", "user"):
+            raise ValueError("Rôle invalide")
+        return v
+
+
+class ModifierCompteRequest(BaseModel):
+    display_name: str | None = None
+    role: str | None = None
+    language: str | None = None
+    vaults: list[str] | None = None
+
+    @validator("role")
+    def role_valid(cls, v):
+        if v is not None and v not in ("admin", "user"):
+            raise ValueError("Rôle invalide")
+        return v
+
+    @validator("language")
+    def language_valid(cls, v):
+        if v is not None and v not in ("fr", "en"):
+            raise ValueError("Langue invalide (fr | en)")
+        return v
+
+
+class ReinitialiserMotDePasseRequest(BaseModel):
+    password: str
+
+    @validator("password")
+    def password_valid(cls, v):
+        return validate_password_strength(v)
+
+
+# ── Lecture ─────────────────────────────────────────────────────────────
+
+@router.get("")
+async def lister_comptes(acteur: str = Depends(require_machine_admin)):
+    """Liste tous les comptes (profils étendus, sans aucun secret)."""
+    comptes = [_profil(u) for u in get_all_users()]
+    return {"comptes": comptes, "total": len(comptes)}
+
+
+@router.get("/{username}")
+async def lire_compte(username: str,
+                      acteur: str = Depends(require_machine_admin)):
+    """Lit un compte et son profil étendu."""
+    return _profil(_compte_ou_404(username))
+
+
+# ── Écriture ────────────────────────────────────────────────────────────
+
+@router.post("", status_code=201)
+async def creer_compte(req: CreerCompteRequest, request: Request,
+                       acteur: str = Depends(require_machine_admin)):
+    """Crée un compte. Le mot de passe initial est temporaire :
+    ``must_change_password`` est posé (changement forcé signalé à la
+    première connexion, comme après une réinitialisation)."""
+    if get_user(req.username) is not None:
+        raise HTTPException(409, "Identifiant déjà utilisé")
+    try:
+        user = create_user(
+            req.username, req.password, req.role, req.vaults,
+            req.display_name, must_change_password=True,
+        )
+    except ValueError as e:
+        raise HTTPException(409, str(e)) from e
+    # #194 : dossier personnel — même provisionnement que la création
+    # par session administratrice (best effort).
+    from backend.user_home import ensure_user_home
+
+    await ensure_user_home(req.username)
+    fresh = get_user(req.username)
+    if fresh:
+        user = fresh
+    _audit(request, acteur, "compte_cree", req.username,
+           {"role": req.role})
+    return _profil(user)
+
+
+@router.patch("/{username}")
+async def modifier_compte(username: str, req: ModifierCompteRequest,
+                          request: Request,
+                          acteur: str = Depends(require_machine_admin)):
+    """Modifie un compte (nom affiché, rôle global, langue, vaults)."""
+    _compte_ou_404(username)
+    updates = req.dict(exclude_none=True)
+    if not updates:
+        raise HTTPException(400, "Aucun champ à modifier")
+    updated = update_user(username, updates)
+    _audit(request, acteur, "compte_modifie", username,
+           {"champs": sorted(updates.keys())})
+    return _profil(updated)
+
+
+@router.post("/{username}/desactiver")
+async def desactiver_compte(username: str, request: Request,
+                            acteur: str = Depends(require_machine_admin)):
+    """Désactive un compte : plus aucun nouveau jeton n'est émis
+    (connexion refusée) et les ``jti`` draco actifs sont révoqués."""
+    user = _compte_ou_404(username)
+    updated = update_user(username, {
+        "active": False,
+        # BUG-028 : avancer le repère invalide aussi les jetons natifs
+        # déjà émis — ils ne ressuscitent pas à la réactivation.
+        "password_changed_at": time.time(),
+    })
+    nb_jti = _revoquer_sessions(user)
+    _audit(request, acteur, "compte_desactive", username,
+           {"jti_revoques": nb_jti})
+    return _profil(updated)
+
+
+@router.post("/{username}/reactiver")
+async def reactiver_compte(username: str, request: Request,
+                           acteur: str = Depends(require_machine_admin)):
+    """Réactive un compte désactivé (les anciennes sessions restent
+    révoquées : une nouvelle connexion est nécessaire)."""
+    _compte_ou_404(username)
+    updated = update_user(username, {"active": True})
+    _audit(request, acteur, "compte_reactive", username)
+    return _profil(updated)
+
+
+@router.delete("/{username}")
+async def supprimer_compte(username: str, request: Request,
+                           acteur: str = Depends(require_machine_admin)):
+    """Supprime un compte et révoque ses ``jti`` draco actifs."""
+    user = _compte_ou_404(username)
+    nb_jti = _revoquer_sessions(user)
+    try:
+        delete_user(username)
+    except ValueError as e:
+        raise HTTPException(404, str(e)) from e
+    # #194 : fermer le vault du dossier personnel (dossier conservé),
+    # comme la suppression par session administratrice.
+    from backend.user_home import release_user_home
+
+    await release_user_home(username)
+    _audit(request, acteur, "compte_supprime", username,
+           {"jti_revoques": nb_jti})
+    return {"message": f"Compte '{username}' supprimé"}
+
+
+@router.post("/{username}/reinitialiser-mot-de-passe")
+async def reinitialiser_mot_de_passe(
+        username: str, req: ReinitialiserMotDePasseRequest,
+        request: Request, acteur: str = Depends(require_machine_admin)):
+    """Pose un nouveau mot de passe temporaire : changement forcé à la
+    première connexion (``must_change_password``, signalé par la
+    connexion et ``GET /api/auth/me``, effacé au changement effectif).
+    Les sessions existantes sont révoquées (repère BUG-028 + ``jti``
+    draco). Le mot de passe n'est jamais journalisé."""
+    user = _compte_ou_404(username)
+    updated = update_user(username, {
+        "password": req.password,
+        "must_change_password": True,
+    })
+    nb_jti = _revoquer_sessions(user)
+    _audit(request, acteur, "mot_de_passe_reinitialise", username,
+           {"jti_revoques": nb_jti})
+    return _profil(updated)
+
+
+@router.post("/{username}/reinitialiser-mfa")
+async def reinitialiser_mfa(username: str, request: Request,
+                            acteur: str = Depends(require_machine_admin)):
+    """Efface l'enrôlement TOTP d'un compte (utilisateur verrouillé
+    hors de son second facteur) : secret, secret en attente et codes
+    de récupération sont supprimés. Les clés WebAuthn éventuelles sont
+    conservées et gardent alors le MFA actif. Le secret n'est jamais
+    exposé — ni avant, ni après."""
+    user = _compte_ou_404(username)
+    webauthn_restantes = len(user.get("webauthn_credentials") or [])
+    updates: dict = {
+        "mfa_secret": None,
+        "mfa_secret_pending": None,
+        "mfa_recovery_codes": [],
+    }
+    if webauthn_restantes:
+        updates["mfa_method"] = "webauthn"
+    else:
+        updates["mfa_enabled"] = False
+        updates["mfa_method"] = None
+    updated = update_user(username, updates)
+    _audit(request, acteur, "mfa_reinitialise", username,
+           {"webauthn_conserves": webauthn_restantes})
+    return _profil(updated)
+
+
+# ── Sessions draco (HUB-22) ─────────────────────────────────────────────
+
+@router.get("/{username}/sessions")
+async def lister_sessions(username: str,
+                          acteur: str = Depends(require_machine_admin)):
+    """Liste les sessions draco actives d'un compte.
+
+    Une session par ``jti`` émis et non expiré (registre des émissions
+    de HUB-13), triées par expiration croissante ; ``revoquee`` signale
+    un ``jti`` déjà présent dans la liste des révocations et
+    ``expire_le`` est l'échéance ``exp`` en ISO 8601 UTC.
+    """
+    user = _compte_ou_404(username)
+    sessions = [{
+        "jti": s["jti"],
+        "exp": s["exp"],
+        "expire_le": datetime.fromtimestamp(s["exp"], tz=UTC).isoformat(),
+        "revoquee": s["revoquee"],
+    } for s in draco_session.issued_sessions_for_user(
+        _identifiant_sessions(user))]
+    return {"username": username, "sessions": sessions}
+
+
+@router.post("/{username}/sessions/{jti}/revoquer")
+async def revoquer_session(username: str, jti: str, request: Request,
+                           acteur: str = Depends(require_machine_admin)):
+    """Révoque une seule session draco d'un compte, par son ``jti``.
+
+    404 si le ``jti`` ne figure pas dans l'ensemble actif de ce
+    compte : une session d'un autre utilisateur n'est jamais révoquée
+    par cette route (aucune révocation cross-utilisateur).
+    """
+    user = _compte_ou_404(username)
+    if not draco_session.revoke_one_for_user(
+            _identifiant_sessions(user), jti):
+        raise HTTPException(404, "Session introuvable")
+    _audit(request, acteur, "session_revoquee", username, {"jti": jti})
+    return {"jti": jti, "revoquee": True}
+
+
+@router.post("/{username}/sessions/revoquer-toutes")
+async def revoquer_toutes_sessions(
+        username: str, request: Request,
+        acteur: str = Depends(require_machine_admin)):
+    """Révoque toutes les sessions draco actives d'un compte.
+
+    C'est la « déconnexion globale » : contrairement à la
+    désactivation, le compte reste actif — seule l'émission d'une
+    nouvelle session (nouvelle connexion) rouvre l'accès.
+    """
+    user = _compte_ou_404(username)
+    nb_jti = _revoquer_sessions(user)
+    _audit(request, acteur, "sessions_revoquees", username,
+           {"jti_revoques": nb_jti})
+    return {"revoquees": nb_jti}
@@ -2626,7 +2626,7 @@ dependencies = [

 [[package]]
 name = "obsigate-desktop"
-version = "2.83.1"
+version = "2.85.2"
 dependencies = [
 "chrono",
 "env_logger",
@@ -1,6 +1,6 @@
 [package]
 name = "obsigate-desktop"
-version = "2.83.1"
+version = "2.85.2"
 description = "ObsiGate Desktop — Porte d'entrée native pour vos vaults Obsidian"
 authors = ["Bruno Charest"]
 edition = "2021"
@@ -1,7 +1,7 @@
 {
  "$schema": "https://raw.githubusercontent.com/nicedoc/obsigate/main/desktop/tauri.conf.schema.json",
  "productName": "ObsiGate",
-  "version": "2.83.1",
+  "version": "2.85.2",
  "identifier": "com.obsigate.desktop",
  "build": {
    "frontendDist": "../frontend",
@@ -1,6 +1,6 @@
 # ObsiGate — Roadmap

-> **Version :** 2.83.1 | **Dernière mise à jour :** 2026-11-03
+> **Version :** 2.85.2 | **Dernière mise à jour :** 2026-11-06
 > **Ce fichier ne contient que le travail à venir** (🔵 En cours + ⚪ Backlog) et un index compact
 > vers les fonctionnalités livrées.
 > - **Méthode de livraison à appliquer pour toute tâche : [DELIVERY_WORKFLOW.md](./DELIVERY_WORKFLOW.md)**
@@ -30,6 +30,86 @@

 ## 🔵 En cours

+### 227. Hub HUB-22 — API machine des sessions draco (liste et révocation)
+
+- **Effort :** ~0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-11-06 | **Statut :** ✅ livré en 2.85.0 (PR #68 fusionnée et release publiée — voir CHANGELOG ; redéploiement Docker requis)
+- **Fiche :** [features/hub-sessions-machine-227.md](./features/hub-sessions-machine-227.md)
+- **Description :** vague C du plan Hub v2.1 (HUB-22) : le Hub doit lister
+  les sessions actives d'un utilisateur et les révoquer une à une ou
+  toutes, via le canal `jti` livré en HUB-13 (#226). Trois routes sous
+  la même garde machine (`require_machine_admin`) et la même
+  journalisation d'audit que les routes comptes existantes :
+  `GET /api/admin/machine/comptes/{username}/sessions`,
+  `POST …/sessions/{jti}/revoquer` (jamais de révocation
+  cross-utilisateur) et `POST …/sessions/revoquer-toutes`
+  (déconnexion globale, sans désactiver le compte).
+- **Sous-tâches :**
+  - [x] `issued_sessions_for_user` + `revoke_one_for_user` (`backend/draco_session.py`)
+  - [x] Trois routes sessions (`backend/routers/comptes_machine.py`)
+  - [x] Tests étendus (`tests/test_comptes_machine.py`, `tests/test_draco_session.py`)
+### 228. Hub HUB-19 — propagation des rôles du Hub à ObsiGate (consommatrice)
+
+- **Effort :** ~0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-11-06 | **Statut :** ✅ livré en 2.85.1 (voir CHANGELOG ; branche rebasée sur la 2.85.0 avant fusion ; redéploiement Docker requis)
+- **Fiche :** [features/hub-roles-obsigate-228.md](./features/hub-roles-obsigate-228.md)
+- **Description :** suite de HUB-19 (plan Hub v2 §2.2, décision D3(a)) : le
+  pilote ShaarIt (0.7.0, en production) a posé le contrat ; ObsiGate —
+  à la fois émettrice et consommatrice du SSO — le consomme à son tour.
+  À l'ouverture de session draco, consultation de
+  `GET {hub}/api/roles/obsigate` (Cookie relayé, délai 2 s), cache
+  mémoire 60 s par `sub` (horodatage posé avant l'appel). Niveau connu
+  `aucun` → session draco refusée (réponse explicite en français) ;
+  routes `/api/auth/admin/*` authentifiées par le canal draco :
+  niveau `administrateur` exigé quand le rôle est connu. Toute erreur
+  du Hub → rôle inconnu → comportement actuel. L'authentification
+  native d'ObsiGate (émettrice, accès de secours) n'est jamais touchée ;
+  validation locale du jeton, émission et révocations inchangées,
+  aucun rôle dans le jeton.
+- **Sous-tâches :**
+  - [x] Client `backend/hub_roles.py` (contrat D3(a), cache/repli, URL du Hub résolue comme la barre — `draco_config.app_url("hub")`)
+  - [x] Refus « aucun » dans `draco_session.user_for_draco` + réponse explicite de `require_auth`
+  - [x] Garde `require_admin_hub` sur les routes `/api/auth/admin/*`
+  - [x] Tests `tests/test_hub_roles.py` (client + intégration du chemin draco)
+
+### 229. Hub HUB-21 — consommation des réglages généraux du Hub par ObsiGate
+
+- **Effort :** ~0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-11-06 | **Statut :** ✅ livré en 2.85.2 (voir CHANGELOG ; PR en attente de fusion ; redéploiement Docker requis)
+- **Fiche :** [features/hub-reglages-obsigate-229.md](./features/hub-reglages-obsigate-229.md)
+- **Description :** propagation de HUB-21 (pilote TikTak 0.61.22, liste
+  fermée D6(a)) : consultation côté serveur de
+  `GET {hub}/api/reglages/effectifs` (endpoint public, délai 2 s),
+  cache mémoire 60 s (horodatage posé avant l'appel), repli intégral
+  sur les défauts actuels si le Hub est muet, en erreur ou de forme
+  inattendue. Bannière d'annonce injectée sous la barre commune (page
+  principale et /recherche, texte échappé, fermable, masquage
+  mémorisé en `sessionStorage`) ; drapeau `recherche_partout` rendu
+  en `data-recherche-partout` de la page /recherche — faux = partie
+  fédérée désactivée, recherche locale intacte. `domaine_defaut`
+  **non consommé** : pas de notion de domaine propre à ObsiGate (le
+  sélecteur de la barre pilote le panneau Spark).
+- **Sous-tâches :**
+  - [x] Client `backend/hub_reglages.py` (forme D6(a), cache/repli, URL du Hub résolue comme la barre — `draco_config.app_url("hub")`)
+  - [x] Bannière injectée (`backend/main.py::_fragment_banniere_hub`, `_index_html`, `serve_recherche_page`) + styles `frontend/style.css`
+  - [x] Jeton `{{RECHERCHE_PARTOUT}}` dans `frontend/recherche.html` + branchement du JS vendangé `frontend/js/recherche.js`
+  - [x] Tests `tests/test_hub_reglages.py` (client + intégration) et `tests/frontend/recherche.test.mjs` étendu
+
+### 226. Hub HUB-13 — API d'administration des comptes (machine-à-machine)
+
+- **Effort :** ~0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-11-05 | **Statut :** ✅ livré en 2.84.0 (PR en attente de fusion — voir CHANGELOG ; redéploiement Docker requis)
+- **Fiche :** [features/hub-api-admin-comptes-226.md](./features/hub-api-admin-comptes-226.md)
+- **Description :** carte fusion #127 (plan Hub v2 §2.2, D1(a)/D2(a)) : le Hub
+  administre les comptes dont ObsiGate reste le magasin, via
+  `/api/admin/machine/comptes` (liste, profil étendu, création,
+  modification, désactivation/réactivation avec révocation des `jti`
+  draco, suppression, réinitialisation du mot de passe avec changement
+  forcé `must_change_password`, réinitialisation du MFA), protégée par
+  la clé machine dédiée `DRACO_ADMIN_MACHINE_KEY` — jamais par une
+  session. Chaque action est journalisée dans `data/audit.log`.
+- **Sous-tâches :**
+  - [x] Routes machine lecture/écriture + garde par clé dédiée (`backend/routers/comptes_machine.py`)
+  - [x] Registre des émissions draco + `revoke_all_for_user` (`backend/draco_session.py`)
+  - [x] Champ `must_change_password` (modèle, connexion, `/me`, changement de mot de passe)
+  - [x] Journalisation `log_compte_admin` (`backend/audit.py`) + tests `tests/test_comptes_machine.py`
+
 ### 225. Fusion — panneau Spark : version du service d'agents visible en mode sidebar

 - **Effort :** ~0,1 jour | **Impact :** 🟢 | **Ouvert :** 2026-10-26 | **Statut :** ✅ livré le 2026-10-26 (version du hook — voir CHANGELOG ; redéploiement Docker requis)
@@ -0,0 +1,105 @@
+# #226 — HUB-13 : API d'administration des comptes (machine-à-machine)
+
+**Carte :** fusion #127 (HUB-13, plan Hub v2 §2.2 et §4 vague A ; décisions
+D1(a) — magasin des comptes chez ObsiGate — et D2(a) — ObsiGate émettrice).
+**Version :** 2.84.0.
+
+## Objet
+
+Le Hub administre les comptes de la suite depuis son interface
+d'administration ; ObsiGate reste le magasin des comptes. Cette API est
+le bras armé de cette interface : administration complète des comptes,
+en lecture et en écriture, réservée aux appels machine-à-machine.
+
+## Routes — `/api/admin/machine/comptes`
+
+Emplacement choisi : l'espace d'administration existant (`/api/admin/…`),
+segment `machine` explicite. Il distingue ces routes de l'administration
+par session (`/api/auth/admin/users`, garde `require_admin`) : aucune
+session utilisateur, même administratrice, ne les ouvre.
+
+| Méthode | Chemin | Effet |
+|---|---|---|
+| GET | `/api/admin/machine/comptes` | Liste des comptes (profils étendus) |
+| GET | `/api/admin/machine/comptes/{username}` | Profil étendu d'un compte |
+| POST | `/api/admin/machine/comptes` | Création (201 ; 409 si identifiant pris) |
+| PATCH | `/api/admin/machine/comptes/{username}` | Modification (nom affiché, rôle global, langue, vaults) |
+| POST | `/api/admin/machine/comptes/{username}/desactiver` | Désactivation + révocation des sessions |
+| POST | `/api/admin/machine/comptes/{username}/reactiver` | Réactivation |
+| DELETE | `/api/admin/machine/comptes/{username}` | Suppression + révocation des sessions |
+| POST | `/api/admin/machine/comptes/{username}/reinitialiser-mot-de-passe` | Nouveau mot de passe temporaire, changement forcé |
+| POST | `/api/admin/machine/comptes/{username}/reinitialiser-mfa` | Effacement de l'enrôlement TOTP |
+
+Codes : 401 sans clé machine valide, 404 compte inconnu (ou API non
+configurée), 409 conflit d'identifiant, 422 corps invalide.
+
+## Protection
+
+- Clé machine **dédiée** : `DRACO_ADMIN_MACHINE_KEY`, en-tête
+  `X-Draco-Machine-Key` (même famille et même en-tête que
+  `GET /api/sso/revocations`). Distincte de `DRACO_SSO_MACHINE_KEY` :
+  l'écriture de comptes est plus sensible que la lecture des
+  révocations (plan §3). Comparaison à temps constant.
+- Sans la variable, l'API est inerte (404 « Non configuré »).
+- Acteur consigné : en-tête facultatif `X-Draco-Actor` (défaut
+  `service-machine`).
+
+## Profil étendu
+
+Liste blanche stricte : `id`, `username`, `display_name`, `language`,
+`avatar` (valeur du modèle — data-URL ou `null`, comme
+`GET /api/auth/me`) et `avatar_present`, `role`, `active`, `vaults`,
+`mfa_enabled` (oui/non), `mfa_method`, `must_change_password`,
+`created_at`, `last_login`. **Jamais** le haché du mot de passe, le
+secret TOTP, les codes de récupération ni les identifiants WebAuthn.
+
+## Désactivation et sessions
+
+- `active = false` → la connexion est refusée (401 uniforme, BUG-039)
+  et plus aucun jeton n'est émis.
+- Les `jti` draco émis pour le compte sont révoqués via le mécanisme
+  existant (`draco_session.revoke`, liste publiée par
+  `GET /api/sso/revocations`). Pour les connaître, `draco_session`
+  tient désormais un registre des émissions (`data/draco_issued.json`,
+  `jti → exp` par `sub`, purgé à l'expiration) et
+  `revoke_all_for_user(sub)`.
+- Le repère `password_changed_at` (BUG-028) est avancé : les jetons
+  natifs déjà émis sont invalidés et ne ressuscitent pas à la
+  réactivation. Les anciennes sessions draco restent révoquées après
+  réactivation : une nouvelle connexion est nécessaire.
+
+## Changement forcé du mot de passe
+
+Nouveau champ du modèle utilisateur : `must_change_password` (booléen,
+défaut `false` — ajouté par `create_user`, aucun fichier à migrer :
+les comptes existants sans le champ valent `false`). Posé à la
+création machine et à la réinitialisation du mot de passe ; signalé
+dans la réponse de connexion et `GET /api/auth/me` ; effacé par
+`POST /api/auth/change-password`.
+
+## Réinitialisation du MFA
+
+Efface `mfa_secret`, `mfa_secret_pending` et `mfa_recovery_codes`.
+Les clés WebAuthn éventuelles sont conservées et gardent le MFA
+actif (méthode `webauthn`) ; sans elles, `mfa_enabled` passe à `false`.
+
+## Journalisation
+
+Chaque action est consignée dans le journal d'audit existant
+(`data/audit.log`, JSON lignes) via `backend.audit.log_compte_admin` :
+horodatage, `acteur` (identité de service), `action` (`compte_cree`,
+`compte_modifie`, `compte_desactive`, `compte_reactive`,
+`compte_supprime`, `mot_de_passe_reinitialise`, `mfa_reinitialise`),
+`cible` (compte visé), IP et détails non sensibles (champs modifiés,
+nombre de `jti` révoqués — jamais de mot de passe ni de secret).
+
+## Tests
+
+`tests/test_comptes_machine.py` : refus sans clé / mauvaise clé / clé
+SSO / session admin, API inerte non configurée, liste et profil étendu
+sans secret, création puis lecture et connexion, doublon 409,
+modification, désactivation (connexion refusée, session native
+refusée, `jti` draco révoqué et publié) puis réactivation,
+réinitialisation du mot de passe (ancien refusé, nouveau accepté,
+changement forcé signalé puis effacé au changement), réinitialisation
+MFA (connexion directe après), suppression, journalisation.
@@ -0,0 +1,82 @@
+# #229 — HUB-21 : consommation des réglages généraux du Hub par ObsiGate
+
+**Carte :** propagation de HUB-21 (fusion #135) — le pilote TikTak
+(0.61.22, en production) a posé le patron de client ; ObsiGate le
+consomme à son tour, comme les autres hôtes de la suite.
+**Version cible :** 2.85.2 (branche depuis le main 2.85.1).
+
+## Contrat consommé (liste fermée D6(a))
+
+- `GET {hub}/api/reglages/effectifs` — endpoint **public** (aucun
+  cookie relayé), `Accept: application/json`, délai **2 s** ;
+- réponse 200, forme figée : `{"recherche_partout": bool,
+  "banniere": str, "domaine_defaut": "pro"|"famille"|"perso"|null,
+  "ttl_secondes": 60}`, `Cache-Control: public, max-age=60` ;
+- **URL du Hub** : `draco_config.app_url("hub")`, la résolution de la
+  barre commune (#223) — variable explicite d'abord, dérivation par
+  l'hôte sœur ensuite, défaut officiel enfin. Jamais d'URL dev figée.
+
+## Client — `backend/hub_reglages.py`
+
+Sur le patron du pilote TikTak (`app/hub_reglages.py`, httpx → urllib
+comme `backend/hub_roles.py`) :
+
+- cache mémoire **60 s** ; horodatage posé **avant** l'appel : un
+  échec conserve l'ancien cache et ne déclenche pas de rafale vers un
+  Hub en panne ;
+- forme validée strictement ; toute erreur (réseau, délai, statut
+  ≠ 200, JSON illisible, forme hors contrat) → **repli intégral** sur
+  les défauts actuels (`recherche_partout: true`, `banniere: ""`,
+  `domaine_defaut: null`) — le comportement d'ObsiGate avant HUB-21.
+  Le module ne lève jamais ; aucun appel au démarrage.
+
+## Consommation
+
+1. **`banniere`** — `backend/main.py::_fragment_banniere_hub()`
+   construit le fragment (texte **échappé** via `html.escape`, jamais
+   de HTML injecté), injecté sous la barre commune par `_index_html`
+   (page principale, juste avant le rappel de la barre) et par
+   `serve_recherche_page` (page /recherche, après l'en-tête de la
+   barre). Le script inline (nonce CSP ajouté par `inject_csp_nonce`)
+   révèle le bandeau sauf si le même texte a été fermé dans la
+   session du navigateur (`sessionStorage`, clé
+   `obsigate_banniere_masquee`) : une nouvelle annonce réapparaît.
+   Bannière vide = aucun fragment rendu, zéro changement visuel.
+   Styles `.banniere-hub*` dans `frontend/style.css`, sur les
+   variables du thème (`var(--accent)`).
+2. **`recherche_partout`** — `serve_recherche_page` remplace le jeton
+   `{{RECHERCHE_PARTOUT}}` de `frontend/recherche.html`, rendu en
+   attribut `data-recherche-partout` du `<main id="recherche">`. Le
+   JS vendangé `frontend/js/recherche.js` (modification identique
+   dans les 4 hôtes applicatifs : fonction pure
+   `federationAutorisee`) n'interroge plus les applications sœurs ni
+   la console quand la valeur est `false` — leurs sections affichent
+   « Recherche fédérée désactivée… » — tandis que la recherche locale
+   ObsiGate (même origine) continue. Attribut absent ou illisible =
+   fédération active (repli).
+3. **`domaine_defaut` — non consommé.** ObsiGate n'a pas de notion
+   de domaine (Pro/Famille/Perso) propre à ses vues : le sélecteur de
+   domaine de la barre commune pilote le panneau Spark, pas
+   ObsiGate. La valeur est lue et validée par le client, sans effet
+   local. Seul l'hôte console (agent) applique ce réglage.
+
+## i18n
+
+Aucun texte d'interface du SPA n'est ajouté : la bannière est un
+contenu d'annonce servi par le Hub (texte libre de l'administrateur),
+et le libellé « Fermer l'annonce » est l'attribut d'accessibilité du
+fragment injecté côté serveur, sur le même patron que les autres
+hôtes. Pas de clé `frontend/locales/*` ajoutée.
+
+## Tests
+
+- `tests/test_hub_reglages.py` (nouveau) : contrat exact de l'appel
+  (URL, aucun cookie, délai 2 s), formes inattendues → repli, erreur
+  HTTP / Hub injoignable / JSON illisible → repli, cache 60 s,
+  ancien cache conservé sans rafale ; intégration TestClient :
+  bannière présente et échappée sur `/` et `/recherche`, absente si
+  vide ou Hub muet, `data-recherche-partout` selon la valeur du
+  drapeau (faux / vrai / Hub muet).
+- `tests/frontend/recherche.test.mjs` : assertions ajoutées pour
+  `federationAutorisee` (seules les valeurs explicitement négatives
+  désactivent ; absent/illisible = actif).
@@ -0,0 +1,77 @@
+# #228 — HUB-19 : propagation des rôles du Hub à ObsiGate
+
+**Carte :** suite de HUB-19 (plan Hub v2 §2.2, décision D3(a)) — le pilote
+ShaarIt (0.7.0, en production) a posé le contrat ; ObsiGate le consomme à
+son tour, comme hôte à la fois **émettrice** et **consommatrice** du SSO.
+**Version cible :** 2.85.1 (branche depuis le main 2.84.1 ; hypothèse : à
+rebaser après la PR « API sessions HUB-22 » — 2.85.0 — si elle fusionne
+d'abord).
+
+## Contrat consommé (D3(a))
+
+À l'ouverture de session draco — chez ObsiGate : la validation locale du
+cookie partagé, `draco_session.user_for_draco()` (ACC-3.2, #217), appelée
+par le repli draco de `get_current_user` — consultation du registre :
+
+- `GET {hub}/api/roles/obsigate`, en-tête **Cookie complet** de la requête
+  relayé tel quel, `Accept: application/json`, délai **2 s** ;
+- réponse 200 : `{"app", "sub", "role", "explicite", "ttl_secondes": 60}`,
+  `role` ∈ {`aucun`, `utilisateur`, `administrateur`} ;
+- **URL du Hub** : `draco_config.app_url("hub")`, la résolution de la
+  barre commune (#223) — `DRACO_HUB_URL` explicite d'abord, dérivation
+  par l'hôte sœur (suffixe d'environnement de l'hôte de l'agent)
+  ensuite, défaut officiel enfin. Jamais d'URL dev figée.
+
+## Client — `backend/hub_roles.py`
+
+Sur le patron du pilote (`src/hub_roles.rs` de ShaarIt) :
+
+- cache mémoire par `sub`, TTL **60 s** ;
+- horodatage posé **avant** l'appel : un échec conserve l'ancien cache
+  et ne déclenche pas de rafale vers un Hub en panne ;
+- toute erreur (réseau, délai, statut ≠ 200, JSON illisible, rôle hors
+  contrat) → rôle **inconnu** (`None`) → l'appelant garde son
+  comportement actuel. Le registre ne crée jamais un verrouillage
+  nouveau.
+
+## Effets (sessions établies par draco seulement)
+
+1. **Niveau connu `aucun`** → `user_for_draco` refuse : pas de session
+   établie par draco. `require_auth` répond alors **403** avec un
+   message explicite en français (niveau « aucun », matrice des rôles
+   du Hub, accès natif toujours possible), consigné via
+   `request.state.role_hub_refuse`. L'**authentification native**
+   d'ObsiGate (son propre login — c'est l'émettrice, son accès propre
+   est le secours) n'est **jamais** touchée.
+2. **Routes d'administration `/api/auth/admin/*`** (CRUD des comptes,
+   `backend/auth/router.py`) : nouvelle garde `require_admin_hub`
+   (`backend/auth/middleware.py`) = `require_admin` + , quand la
+   requête est authentifiée par le **canal draco** (`_draco_sub`
+   présent, `_hub_role` joint par `user_for_draco`) et que le rôle est
+   **connu**, exigence du niveau `administrateur` du registre.
+   Sessions natives → règles actuelles inchangées ; rôle inconnu →
+   règles actuelles inchangées. Le registre n'élève aucun privilège :
+   un compte local non admin reste refusé par la règle locale, quel
+   que soit son niveau au Hub.
+3. **Inchangés** : validation locale du jeton, émission du cookie,
+   révocations (`jti`), renouvellement glissant. **Aucun rôle dans le
+   jeton** (claims minimaux de #216 préservés).
+
+Périmètre assumé : la garde du registre vise les routes nommées par la
+carte, `/api/auth/admin/*`. Les autres surfaces gardées par
+`require_admin` (configuration, vaults, coffres…) gardent leurs règles
+actuelles ; les y soumettre serait un changement d'une ligne par
+surface (`require_admin_hub` est réutilisable tel quel) si Bruno le
+décide.
+
+## Tests
+
+`tests/test_hub_roles.py` : parsing du contrat (URL, Cookie relayé,
+`Accept`, délai 2 s), rôles reconnus / hors contrat, JSON illisible,
+erreurs HTTP et réseau → inconnu ; résolution de l'URL du Hub
+(explicite, dérivée `-dev`, défaut officiel) ; cache par `sub`, TTL,
+échec sans rafale avec ancien cache conservé ; intégration sur le
+chemin draco (refus « aucun » explicite, login natif intact sous
+« aucun », rôle inconnu = comportement actuel, `utilisateur` Hub
+refusé sur `/api/auth/admin/*`, `administrateur` Hub accepté, compte
+local non admin non élevé, session native jamais bloquée par le Hub).
@@ -0,0 +1,85 @@
+# #227 — HUB-22 : API machine des sessions draco (liste et révocation)
+
+**Carte :** vague C du plan Hub v2.1 (HUB-22) — le Hub consomme ces
+routes en 0.17.0 pour l'écran des sessions d'un utilisateur.
+**Version :** 2.85.0. **Prérequis :** HUB-13 (#226) — registre des
+émissions `jti` et garde machine.
+
+## Objet
+
+Le Hub doit lister les sessions actives d'un utilisateur et les
+révoquer une à une ou toutes, via le canal `jti` livré en HUB-13.
+Aucune route machine « sessions » n'existait : cette livraison la crée,
+sous la même garde (`require_machine_admin`, clé
+`DRACO_ADMIN_MACHINE_KEY`, en-têtes `X-Draco-Machine-Key` /
+`X-Draco-Actor`) et avec la même journalisation d'audit que les routes
+comptes existantes. Sans la clé configurée, l'API reste inerte (404) ;
+sans clé valide, 401.
+
+## Routes — `/api/admin/machine/comptes/{username}/sessions`
+
+| Méthode | Chemin | Effet |
+|---|---|---|
+| GET | `/api/admin/machine/comptes/{username}/sessions` | Sessions actives du compte |
+| POST | `/api/admin/machine/comptes/{username}/sessions/{jti}/revoquer` | Révocation d'une session |
+| POST | `/api/admin/machine/comptes/{username}/sessions/revoquer-toutes` | Révocation de toutes les sessions |
+
+Codes : 401 sans clé machine valide, 404 compte inconnu (ou API non
+configurée), 404 `jti` absent de l'ensemble actif du compte.
+
+### Liste — `GET …/sessions`
+
+`200 {"username": …, "sessions": [{"jti", "exp", "expire_le",
+"revoquee"}]}` — une entrée par `jti` émis et non expiré, triée par
+`exp` croissant ; `expire_le` est l'échéance en ISO 8601 UTC et
+`revoquee` signale un `jti` déjà présent dans la liste des
+révocations.
+
+### Révocation unitaire — `POST …/sessions/{jti}/revoquer`
+
+`200 {"jti", "revoquee": true}`. Le `jti` n'est révoqué que s'il
+appartient à l'ensemble émis du compte visé et n'est pas expiré :
+**404 sinon, jamais de révocation cross-utilisateur**.
+
+### Tout révoquer — `POST …/sessions/revoquer-toutes`
+
+`200 {"revoquees": n}` — réutilise `revoke_all_for_user` de HUB-13.
+C'est la « déconnexion globale », **distincte de la désactivation** :
+le compte reste actif, une nouvelle connexion émet une nouvelle
+session.
+
+## Backend — `backend/draco_session.py`
+
+- `issued_sessions_for_user(sub)` : sessions actives
+  (`exp > maintenant`) du `sub`, `[{jti, exp, revoquee}]` triées par
+  `exp` croissant ; les entrées expirées du `sub` sont purgées du
+  registre au passage.
+- `revoke_one_for_user(sub, jti)` : révoque via le `revoke()`
+  existant uniquement si le `jti` appartient à l'ensemble émis de ce
+  `sub` et n'est pas expiré ; retourne un booléen.
+
+La clé du registre est le même `sub` que celui de HUB-13
+(`_identifiant_sessions` dans `comptes_machine.py` : `id` du compte,
+à défaut `username`) — factorisée depuis `_revoquer_sessions`, qui
+l'utilise aussi désormais.
+
+## Journalisation
+
+Les deux écritures sont consignées dans `data/audit.log` via
+`log_compte_admin` : actions `session_revoquee` (détail : le `jti`) et
+`sessions_revoquees` (détail : nombre de `jti` révoqués), acteur =
+identité de service `X-Draco-Actor`. La lecture suit le patron des
+lectures existantes (non journalisée).
+
+## Tests
+
+- `tests/test_draco_session.py` : liste triée et marquage `revoquee`,
+  purge des expirés, révocation unitaire, refus cross-utilisateur,
+  refus d'un `jti` expiré ; le registre des émissions est isolé en
+  fichier temporaire dans la fixture.
+- `tests/test_comptes_machine.py` (`TestSessions`) : liste (contenu,
+  `expire_le` ISO 8601 UTC), liste vide, compte inconnu 404,
+  révocation unitaire (succès + effet sur `verify_token`),
+  cross-utilisateur 404 sans effet, tout-révoquer (compte toujours
+  actif, autres comptes intacts, seconde passe à 0), garde (401 sans
+  clé, 404 API non configurée), journalisation.
@@ -1214,6 +1214,30 @@
  function initTheme() {
    const saved = localStorage.getItem("obsigate-theme") || "dark";
    applyTheme(saved);
+    // Thème commun de la suite (HUB-18, fusion #132) : la barre
+    // commune (barre v0.5.0) applique la préférence du Hub
+    // (sombre/clair/système) à l'ouverture — directement sur
+    // data-theme, et via l'événement « draco:theme » pour que le
+    // mécanisme propre d'ObsiGate suive (icône et libellé du bouton,
+    // feuilles highlight.js). applyTheme mémorise le mode appliqué
+    // dans « obsigate-theme » : la préférence du Hub devient le
+    // choix local courant, et le bouton de bascule reste le maître
+    // pour la suite de la session (aucune ré-application de la barre
+    // après l'ouverture). « systeme » arrive déjà résolu en mode
+    // effectif (detail.mode) par la barre. Repli : si le Hub ne
+    // répond pas, aucun événement n'arrive et le choix local
+    // ci-dessus reste seul maître, comme avant.
+    document.addEventListener("draco:theme", (e) => {
+      const mode = e && e.detail && e.detail.mode;
+      if (mode === "dark" || mode === "light") applyTheme(mode);
+    });
+    // Si la barre s'est initialisée AVANT ce module (ordre des
+    // scripts defer/module selon la page), sa préférence déjà
+    // résolue depuis son cache est reprise ici.
+    const barre = window.DRACO_BAR;
+    if (barre && (barre.themeMode === "dark" || barre.themeMode === "light")) {
+      applyTheme(barre.themeMode);
+    }
  }

  function applyTheme(theme) {
@@ -20,7 +20,18 @@
   le clair via data-theme="light" héritait quand même du sombre
   système (piège constaté dans les copies vendangées de
   Kanbante/Flowdeck ; les re-vendanges de la v0.2.0 le corrigent).
+   v0.3.0 (HUB-1) : aucun style nouveau — les liens du Hub du menu
+   compte (Télécharger, À Propos, Aides, Profil) réutilisent
+   .draco-menu-item (déjà ancre-compatible : text-decoration none)
+   et le séparateur .draco-menu-sep du menu des applications.
+   v0.4.0 (HUB-11) : .draco-menu-icone — les icônes monoline des
+   items du menu compte (SVG inline construit par le JS) : 18 px,
+   replacées à gauche du libellé par order: -1 (l'item est en
+   flex), couleur atténuée --ink-2, pleine --ink au survol/focus.
   Jetons repris du prototype validé Console v7.2.
+   v0.4.1 (fusion #125) : menu compte resserré — min-width
+   248 → 232 px, le panneau épouse le contenu (demande de Bruno :
+   le menu était trop large une fois les icônes visibles).
   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
   (aucun attribut data-theme sur <html>). */
@@ -78,7 +89,7 @@
 * 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;
+  min-width: 232px; padding: 6px;
  background: var(--surface); border: 1px solid var(--line); border-radius: 14px;
  box-shadow: 0 16px 44px rgb(0 0 0 / .28);
 }
@@ -90,6 +101,15 @@
  text-decoration: none; cursor: pointer;
 }
 .draco-menu-item:hover, .draco-menu-item:focus-visible { background: var(--surface-2); }
+/* Icônes monoline du menu compte (v0.4.0) : appendues après le
+   libellé dans le DOM, replacées à gauche par order: -1. */
+.draco-menu-icone {
+  order: -1; flex: none; display: inline-flex; align-items: center;
+  width: 18px; height: 18px; color: var(--ink-2);
+}
+.draco-menu-icone svg { display: block; width: 18px; height: 18px; }
+.draco-menu-item:hover .draco-menu-icone,
+.draco-menu-item:focus-visible .draco-menu-icone { color: var(--ink); }
 .draco-menu-sep { height: 1px; margin: 6px 10px; background: var(--line); }
 .draco-compte-nom {
  padding: 8px 10px 10px; font-weight: 700; font-size: 14px;
@@ -14,6 +14,34 @@
 * contrat que les autres apps), entrée APP_LABELS ; l'onglet
 * (data-app="shaarit", après Kanbante, avant agent) est repris
 * automatiquement par la construction du menu de la marque.
+ * v0.3.0 (carte HUB-1, fusion #115) : le Hub, point central de la
+ * suite — nouvelle clé d'URL « hub » (jeton {{URL_HUB}} côté hôte,
+ * DRACO_BAR_CONFIG.urls.hub), défaut officiel
+ * https://hub.dracodev.net/, dérivation -dev hub-dev comme les
+ * sœurs. Le menu compte gagne trois vrais liens (patron
+ * buildAppsMenu : <a href>, classe draco-menu-item) — Télécharger
+ * → <hub>/telecharger, À Propos → <hub>/a-propos, Aides →
+ * <hub>/aide — et « Profil » devient lui aussi un lien, vers
+ * <hub>/profil (il n'est plus relayé aux hôtes : un seul Profil,
+ * celui du Hub). « Déconnexion » reste l'action relayée
+ * (data-compte-act="deconnexion" / onAction), inchangée.
+ * refreshMenuHrefs() resynchronise aussi les liens du Hub à
+ * l'ouverture des menus. Le Hub n'a pas d'onglet dans la barre :
+ * comme spark, sa clé est résolue et exposée via DRACO_BAR.urls,
+ * sans étape « href rendu » (voir « URL » ci-dessous).
+ * v0.4.0 (carte HUB-11, fusion #125) : icônes monoline dans le
+ * menu compte — chaque item (les 4 liens du Hub et « Déconnexion »)
+ * reçoit un glyphe SVG inline dans le style des icônes du rail de
+ * la console (contour, trait fin régulier, currentColor, aucun
+ * remplissage), aligné à gauche du libellé via .draco-menu-icone.
+ * L'en-tête d'identité ne reçoit pas d'icône. Aucun changement de
+ * comportement : liens résolus et Déconnexion relayée inchangés.
+ * v0.5.0 (carte HUB-18, fusion #132) : thème commun de la suite —
+ * la barre apprend la préférence de thème du profil du Hub
+ * (GET <hub>/api/profil/theme, cookie draco) et l'applique à
+ * l'ouverture par le mécanisme data-theme des hôtes, avec cache
+ * local court et repli intégral sur le comportement actuel de
+ * l'hôte si le Hub ne répond pas. Voir « Thème commun » plus bas.
 *
 * 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
@@ -33,7 +61,8 @@
 *       kanbante: "https://kanbante.dracodev.net/",
 *       shaarit:  "https://shaarit.dracodev.net/",
 *       agent:    "https://agent.dracodev.net/",
- *       spark:    "https://spark.dracodev.net/"
+ *       spark:    "https://spark.dracodev.net/",
+ *       hub:      "https://hub.dracodev.net/"
 *     },
 *     onAction: function (act, el) { … }      // l'app relaie les actions
 *   }                                          // qu'elle ne connaît pas
@@ -67,6 +96,12 @@
 * la marque et DRACO_BAR.urls. Même résolution pour shaarit (v0.2.0) :
 * explicite > dérivation -dev shaarit-dev > href rendu
 * ({{URL_SHAARIT}}) > défaut officiel.
+ * Cas hub (v0.3.0) : PAS d'onglet, donc pas d'étape « href rendu » —
+ * explicite (DRACO_BAR_CONFIG.urls.hub, alimenté par le jeton
+ * {{URL_HUB}} remplacé côté serveur par l'hôte) > dérivation -dev
+ * hub-dev sur hôte -dev > défaut officiel
+ * https://hub.dracodev.net/. La base résolue sert les quatre liens
+ * du menu compte (telecharger, a-propos, aide, profil).
 * Actions émises (data-act) : rail, palette, domaine (data-dom),
 * alertes, spark, rappel-entete. L'app intégratrice décide de chacune
 * (ouvrir la palette, le panneau Spark, changer de domaine…).
@@ -141,6 +176,14 @@
 * 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.
+ * Menu compte (v0.3.0) — Profil n'est PLUS relayé : c'est un lien
+ * vers <hub>/profil, comme Télécharger / À Propos / Aides (liens
+ * Hub, data-hub-link, href resynchronisés à chaque ouverture via
+ * refreshCompteHrefs / refreshMenuHrefs). Seule « Déconnexion »
+ * reste relayée à l'hôte (data-compte-act="deconnexion"), inchangée.
+ * Les hôtes qui traitaient onAction("profil") (Kanbante → /profile)
+ * voient ce comportement remplacé par le lien Hub — décision du
+ * plan Hub : un seul Profil, celui du Hub.
 */
 (function () {
  "use strict";
@@ -155,7 +198,8 @@
    kanbante: "https://kanbante.dracodev.net/",
    shaarit: "https://shaarit.dracodev.net/",
    agent: "https://agent.dracodev.net/",
-    spark: "https://spark.dracodev.net/"
+    spark: "https://spark.dracodev.net/",
+    hub: "https://hub.dracodev.net/"
  };

  /* Dérivation -dev (v0.1.6) — appliquée UNIQUEMENT quand l'hôte courant
@@ -168,7 +212,8 @@
    tiktak: "https://tiktak-dev.dracodev.net/",
    kanbante: "https://kanbante-dev.dracodev.net/",
    shaarit: "https://shaarit-dev.dracodev.net/",
-    agent: "https://agent-dev.dracodev.net/"
+    agent: "https://agent-dev.dracodev.net/",
+    hub: "https://hub-dev.dracodev.net/"
  };

  var APP_LABELS = {
@@ -229,6 +274,131 @@
  }
  var resolvedUrls = resolveUrls();

+  /* ── Thème commun (v0.5.0, carte HUB-18, fusion #132) ────────────
+   * La préférence de thème de la suite vit dans le profil du Hub :
+   *   GET <hub>/api/profil/theme → {"theme": "sombre"|"clair"|"systeme"|null}
+   * authentifié par le cookie draco (credentials: "include").
+   * <hub> est l'URL RÉSOLUE ci-dessus (explicite > dérivation -dev >
+   * défaut officiel) — jamais un nom figé de plus.
+   * Application par le mécanisme data-theme existant des hôtes :
+   * "sombre" → data-theme="dark", "clair" → data-theme="light",
+   * "systeme" → attribut RETIRÉ (prefers-color-scheme décide, garde
+   * html:not([data-theme]) du CSS de la barre comme des hôtes).
+   * L'événement draco:theme ({theme, mode} — mode = "dark"/"light"
+   * EFFECTIF) est ensuite dispatché pour les hôtes dont le mécanisme
+   * propre doit suivre (icônes et libellés, feuilles de style,
+   * palettes ShaarIt, attribut dédié de la console…) ; un hôte qui
+   * s'initialise après la barre lit la même information dans
+   * DRACO_BAR.themePref / DRACO_BAR.themeMode.
+   * Ordre d'application : 1) le cache local FRAIS est appliqué de
+   * façon SYNCHRONE à l'initialisation de la barre (script en defer
+   * chez tous les hôtes : avant DOMContentLoaded, donc avant le
+   * premier rendu dans le cas général) ; 2) un fetch ASYNCHRONE et
+   * NON BLOQUANT rafraîchit le cache et ré-applique si la préférence
+   * a changé. À la toute première visite (aucun cache), un bref
+   * flash du thème local de l'hôte reste possible le temps du fetch :
+   * c'est le prix du repli — l'état affiché transitoire est le thème
+   * que l'hôte aurait de toute façon choisi seul, jamais un état
+   * cassé, et les visites suivantes sont servies par le cache.
+   * Cache : localStorage "draco-theme-hub" ({theme, ts}), TTL 12 h
+   * (ordre de la journée) ; il ne contient QUE la préférence du Hub,
+   * jamais le choix local de l'hôte.
+   * REPLI INTÉGRAL : Hub injoignable, réponse non-OK (401…), JSON
+   * invalide, theme null ou valeur inconnue → RIEN n'est appliqué et
+   * RIEN n'est mis en cache ; un échec de fetch n'efface pas un cache
+   * existant. Le comportement actuel de l'hôte (son localStorage,
+   * puis le système) reste alors exactement le maître, comme avant
+   * la v0.5.0. Le sélecteur de thème LOCAL de chaque hôte reste
+   * fonctionnel : la barre n'applique qu'à l'ouverture (cache, puis
+   * fetch) ; elle ne ré-applique ensuite que sur changement du
+   * schéma système, et seulement tant que la préférence résolue est
+   * "systeme". */
+  var THEME_CACHE_CLE = "draco-theme-hub";
+  var THEME_CACHE_TTL_MS = 12 * 60 * 60 * 1000;
+  var themePref = null;  /* "sombre"|"clair"|"systeme"|null (non résolue) */
+  var themeMode = null;  /* "dark"|"light"|null : mode effectif appliqué */
+
+  function themeSystemeEstSombre() {
+    try {
+      return !!(window.matchMedia &&
+        window.matchMedia("(prefers-color-scheme: dark)").matches);
+    } catch (e) { return false; }
+  }
+  function lireCacheTheme() {
+    try {
+      var brut = window.localStorage &&
+        window.localStorage.getItem(THEME_CACHE_CLE);
+      if (!brut) return null;
+      var c = JSON.parse(brut);
+      if (!c || typeof c.ts !== "number") return null;
+      if (Date.now() - c.ts > THEME_CACHE_TTL_MS) return null;
+      if (c.theme === "sombre" || c.theme === "clair" || c.theme === "systeme")
+        return c.theme;
+    } catch (e) { /* stockage indisponible ou corrompu : pas de cache */ }
+    return null;
+  }
+  function ecrireCacheTheme(theme) {
+    try {
+      if (window.localStorage) {
+        window.localStorage.setItem(THEME_CACHE_CLE,
+          JSON.stringify({ theme: theme, ts: Date.now() }));
+      }
+    } catch (e) { /* stockage indisponible : le prochain fetch refera le travail */ }
+  }
+  function appliquerThemeCommun(theme) {
+    var root = document.documentElement;
+    if (!root) return;
+    if (theme === "sombre" || theme === "clair") {
+      themeMode = theme === "sombre" ? "dark" : "light";
+      root.setAttribute("data-theme", themeMode);
+    } else if (theme === "systeme") {
+      themeMode = themeSystemeEstSombre() ? "dark" : "light";
+      root.removeAttribute("data-theme");
+    } else {
+      return;
+    }
+    themePref = theme;
+    if (window.DRACO_BAR) {
+      window.DRACO_BAR.themePref = themePref;
+      window.DRACO_BAR.themeMode = themeMode;
+    }
+    try {
+      document.dispatchEvent(new CustomEvent("draco:theme",
+        { detail: { theme: themePref, mode: themeMode } }));
+    } catch (e) { /* aucun écouteur hôte : data-theme suffit */ }
+  }
+  function initThemeCommun() {
+    var enCache = lireCacheTheme();
+    if (enCache) appliquerThemeCommun(enCache);
+    /* Suivi du schéma système tant que la préférence est "systeme" :
+     * sans data-theme, le CSS suit tout seul ; l'événement est
+     * re-dispatché pour les hôtes qui matérialisent le mode. */
+    try {
+      var mq = window.matchMedia &&
+        window.matchMedia("(prefers-color-scheme: dark)");
+      if (mq && mq.addEventListener) {
+        mq.addEventListener("change", function () {
+          if (themePref === "systeme") appliquerThemeCommun("systeme");
+        });
+      }
+    } catch (e) { /* pas de matchMedia : pas de suivi */ }
+    if (typeof window.fetch !== "function") return;
+    var url = withSlash(resolvedUrls.hub || DEFAULT_URLS.hub) +
+      "api/profil/theme";
+    window.fetch(url, { credentials: "include" }).then(function (resp) {
+      if (!resp || !resp.ok) return null;
+      return resp.json();
+    }).then(function (data) {
+      if (!data) return;
+      var t = data.theme;
+      if (t === "sombre" || t === "clair" || t === "systeme") {
+        ecrireCacheTheme(t);
+        appliquerThemeCommun(t);
+      }
+      /* theme null ou inconnu : repli intégral, rien n'est touché. */
+    }).catch(function () { /* Hub injoignable : repli intégral */ });
+  }
+
  function setCounts(counts) {
    Object.keys(counts || {}).forEach(function (k) {
      /* Toutes les occurrences : l'onglet ET sa ligne dans le menu. */
@@ -307,6 +477,28 @@
    menu.querySelectorAll(".draco-apps-item").forEach(function (a) {
      if (a.dataset.app && resolvedUrls[a.dataset.app]) a.setAttribute("href", resolvedUrls[a.dataset.app]);
    });
+    /* v0.3.0 : les liens du Hub (menu compte) sont resynchronisés
+     * eux aussi à l'ouverture d'un menu, pour refléter setUrls et
+     * la dérivation -dev même s'ils ont été construits avant. */
+    refreshCompteHrefs();
+  }
+  /* Liens du Hub dans le menu compte (v0.3.0) : chemin → libellé.
+   * « Profil » est le quatrième lien (vers <hub>/profil) ; il
+   * remplace l'ancien item relayé « profil ». */
+  var HUB_LINKS = [
+    ["telecharger", "Télécharger"],
+    ["a-propos", "À Propos"],
+    ["aide", "Aides"],
+    ["profil", "Profil"]
+  ];
+  function hubHref(path) {
+    return withSlash(resolvedUrls.hub || DEFAULT_URLS.hub) + path;
+  }
+  function refreshCompteHrefs() {
+    if (!compteMenu) return;
+    compteMenu.querySelectorAll("[data-hub-link]").forEach(function (a) {
+      a.setAttribute("href", hubHref(a.getAttribute("data-hub-link")));
+    });
  }
  function togglePopup(menu, btn, force) {
    if (!menu) return;
@@ -429,10 +621,80 @@
    if (!appsMenu.hidden) lastOpener = brand;
  }

-  /* 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). */
+  /* Icônes monoline du menu compte (v0.4.0) — glyphes contour
+   * dans le style des icônes du rail de la console : viewBox 24,
+   * stroke currentColor, remplissage nul, extrémités rondes.
+   * Chaque glyphe est une liste de primitives [balise, attributs]
+   * construites en DOM (jamais d'innerHTML), comme le reste du
+   * fichier. Le libellé reste le nœud texte de l'item ; l'icône,
+   * appendue après, est replacée à gauche par le CSS (order: -1
+   * sur .draco-menu-icone, l'item étant déjà en flex). */
+  var MENU_ICONES = {
+    /* Flèche vers le bas dans un plateau. */
+    "telecharger": [
+      ["path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }],
+      ["polyline", { points: "7 10 12 15 17 10" }],
+      ["line", { x1: "12", y1: "15", x2: "12", y2: "3" }]
+    ],
+    /* Cercle d'information. */
+    "a-propos": [
+      ["circle", { cx: "12", cy: "12", r: "9" }],
+      ["line", { x1: "12", y1: "11", x2: "12", y2: "16" }],
+      ["line", { x1: "12", y1: "8", x2: "12.01", y2: "8" }]
+    ],
+    /* Cercle d'interrogation. */
+    "aide": [
+      ["circle", { cx: "12", cy: "12", r: "9" }],
+      ["path", { d: "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" }],
+      ["line", { x1: "12", y1: "17", x2: "12.01", y2: "17" }]
+    ],
+    /* Personne : tête + épaules. */
+    "profil": [
+      ["path", { d: "M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2" }],
+      ["circle", { cx: "12", cy: "7", r: "4" }]
+    ],
+    /* Flèche sortant d'un cadre (porte). */
+    "deconnexion": [
+      ["path", { d: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4" }],
+      ["polyline", { points: "16 17 21 12 16 7" }],
+      ["line", { x1: "21", y1: "12", x2: "9", y2: "12" }]
+    ]
+  };
+  /* Espace de noms SVG — OBLIGATOIRE : un élément « svg » (ou
+   * « path », « circle »…) créé par createElement() appartient à
+   * l'espace de noms HTML et le navigateur ne le dessine JAMAIS
+   * (bug v0.4.0 : libellés décalés d'un cran d'icône, aucun glyphe
+   * visible ; corrigé en v0.4.1, carte fusion #125). */
+  var SVG_NS = "http://www.w3.org/2000/svg";
+  function menuIcone(nom) {
+    var span = document.createElement("span");
+    span.className = "draco-menu-icone";
+    span.setAttribute("aria-hidden", "true");
+    var svg = document.createElementNS(SVG_NS, "svg");
+    svg.setAttribute("viewBox", "0 0 24 24");
+    svg.setAttribute("fill", "none");
+    svg.setAttribute("stroke", "currentColor");
+    svg.setAttribute("stroke-width", "1.8");
+    svg.setAttribute("stroke-linecap", "round");
+    svg.setAttribute("stroke-linejoin", "round");
+    svg.setAttribute("focusable", "false");
+    (MENU_ICONES[nom] || []).forEach(function (spec) {
+      var el = document.createElementNS(SVG_NS, spec[0]);
+      for (var k in spec[1]) el.setAttribute(k, spec[1][k]);
+      svg.appendChild(el);
+    });
+    span.appendChild(svg);
+    return span;
+  }
+
+  /* Menu compte (v0.1.6 ; v0.3.0 pour les liens) — en-tête
+   * d'identité, puis les liens du Hub (Télécharger, À Propos,
+   * Aides, Profil — vrais <a href>, même patron que le menu des
+   * applications), un séparateur, puis « Déconnexion » relayée à
+   * l'hôte. L'en-tête et les href sont rafraîchis à 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) et la résolution d'URL la plus récente. */
  function buildCompteMenu() {
    if (!bar || !avatarBtn || compteMenu) return;
    compteMenu = document.createElement("div");
@@ -443,15 +705,28 @@
    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);
+    HUB_LINKS.forEach(function (pair) {
+      var a = document.createElement("a");
+      a.className = "draco-menu-item";
+      a.href = hubHref(pair[0]);
+      a.setAttribute("data-hub-link", pair[0]);
+      a.setAttribute("role", "menuitem");
+      a.textContent = pair[1];
+      a.appendChild(menuIcone(pair[0]));
+      compteMenu.appendChild(a);
    });
+    var sep = document.createElement("div");
+    sep.className = "draco-menu-sep";
+    sep.setAttribute("aria-hidden", "true");
+    compteMenu.appendChild(sep);
+    var b = document.createElement("button");
+    b.type = "button";
+    b.className = "draco-menu-item";
+    b.setAttribute("data-compte-act", "deconnexion");
+    b.setAttribute("role", "menuitem");
+    b.textContent = "Déconnexion";
+    b.appendChild(menuIcone("deconnexion"));
+    compteMenu.appendChild(b);
    bar.appendChild(compteMenu);
  }
  function refreshCompteMenu() {
@@ -459,6 +734,7 @@
    var head = compteMenu.querySelector(".draco-compte-nom");
    var name = displayName();
    if (head) head.textContent = name || "Compte";
+    refreshCompteHrefs();
  }
  function toggleCompteMenu(force) {
    buildCompteMenu();
@@ -550,11 +826,15 @@
  window.DRACO_BAR = {
    setCounts: setCounts, setCurrent: setCurrent, setDomain: setDomain,
    urls: resolvedUrls,
+    /* Thème commun (v0.5.0) : préférence du Hub résolue et mode
+     * effectif appliqué ; null tant que rien n'a été résolu (repli). */
+    themePref: null, themeMode: null,
    setUrls: function (urls) {
      cfg.urls = Object.assign({}, cfg.urls, urls || {});
      resolvedUrls = resolveUrls();
      window.DRACO_BAR.urls = resolvedUrls;
      applyUrls(resolvedUrls);
+      refreshCompteHrefs();
    }
  };

@@ -563,6 +843,7 @@
  buildCompteMenu();
  syncAvatar();
  refreshCompteMenu();
+  initThemeCommun();
  if (cfg.current) setCurrent(cfg.current);
  if (cfg.domain) setDomain(cfg.domain);
  if (cfg.counts) setCounts(cfg.counts);
@@ -268,10 +268,14 @@

        <!-- Main Application (wrapped for show/hide) -->
        <!-- Barre d'apps commune dracodev — Fusion #215 (ACC-1.1).
-             Snippet FIGÉ vendangé depuis Projets/dracodev-commons v0.2.0
-             (ui/barre-apps/, commit 70c837a de la branche
-             shaarit-phase3-barre-contrats) : ne pas modifier la structure
+             Snippet FIGÉ vendangé depuis Projets/dracodev-commons v0.3.0
+             (ui/barre-apps/, branche hub-menu-compte-v0-3-0 de la PR
+             commons #9 — HUB-1, fusion #115) : ne pas modifier la structure
             ici ; toute évolution passe par une nouvelle version de commons.
+             v0.3.0 : menu compte — liens Hub Télécharger / À Propos /
+             Aides et Profil devenu lien (vers le Hub résolu par
+             backend/draco_config, clé "hub", passé en urls.hub de la
+             configuration ci-dessous) ; « Déconnexion » reste relayée.
             v0.2.0 : 6e onglet ShaarIt (data-app="shaarit", après Kanbante,
             avant l'onglet agent) — son href porte le défaut officiel et
             la réécriture DRACO_URLS ci-dessous le résout comme les
@@ -376,6 +380,13 @@
            })();
            window.DRACO_BAR_CONFIG = {
                current: "obsigate",
+                /* Barre v0.3.0 (HUB-1) : la base du Hub vient de
+                   window.DRACO_URLS (clé "hub" de backend/draco_config :
+                   DRACO_HUB_URL explicite, dérivation -dev, défaut
+                   officiel) — le Hub n'a pas d'onglet, c'est par
+                   urls.hub que le menu compte construit ses liens
+                   Télécharger / À Propos / Aides / Profil. */
+                urls: (function () { var u = window.DRACO_URLS && window.DRACO_URLS.hub; return u ? { hub: u.replace(/\/$/, "") + "/" } : {}; })(),
                domain: (function () { try { return localStorage.getItem("draco_domain") || "pro"; } catch (e) { return "pro"; } })(),
                counts: {},
                onAction: function (act, el) {
@@ -2,11 +2,13 @@
 * 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.
+ * hôte (ObsiGate, Flowdeck, TikTak, Kanbante, ShaarIt) : la configuration
+ * vient des attributs data-* de #recherche, rendus côté serveur par
+ * l'hôte. Source canonique : dracodev-commons, ui/recherche/
+ * (contrat : contrats/recherche-federee.md).
 *
 * Présentation en onglets : Tout, ObsiGate, Flowdeck, TikTak, Kanbante,
- * Console Spark. « Tout » = les 4 sections groupées, chaque liste
+ * ShaarIt, Console Spark. « Tout » = les 5 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
@@ -46,6 +48,11 @@
 *   -> { 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).
+ * - ShaarIt : GET {base}/api/search?q=
+ *   -> { links: [{ id, title, url, description, tags, shorturl,
+ *        private }] }
+ *   Lien profond (contrat liens-profonds) : {base}shaare/<shorturl>.
+ *   Recherche native adressable : {base}?q=<q> (page d'accueil).
 * - Console Spark : GET {base-console}/api/v1/recherche?q=&limite=
 *   (agent-commun, authentifié par le cookie SSO draco_session) ->
 *   { q, domain, limite_par_type, resultats[], par_type,
@@ -87,8 +94,9 @@
 * 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)
+ * (Domain=.dracodev.net), accepté par les 5 API de recherche
+ * (ObsiGate et TikTak nativement, Flowdeck et Kanbante via #68,
+ * ShaarIt via la fédération v0.2.1 de commons)
 * et par GET /api/v1/recherche de la console (identity() accepte
 * draco_session). Chaque sœur n'autorise en CORS que les origines
 * sœurs (GET sur l'endpoint de recherche uniquement, pas de "*") ;
@@ -109,12 +117,14 @@
    flowdeck: "https://flowdeck.dracodev.net/",
    tiktak: "https://tiktak.dracodev.net/",
    kanbante: "https://kanbante.dracodev.net/",
+    shaarit: "https://shaarit.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/",
+    shaarit: "https://shaarit-dev.dracodev.net/",
  };
  var PROD_AGENT = "https://agent.dracodev.net/";
  var DEV_AGENT = "https://agent-dev.dracodev.net/";
@@ -125,6 +135,7 @@
    { key: "flowdeck", label: "Flowdeck" },
    { key: "tiktak", label: "TikTak" },
    { key: "kanbante", label: "Kanbante" },
+    { key: "shaarit", label: "ShaarIt" },
  ];
  var CONSOLE_APP = { key: "console", label: "Console Spark" };
  var CONSOLE_TYPE_LABELS = {
@@ -145,7 +156,7 @@
    planification: "/?section=planifie",
    identite: "/?section=identites",
  };
-  var TABS = ["all", "obsigate", "flowdeck", "tiktak", "kanbante", "console"];
+  var TABS = ["all", "obsigate", "flowdeck", "tiktak", "kanbante", "shaarit", "console"];
  var COLUMN_LABELS = {
    backlog: "Backlog",
    in_progress: "En cours",
@@ -227,7 +238,7 @@
    return TABS.indexOf(v) !== -1 ? v : "all";
  }

-  /* Sections visibles pour un onglet. « Tout » = les 4 sections
+  /* Sections visibles pour un onglet. « Tout » = les 5 sections
   * groupées (vue #68) ; la console n'y figure pas (voir en-tête). */
  function visibleKeys(tab) {
    tab = parseTab(tab);
@@ -235,6 +246,21 @@
    return [tab];
  }

+  /* HUB-21 (propagation des réglages généraux du Hub) : le drapeau
+   * « Rechercher partout », rendu par l'hôte dans l'attribut
+   * data-recherche-partout de #recherche (« true »/« false », lu
+   * côté serveur depuis GET {hub}/api/reglages/effectifs, cache
+   * 60 s, patron du pilote TikTak 0.61.22). Seules les valeurs
+   * explicitement négatives désactivent la fédération ; attribut
+   * absent ou illisible = fédération active — le comportement
+   * actuel, qui est aussi le repli quand le Hub est muet.
+   * Fonction pure, exposée aux tests. */
+  function federationAutorisee(valeur) {
+    if (valeur == null) return true;
+    var v = String(valeur).trim().toLowerCase();
+    return v !== "false" && v !== "0" && v !== "non";
+  }
+
  /* Troncature d'affichage : liste complète dans l'onglet propre à
   * l'application, PER_APP_LIMIT partout ailleurs (vue « Tout »). */
  function pageItems(items, full) {
@@ -256,7 +282,7 @@
   * 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. */
+   * connus, "" si les 5 sections sont en erreur/inactives. */
  function tabCounts(states) {
    states = states || {};
    var out = {};
@@ -367,6 +393,22 @@
        };
      });
    }
+    if (app === "shaarit") {
+      return cut(data.links || []).map(function (l) {
+        var tags = (l.tags || []).filter(function (t) { return !!t; });
+        var ctx = "Bookmark";
+        if (l.private) ctx += " · privé";
+        if (tags.length) ctx += " · " + tags.join(", ");
+        return {
+          title: l.title || l.url || "Sans titre",
+          snippet: snippetOf(l.description || ""),
+          context: ctx,
+          /* Lien profond canonique (contrats/liens-profonds.md) ;
+           * sans shorturl, repli sur l'URL du bookmark lui-même. */
+          url: l.shorturl ? base + "shaare/" + l.shorturl : l.url || null,
+        };
+      });
+    }
    return [];
  }

@@ -455,13 +497,16 @@
    if (app === "tiktak" || app === "kanbante") {
      return base + "search?q=" + encodeURIComponent(q || "");
    }
+    if (app === "shaarit") {
+      return base + "?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") {
+    if (app === "tiktak" || app === "kanbante" || app === "shaarit") {
      return "Ouvrir la recherche dans " + appLabel(app);
    }
    return "Ouvrir " + appLabel(app) + " (recherche via la palette Ctrl+K)";
@@ -484,6 +529,7 @@
    visibleKeys: visibleKeys,
    pageItems: pageItems,
    buildSearchUrl: buildSearchUrl,
+    federationAutorisee: federationAutorisee,
    tabCounts: tabCounts,
    searchPath: searchPath,
    normalize: normalize,
@@ -579,6 +625,14 @@
        ".</p>";
      return;
    }
+    if (state.status === "desactivee") {
+      count.textContent = "";
+      body.innerHTML =
+        '<p class="rp-state">Recherche fédérée désactivée dans les ' +
+        "réglages généraux de la suite (Hub) : cette application " +
+        "n'est pas interrogée.</p>";
+      return;
+    }
    if (state.status === "idle") {
      count.textContent = "";
      body.innerHTML =
@@ -621,6 +675,8 @@
    var input = document.getElementById("rp-q");
    if (!input) return;
    var hostApp = root.getAttribute("data-host") || "";
+    var federation = federationAutorisee(
+      root.getAttribute("data-recherche-partout"));
    var explicit = {};
    APPS.forEach(function (app) {
      var v = root.getAttribute("data-base-" + app.key);
@@ -742,7 +798,23 @@
      applyTab(tab, opts);
      /* La console n'est interrogée qu'une fois affichée. */
      if (parseTab(tab) === "console" && currentQ && consoleFetchedQ !== currentQ) {
-        fetchConsole(currentQ, runId);
+        if (!federation) {
+          var secConsOnglet = sections.console;
+          if (secConsOnglet) {
+            states.console = {
+              status: "desactivee",
+              items: [],
+              message: "",
+              q: currentQ,
+              base: consoleBase,
+              app: "console",
+            };
+            renderSection(secConsOnglet, states.console, true);
+            renderTabs();
+          }
+        } else {
+          fetchConsole(currentQ, runId);
+        }
      }
    }

@@ -835,6 +907,22 @@
      APPS.forEach(function (app) {
        var sec = sections[app.key];
        if (!sec) return;
+        if (!federation && app.key !== hostApp) {
+          /* HUB-21 : fédération désactivée par le Hub — la section
+           * sœur n'est pas interrogée, la recherche locale
+           * (app.key === hostApp, même origine) continue. */
+          states[app.key] = {
+            status: "desactivee",
+            items: [],
+            message: "",
+            q: q,
+            base: bases[app.key],
+            app: app.key,
+          };
+          renderSection(sec, states[app.key], activeTab === app.key);
+          renderTabs();
+          return;
+        }
        states[app.key] = {
          status: "loading",
          items: [],
@@ -885,7 +973,21 @@
      });
      /* Console : seulement si son onglet est affiché ; sinon son
       * compteur reste vide (pas de faux 0) jusqu'à son activation. */
-      if (activeTab === "console") {
+      if (activeTab === "console" && !federation) {
+        var secConsRecherche = sections.console;
+        if (secConsRecherche) {
+          states.console = {
+            status: "desactivee",
+            items: [],
+            message: "",
+            q: q,
+            base: consoleBase,
+            app: "console",
+          };
+          renderSection(secConsRecherche, states.console, true);
+          renderTabs();
+        }
+      } else if (activeTab === "console") {
        fetchConsole(q, myRun);
      } else {
        states.console = {
@@ -129,12 +129,14 @@
      <div class="content-wrapper">
        <div class="content-area">
          <main class="rp-page" id="recherche" data-host="obsigate"
+                data-recherche-partout="{{RECHERCHE_PARTOUT}}"
                data-base-obsigate="{{URL_OBSIGATE}}"
                data-base-flowdeck="{{URL_FLOWDECK}}"
                data-base-tiktak="{{URL_TIKTAK}}"
-                data-base-kanbante="{{URL_KANBANTE}}">
+                data-base-kanbante="{{URL_KANBANTE}}"
+                data-base-shaarit="{{URL_SHAARIT}}">
            <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>
+            <p class="rp-hint">Notes ObsiGate, pages Flowdeck, tâches TikTak, cartes Kanbante, bookmarks ShaarIt — 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=""
                     placeholder="Rechercher partout…" autocomplete="off" autofocus>
@@ -145,6 +147,7 @@
              <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="shaarit">ShaarIt <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">
@@ -163,6 +166,10 @@
              <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="shaarit">
+              <div class="rp-head"><h2>ShaarIt — bookmarks</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>
@@ -14378,3 +14378,12 @@ body.has-draco-bar .app-container { height: calc(100vh - 60px); }
 .coffres-context-menu { position: fixed; z-index: 1000; min-width: 220px; background: var(--bg-secondary, #161b22); border: 1px solid var(--border, #21262d); border-radius: 8px; padding: 4px; box-shadow: 0 8px 24px rgba(0, 0, 0, 0.4); }
 .coffres-context-item { display: block; width: 100%; text-align: left; padding: 8px 12px; background: transparent; border: none; color: var(--text-primary, #e6edf3); cursor: pointer; border-radius: 6px; }
 .coffres-context-item:hover { background: var(--bg-hover, #1f2430); }
+
+/* Bannière d'annonce des réglages généraux du Hub (HUB-21) :
+   bandeau injecté côté serveur sous la barre commune, fermable
+   (masquage mémorisé pour la session du navigateur). */
+.banniere-hub { display: flex; align-items: center; gap: 12px; padding: 8px 16px; background: var(--accent, #7c5cd6); color: #fff; font-size: 14px; }
+.banniere-hub[hidden] { display: none; }
+.banniere-hub-texte { flex: 1; overflow-wrap: anywhere; }
+.banniere-hub-fermer { flex: none; background: transparent; border: none; color: inherit; font-size: 15px; line-height: 1; padding: 4px 6px; cursor: pointer; border-radius: 6px; }
+.banniere-hub-fermer:hover { background: rgba(255, 255, 255, 0.18); }
@@ -1,6 +1,6 @@
 {
  "name": "obsigate",
-  "version": "2.83.1",
+  "version": "2.85.2",
  "description": "**Porte d'entrée web ultra-léger pour vos vaults Obsidian** — Accédez, naviguez et recherchez dans toutes vos notes Obsidian depuis n'importe quel appareil via une interface web moderne et responsive.",
  "main": "patch.js",
  "directories": {
@@ -38,6 +38,7 @@ const b = rp.resolveBases({
 ok(b.tiktak === "https://tiktak-perso.example/", "explicite prioritaire");
 ok(b.obsigate === "https://og-dev.dracodev.net/", "dev pour l'hôte courant");
 ok(b.kanbante === "https://kanbante-dev.dracodev.net/", "dev avant href");
+ok(b.shaarit === "https://shaarit-dev.dracodev.net/", "base shaarit dev");
 ok(
  rp.searchPath("obsigate", "café") === "api/search?q=caf%C3%A9&vault=all&limit=8",
  "path ObsiGate",
@@ -58,21 +59,47 @@ ok(
    "https://tiktak-dev.dracodev.net/search?q=q",
  "repli TikTak",
 );
+ok(
+  rp.nativeSearchUrl("shaarit", "https://shaarit-dev.dracodev.net/", "q") ===
+    "https://shaarit-dev.dracodev.net/?q=q",
+  "repli ShaarIt = accueil ?q=",
+);
+
+/* normalize ShaarIt (commons v0.2.1) : lien profond shaare/<shorturl>,
+ * contexte privé + tags, repli sur l'URL du bookmark sans shorturl */
+const signets = rp.normalize(
+  "shaarit",
+  { links: [{ title: "Yandex", url: "https://yandex.com", description: "moteur", tags: ["recherche", "web"], shorturl: "xYz9", private: true }] },
+  "https://shaarit-dev.dracodev.net/",
+  "recherche",
+);
+ok(signets[0].url === "https://shaarit-dev.dracodev.net/shaare/xYz9", "lien profond ShaarIt (shaare/<shorturl>)");
+ok(signets[0].context === "Bookmark · privé · recherche, web", "contexte ShaarIt (privé + tags)");
+ok(signets[0].snippet === "moteur", "extrait ShaarIt = description");
+const sansShort = rp.normalize(
+  "shaarit",
+  { links: [{ title: "", url: "https://exemple.fr", tags: [], shorturl: "" }] },
+  "https://shaarit.dracodev.net/",
+  "x",
+);
+ok(sansShort[0].url === "https://exemple.fr" && sansShort[0].title === "https://exemple.fr", "ShaarIt sans shorturl : repli URL + titre");


 /* ---- Chantier 2+3 : onglets, compteurs, URL, console (logique pure) ---- */

 /* parseTab */
 ok(rp.parseTab("obsigate") === "obsigate", "onglet valide conservé");
+ok(rp.parseTab("shaarit") === "shaarit", "onglet shaarit valide");
 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");
+/* visibleKeys : Tout = les 5 sections groupées, sans la console */
+ok(JSON.stringify(rp.visibleKeys("all")) === JSON.stringify(["obsigate", "flowdeck", "tiktak", "kanbante", "shaarit"]), "Tout = 5 sections, pas la console");
 ok(JSON.stringify(rp.visibleKeys("tiktak")) === JSON.stringify(["tiktak"]), "onglet app = sa seule section");
+ok(JSON.stringify(rp.visibleKeys("shaarit")) === JSON.stringify(["shaarit"]), "onglet shaarit = 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");
+ok(JSON.stringify(rp.visibleKeys("bidon")) === JSON.stringify(["obsigate", "flowdeck", "tiktak", "kanbante", "shaarit"]), "onglet inconnu -> Tout");

 /* pageItems : troncature Tout (8), complet dans l'onglet de l'app */
 let douze = Array.from({ length: 12 }, (_, i) => ({ title: "T" + i }));
@@ -85,9 +112,11 @@ let c = rp.tabCounts({
  flowdeck: { status: "ok", total: 3 },
  tiktak: { status: "empty", total: 0 },
  kanbante: { status: "error", total: 0 },
+  shaarit: { status: "ok", total: 2 },
  console: { status: "idle", total: 0 },
 });
 ok(c.obsigate === "…", "compteur … pendant le chargement");
+ok(c.shaarit === "2", "compteur shaarit");
 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");
@@ -96,18 +125,20 @@ c = rp.tabCounts({
  flowdeck: { status: "ok", total: 2 },
  tiktak: { status: "empty", total: 0 },
  kanbante: { status: "error", total: 0 },
+  shaarit: { status: "ok", total: 1 },
  console: { status: "ok", total: 4 },
 });
-ok(c.all === "7", "Tout = somme des totaux connus");
+ok(c.all === "8", "Tout = somme des totaux connus (5 sections)");
 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 },
+  shaarit: { status: "error", total: 0 },
  console: { status: "idle", total: 0 },
 });
-ok(c.all === "", "Tout vide si les 4 sections sont en erreur");
+ok(c.all === "", "Tout vide si les 5 sections sont en erreur");

 /* buildSearchUrl : état onglet partageable */
 ok(rp.buildSearchUrl("café", "tiktak") === "?q=caf%C3%A9&tab=tiktak", "URL q+onglet");
@@ -176,4 +207,14 @@ ok(rc.recognized === true && rc.items.length === 0, "console : resultats vide re
 ok(rp.consoleLinkFor({ type: "discussion", id: "c1" }) === "/?section=conversation&disc=c1", "consoleLinkFor discussion");
 ok(rp.resolveConsoleBase({ host: "x.example", tabHrefs: { agent: "https://agent-perso.example/" } }) === "https://agent-perso.example/", "console : href onglet barre agent accepte");

+/* federationAutorisee (HUB-21) : seules les valeurs explicitement
+   négatives désactivent la fédération ; absent/illisible = actif
+   (repli = comportement actuel, Hub muet compris). */
+ok(rp.federationAutorisee("false") === false, "fédération : false désactive");
+ok(rp.federationAutorisee("0") === false, "fédération : 0 désactive");
+ok(rp.federationAutorisee("true") === true, "fédération : true active");
+ok(rp.federationAutorisee(null) === true, "fédération : attribut absent = actif");
+ok(rp.federationAutorisee("") === true, "fédération : vide = actif");
+ok(rp.federationAutorisee("nimporte") === true, "fédération : illisible = actif");
+
 console.log(`recherche.test.mjs : ${n} assertions OK`);
@@ -0,0 +1,534 @@
+# tests/test_comptes_machine.py — HUB-13 (fusion #127)
+# API d'administration des comptes machine-à-machine
+# (/api/admin/machine/comptes), protégée par la clé dédiée
+# DRACO_ADMIN_MACHINE_KEY : lecture/écriture, désactivation avec
+# révocation des sessions, réinitialisations du mot de passe (avec
+# changement forcé) et du MFA, suppression, journalisation d'audit.
+
+import json
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+import pytest
+
+MACHINE_KEY = "cle-admin-machine-test"
+MACHINE_HEADERS = {"X-Draco-Machine-Key": MACHINE_KEY,
+                   "X-Draco-Actor": "hub-test"}
+BASE = "/api/admin/machine/comptes"
+
+
+@pytest.fixture
+def machine_client():
+    """TestClient avec auth active, données isolées, clés machine posées."""
+    tmp = Path(tempfile.mkdtemp())
+    data_dir = tmp / "data"
+    data_dir.mkdir()
+
+    from backend.auth.mfa import generate_secret
+    from backend.auth.password import hash_password
+
+    users = {
+        "version": 1,
+        "users": {
+            "admin": {
+                "id": "admin-1",
+                "username": "admin",
+                "display_name": "admin",
+                "password_hash": hash_password("chab30"),
+                "role": "admin",
+                "vaults": ["*"],
+                "active": True,
+                "created_at": "2026-01-01T00:00:00",
+            },
+            "mfauser": {
+                "id": "user-mfa",
+                "username": "mfauser",
+                "display_name": "Utilisateur MFA",
+                "password_hash": hash_password("motdepasse-mfa"),
+                "role": "user",
+                "vaults": ["TestVault"],
+                "active": True,
+                "created_at": "2026-01-01T00:00:00",
+                "mfa_enabled": True,
+                "mfa_secret": generate_secret(),
+                "mfa_method": "totp",
+                "mfa_recovery_codes": ["hash-fictif"],
+            },
+        },
+    }
+    (data_dir / "users.json").write_text(json.dumps(users), encoding="utf-8")
+
+    src_secret = Path("data/secret.key")
+    if src_secret.exists():
+        shutil.copy2(str(src_secret), str(data_dir / "secret.key"))
+
+    orig_cwd = os.getcwd()
+    test_vault_path = os.path.abspath("test-vault")
+    os.chdir(str(tmp))
+
+    os.environ["VAULT_1_NAME"] = "TestVault"
+    os.environ["VAULT_1_PATH"] = test_vault_path
+    os.environ["OBSIGATE_AUTH_ENABLED"] = "true"
+    os.environ["OBSIGATE_WATCHER_ENABLED"] = "false"
+    os.environ["DRACO_ADMIN_MACHINE_KEY"] = MACHINE_KEY
+    os.environ["DRACO_SSO_MACHINE_KEY"] = "cle-sso-test"
+    os.environ["DRACO_SESSION_SECRET"] = "secret-draco-test"
+
+    from backend import draco_session
+    draco_session._revoked = None
+    draco_session._issued = None
+
+    import backend.main
+    backend.main._load_config = lambda: {"watcher_enabled": False}
+
+    from backend.main import app
+    from backend.indexer import build_index, index
+    import asyncio
+
+    for key in list(index.keys()):
+        del index[key]
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(build_index())
+
+    from backend.search import init_inverted_index
+    init_inverted_index()
+
+    from fastapi.testclient import TestClient
+    client = TestClient(app)
+    yield client
+
+    if hasattr(client, "close"):
+        client.close()
+    loop.run_until_complete(asyncio.sleep(0))
+
+    draco_session._revoked = None
+    draco_session._issued = None
+    os.chdir(orig_cwd)
+    shutil.rmtree(str(tmp), ignore_errors=True)
+    for k in ["VAULT_1_NAME", "VAULT_1_PATH", "OBSIGATE_AUTH_ENABLED",
+              "OBSIGATE_WATCHER_ENABLED", "DRACO_ADMIN_MACHINE_KEY",
+              "DRACO_SSO_MACHINE_KEY", "DRACO_SESSION_SECRET"]:
+        os.environ.pop(k, None)
+
+
+def _login(client, username, password):
+    return client.post("/api/auth/login",
+                       json={"username": username, "password": password})
+
+
+def _creer(client, username="nouveau", password="motdepasse-initial", **kw):
+    corps = {"username": username, "password": password,
+             "display_name": kw.pop("display_name", "Nouveau Compte"),
+             "role": kw.pop("role", "user")}
+    corps.update(kw)
+    return client.post(BASE, headers=MACHINE_HEADERS, json=corps)
+
+
+# ── Protection par clé machine ──────────────────────────────────────────
+
+class TestProtection:
+    def test_sans_cle_refuse(self, machine_client):
+        assert machine_client.get(BASE).status_code == 401
+        assert machine_client.post(
+            BASE, json={"username": "x1", "password": "motdepasse"}
+        ).status_code == 401
+
+    def test_mauvaise_cle_refusee(self, machine_client):
+        resp = machine_client.get(
+            BASE, headers={"X-Draco-Machine-Key": "mauvaise-cle"})
+        assert resp.status_code == 401
+
+    def test_cle_sso_ne_suffit_pas(self, machine_client):
+        """La clé des révocations (lecture) n'ouvre pas l'administration."""
+        resp = machine_client.get(
+            BASE, headers={"X-Draco-Machine-Key": "cle-sso-test"})
+        assert resp.status_code == 401
+
+    def test_session_admin_ne_suffit_pas(self, machine_client):
+        """Même une session administratrice ordinaire est refusée."""
+        token = _login(machine_client, "admin", "chab30").json()["access_token"]
+        resp = machine_client.get(
+            BASE, headers={"Authorization": f"Bearer {token}"})
+        assert resp.status_code == 401
+
+    def test_non_configuree_inerte(self, machine_client, monkeypatch):
+        monkeypatch.delenv("DRACO_ADMIN_MACHINE_KEY")
+        resp = machine_client.get(BASE, headers=MACHINE_HEADERS)
+        assert resp.status_code == 404
+
+
+# ── Lecture ─────────────────────────────────────────────────────────────
+
+class TestLecture:
+    def test_liste(self, machine_client):
+        resp = machine_client.get(BASE, headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["total"] >= 2
+        noms = [c["username"] for c in data["comptes"]]
+        assert "admin" in noms and "mfauser" in noms
+
+    def test_profil_etendu_sans_secret(self, machine_client):
+        resp = machine_client.get(f"{BASE}/mfauser", headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        profil = resp.json()
+        assert profil["username"] == "mfauser"
+        assert profil["display_name"] == "Utilisateur MFA"
+        assert profil["language"] == "fr"
+        assert profil["avatar_present"] is False
+        assert profil["role"] == "user"
+        assert profil["active"] is True
+        assert profil["mfa_enabled"] is True
+        # Jamais de secret : ni le haché du mot de passe, ni le TOTP.
+        brut = resp.text
+        assert "password_hash" not in brut
+        assert "mfa_secret" not in brut
+        assert "mfa_recovery" not in brut
+
+    def test_compte_inconnu_404(self, machine_client):
+        resp = machine_client.get(f"{BASE}/personne", headers=MACHINE_HEADERS)
+        assert resp.status_code == 404
+
+
+# ── Création / modification ─────────────────────────────────────────────
+
+class TestCreationModification:
+    def test_creation_puis_lecture(self, machine_client):
+        resp = _creer(machine_client)
+        assert resp.status_code == 201, resp.text
+        profil = resp.json()
+        assert profil["username"] == "nouveau"
+        assert profil["must_change_password"] is True
+
+        lu = machine_client.get(f"{BASE}/nouveau", headers=MACHINE_HEADERS)
+        assert lu.status_code == 200
+        assert lu.json()["display_name"] == "Nouveau Compte"
+
+        # Le compte créé se connecte, avec changement forcé signalé.
+        login = _login(machine_client, "nouveau", "motdepasse-initial")
+        assert login.status_code == 200
+        assert login.json()["user"]["must_change_password"] is True
+
+    def test_creation_doublon_409(self, machine_client):
+        assert _creer(machine_client).status_code == 201
+        assert _creer(machine_client).status_code == 409
+        assert _creer(machine_client, username="admin").status_code == 409
+
+    def test_modification(self, machine_client):
+        assert _creer(machine_client).status_code == 201
+        resp = machine_client.patch(
+            f"{BASE}/nouveau", headers=MACHINE_HEADERS,
+            json={"display_name": "Nom Modifié", "role": "admin"})
+        assert resp.status_code == 200
+        assert resp.json()["display_name"] == "Nom Modifié"
+        assert resp.json()["role"] == "admin"
+
+    def test_modification_inconnue_404(self, machine_client):
+        resp = machine_client.patch(
+            f"{BASE}/personne", headers=MACHINE_HEADERS,
+            json={"display_name": "X"})
+        assert resp.status_code == 404
+
+
+# ── Désactivation / réactivation ────────────────────────────────────────
+
+class TestDesactivation:
+    def test_desactivation_revoque_puis_reactivation(self, machine_client):
+        from backend import draco_session
+
+        assert _creer(machine_client).status_code == 201
+        login = _login(machine_client, "nouveau", "motdepasse-initial")
+        assert login.status_code == 200
+        token_natif = login.json()["access_token"]
+
+        profil = machine_client.get(
+            f"{BASE}/nouveau", headers=MACHINE_HEADERS).json()
+        token_draco, jti, _exp = draco_session.issue_token(
+            {"id": profil["id"], "username": "nouveau",
+             "display_name": "Nouveau Compte"})
+        assert draco_session.verify_token(token_draco) is not None
+
+        resp = machine_client.post(f"{BASE}/nouveau/desactiver",
+                                   headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        assert resp.json()["active"] is False
+
+        # Connexion refusée, ancienne session native refusée,
+        # jti draco révoqué et publié dans la liste des révocations.
+        assert _login(machine_client, "nouveau",
+                      "motdepasse-initial").status_code == 401
+        me = machine_client.get(
+            "/api/auth/me",
+            headers={"Authorization": f"Bearer {token_natif}"})
+        assert me.status_code == 401
+        assert draco_session.verify_token(token_draco) is None
+        revocations = machine_client.get(
+            "/api/sso/revocations",
+            headers={"X-Draco-Machine-Key": "cle-sso-test"})
+        assert revocations.status_code == 200
+        assert jti in [r["jti"] for r in revocations.json()["revoked"]]
+
+        resp = machine_client.post(f"{BASE}/nouveau/reactiver",
+                                   headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        assert resp.json()["active"] is True
+
+        # Réactivation : nouvelle connexion OK, ancien jti toujours révoqué.
+        assert _login(machine_client, "nouveau",
+                      "motdepasse-initial").status_code == 200
+        assert draco_session.verify_token(token_draco) is None
+
+
+# ── Réinitialisation du mot de passe ────────────────────────────────────
+
+class TestReinitialisationMotDePasse:
+    def test_ancien_refuse_nouveau_accepte_changement_force(
+            self, machine_client):
+        assert _creer(machine_client).status_code == 201
+        resp = machine_client.post(
+            f"{BASE}/nouveau/reinitialiser-mot-de-passe",
+            headers=MACHINE_HEADERS,
+            json={"password": "nouveau-mot-de-passe"})
+        assert resp.status_code == 200
+        assert resp.json()["must_change_password"] is True
+
+        assert _login(machine_client, "nouveau",
+                      "motdepasse-initial").status_code == 401
+        login = _login(machine_client, "nouveau", "nouveau-mot-de-passe")
+        assert login.status_code == 200
+        assert login.json()["user"]["must_change_password"] is True
+
+        # Le changement effectif par l'utilisateur efface le marqueur.
+        token = login.json()["access_token"]
+        changement = machine_client.post(
+            "/api/auth/change-password",
+            headers={"Authorization": f"Bearer {token}"},
+            json={"current_password": "nouveau-mot-de-passe",
+                  "new_password": "mot-de-passe-choisi"})
+        assert changement.status_code == 200, changement.text
+        login2 = _login(machine_client, "nouveau", "mot-de-passe-choisi")
+        assert login2.status_code == 200
+        assert login2.json()["user"]["must_change_password"] is False
+
+
+# ── Réinitialisation du MFA ─────────────────────────────────────────────
+
+class TestReinitialisationMfa:
+    def test_mfa_reinitialise(self, machine_client):
+        # Avant : la connexion exige le second facteur.
+        login = _login(machine_client, "mfauser", "motdepasse-mfa")
+        assert login.status_code == 200
+        assert login.json().get("mfa_required") is True
+
+        resp = machine_client.post(f"{BASE}/mfauser/reinitialiser-mfa",
+                                   headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        assert resp.json()["mfa_enabled"] is False
+
+        # Après : connexion directe, sans second facteur.
+        login = _login(machine_client, "mfauser", "motdepasse-mfa")
+        assert login.status_code == 200
+        assert "access_token" in login.json()
+
+
+# ── Suppression ─────────────────────────────────────────────────────────
+
+class TestSuppression:
+    def test_suppression(self, machine_client):
+        assert _creer(machine_client).status_code == 201
+        resp = machine_client.delete(f"{BASE}/nouveau",
+                                     headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        assert machine_client.get(
+            f"{BASE}/nouveau", headers=MACHINE_HEADERS).status_code == 404
+        assert _login(machine_client, "nouveau",
+                      "motdepasse-initial").status_code == 401
+
+    def test_suppression_inconnue_404(self, machine_client):
+        resp = machine_client.delete(f"{BASE}/personne",
+                                     headers=MACHINE_HEADERS)
+        assert resp.status_code == 404
+
+
+# ── Sessions draco (HUB-22) ─────────────────────────────────────────────
+
+def _emettre(client, username, nombre=1):
+    """Émet ``nombre`` jetons draco pour un compte ; retourne
+    [(jeton, jti, exp), …]."""
+    from backend import draco_session
+
+    profil = client.get(f"{BASE}/{username}",
+                        headers=MACHINE_HEADERS).json()
+    return [draco_session.issue_token(
+        {"id": profil["id"], "username": username,
+         "display_name": profil["display_name"]})
+        for _ in range(nombre)]
+
+
+class TestSessions:
+    def test_liste_sessions(self, machine_client):
+        from datetime import datetime
+
+        assert _creer(machine_client).status_code == 201
+        emis = _emettre(machine_client, "nouveau", 2)
+
+        resp = machine_client.get(f"{BASE}/nouveau/sessions",
+                                  headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["username"] == "nouveau"
+        assert len(data["sessions"]) == 2
+        jtis = [s["jti"] for s in data["sessions"]]
+        assert jtis == [j for _t, j, _e in emis]  # exp croissant
+        for session, (_t, _j, exp) in zip(data["sessions"], emis):
+            assert session["exp"] == exp
+            assert session["revoquee"] is False
+            echeance = datetime.fromisoformat(session["expire_le"])
+            assert echeance.tzinfo is not None
+            assert int(echeance.timestamp()) == exp
+
+    def test_liste_sessions_vide_et_compte_inconnu(self, machine_client):
+        resp = machine_client.get(f"{BASE}/mfauser/sessions",
+                                  headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        assert resp.json() == {"username": "mfauser", "sessions": []}
+        resp = machine_client.get(f"{BASE}/personne/sessions",
+                                  headers=MACHINE_HEADERS)
+        assert resp.status_code == 404
+
+    def test_revocation_unitaire(self, machine_client):
+        from backend import draco_session
+
+        assert _creer(machine_client).status_code == 201
+        (t1, jti1, _e1), (t2, _jti2, _e2) = _emettre(
+            machine_client, "nouveau", 2)
+
+        resp = machine_client.post(
+            f"{BASE}/nouveau/sessions/{jti1}/revoquer",
+            headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        assert resp.json() == {"jti": jti1, "revoquee": True}
+
+        # La session révoquée est morte, l'autre vit ; la liste la
+        # signale comme révoquée.
+        assert draco_session.verify_token(t1) is None
+        assert draco_session.verify_token(t2) is not None
+        sessions = machine_client.get(
+            f"{BASE}/nouveau/sessions", headers=MACHINE_HEADERS).json()
+        etats = {s["jti"]: s["revoquee"] for s in sessions["sessions"]}
+        assert etats[jti1] is True
+
+    def test_revocation_cross_utilisateur_404(self, machine_client):
+        from backend import draco_session
+
+        assert _creer(machine_client).status_code == 201
+        (token, jti, _e), = _emettre(machine_client, "nouveau", 1)
+
+        # Le jti de « nouveau » demandé sous « mfauser » : 404, et la
+        # session de « nouveau » reste valide (jamais de révocation
+        # cross-utilisateur).
+        resp = machine_client.post(
+            f"{BASE}/mfauser/sessions/{jti}/revoquer",
+            headers=MACHINE_HEADERS)
+        assert resp.status_code == 404
+        assert draco_session.verify_token(token) is not None
+
+        # Jti inconnu et compte inconnu : 404 également.
+        resp = machine_client.post(
+            f"{BASE}/nouveau/sessions/jti-inconnu/revoquer",
+            headers=MACHINE_HEADERS)
+        assert resp.status_code == 404
+        resp = machine_client.post(
+            f"{BASE}/personne/sessions/{jti}/revoquer",
+            headers=MACHINE_HEADERS)
+        assert resp.status_code == 404
+
+    def test_revoquer_toutes_sans_desactiver(self, machine_client):
+        from backend import draco_session
+
+        assert _creer(machine_client).status_code == 201
+        emis = _emettre(machine_client, "nouveau", 2)
+        (autre_token, _j, _e), = _emettre(machine_client, "mfauser", 1)
+
+        resp = machine_client.post(
+            f"{BASE}/nouveau/sessions/revoquer-toutes",
+            headers=MACHINE_HEADERS)
+        assert resp.status_code == 200
+        assert resp.json() == {"revoquees": 2}
+
+        for token, _jti, _exp in emis:
+            assert draco_session.verify_token(token) is None
+        # Les sessions des autres comptes ne sont pas touchées.
+        assert draco_session.verify_token(autre_token) is not None
+
+        # Plus rien à révoquer : le registre a été vidé pour ce compte
+        # (avant toute nouvelle connexion, qui émettrait une session).
+        resp = machine_client.post(
+            f"{BASE}/nouveau/sessions/revoquer-toutes",
+            headers=MACHINE_HEADERS)
+        assert resp.json() == {"revoquees": 0}
+
+        # Déconnexion globale ≠ désactivation : le compte reste actif
+        # et une nouvelle connexion fonctionne.
+        profil = machine_client.get(f"{BASE}/nouveau",
+                                    headers=MACHINE_HEADERS).json()
+        assert profil["active"] is True
+        assert _login(machine_client, "nouveau",
+                      "motdepasse-initial").status_code == 200
+
+    def test_sessions_protegees_par_cle_machine(self, machine_client,
+                                                 monkeypatch):
+        assert machine_client.get(
+            f"{BASE}/nouveau/sessions").status_code == 401
+        assert machine_client.post(
+            f"{BASE}/nouveau/sessions/un-jti/revoquer").status_code == 401
+        assert machine_client.post(
+            f"{BASE}/nouveau/sessions/revoquer-toutes").status_code == 401
+        monkeypatch.delenv("DRACO_ADMIN_MACHINE_KEY")
+        assert machine_client.get(
+            f"{BASE}/nouveau/sessions",
+            headers=MACHINE_HEADERS).status_code == 404
+
+    def test_sessions_journalisees(self, machine_client):
+        assert _creer(machine_client).status_code == 201
+        (_t, jti, _e), = _emettre(machine_client, "nouveau", 1)
+        machine_client.post(f"{BASE}/nouveau/sessions/{jti}/revoquer",
+                            headers=MACHINE_HEADERS)
+        machine_client.post(f"{BASE}/nouveau/sessions/revoquer-toutes",
+                            headers=MACHINE_HEADERS)
+
+        audit_file = Path("data/audit.log")
+        entrees = [json.loads(ligne)
+                   for ligne in audit_file.read_text(
+                       encoding="utf-8").splitlines() if ligne.strip()]
+        actions = {(e["action"], e["cible"]) for e in entrees
+                   if e.get("cible") == "nouveau"}
+        assert ("session_revoquee", "nouveau") in actions
+        assert ("sessions_revoquees", "nouveau") in actions
+
+
+# ── Journalisation ──────────────────────────────────────────────────────
+
+class TestJournalisation:
+    def test_actions_consignees(self, machine_client):
+        assert _creer(machine_client).status_code == 201
+        machine_client.post(f"{BASE}/nouveau/desactiver",
+                            headers=MACHINE_HEADERS)
+
+        audit_file = Path("data/audit.log")
+        assert audit_file.exists()
+        entrees = [json.loads(ligne)
+                   for ligne in audit_file.read_text(
+                       encoding="utf-8").splitlines() if ligne.strip()]
+        actions = {(e["action"], e["cible"]) for e in entrees
+                   if e.get("cible") == "nouveau"}
+        assert ("compte_cree", "nouveau") in actions
+        assert ("compte_desactive", "nouveau") in actions
+        for e in entrees:
+            if e.get("cible") == "nouveau":
+                assert e["acteur"] == "hub-test"
+                assert e["timestamp"]
@@ -78,6 +78,29 @@ def test_barre_v020_onglet_shaarit_et_garde_data_theme():
    assert 'shaarit: "https://shaarit-dev.dracodev.net/"' in js


+def test_barre_v030_liens_hub_menu_compte():
+    # Barre v0.3.0 (dracodev-commons, HUB-1 / fusion #115) : clé
+    # urls.hub (défaut officiel + dérivation hub-dev), liens du menu
+    # compte (Télécharger, À Propos, Aides, Profil-lien) construits
+    # par le JS vendangé, et branchement hôte : index.html passe la
+    # base Hub de window.DRACO_URLS (backend/draco_config) en
+    # urls.hub de DRACO_BAR_CONFIG.
+    js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
+    assert 'hub: "https://hub.dracodev.net/"' in js
+    assert 'hub: "https://hub-dev.dracodev.net/"' in js
+    assert '"telecharger", "Télécharger"' in js
+    assert '"a-propos", "À Propos"' in js
+    assert '"aide", "Aides"' in js
+    assert '"profil", "Profil"' in js
+    assert 'data-hub-link' in js
+    # Profil n'est plus un item relayé ; Déconnexion le reste.
+    assert 'data-compte-act", "profil"' not in js
+    assert 'data-compte-act", "deconnexion"' in js
+    html = _index()
+    assert "window.DRACO_URLS.hub" in html
+    assert "v0.3.0" in html
+
+
 def test_panneau_spark_integre_218():
    # #218 : le bouton Spark de la barre ouvre le panneau de l'agent
    # commun (mêmes assets partagés que TikTak / Flowdeck / Kanbante).
@@ -183,3 +206,56 @@ def test_panneau_version_service_affichee_225():
    # La ligne naît masquée et n'est démasquée qu'avec une version lue.
    assert 'class="draco-panneau-version"' in panneau
    assert "versionEl.hidden = false" in panneau
+
+
+def test_barre_v040_icones_monoline_menu_compte():
+    # v0.4.0 (HUB-11, fusion #125) : les items du menu compte
+    # portent des icônes SVG monoline construites en DOM, dans le
+    # style des icônes du rail de la console — aucun emoji, aucune
+    # icône pleine. La vendange reste verbatim commons.
+    js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
+    assert "MENU_ICONES" in js
+    for nom in ("telecharger", "a-propos", "aide", "profil", "deconnexion"):
+        assert nom in js
+    assert "draco-menu-icone" in js
+    assert "stroke: currentColor" not in js  # attributs posés en DOM
+    assert 'setAttribute("stroke", "currentColor")' in js
+    assert 'setAttribute("fill", "none")' in js
+    css = _css()
+    assert ".draco-menu-icone" in css
+    bloc = css.split(".draco-menu-icone {", 1)[1].split("}", 1)[0]
+    assert "width: 18px" in bloc
+    assert "var(--ink-2)" in bloc
+
+
+def test_barre_v041_correctif_icones_espace_de_noms_svg():
+    # v0.4.1 (correctif fusion #125) : les icônes du menu compte
+    # sont créées via createElementNS (espace de noms SVG). En
+    # v0.4.0, createElement() les créait dans l'espace de noms
+    # HTML : jamais dessinées par le navigateur, libellés
+    # décalés d'un cran d'icône sans aucun glyphe.
+    js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
+    assert 'createElementNS(SVG_NS, "svg")' in js
+    assert "createElementNS(SVG_NS, spec[0])" in js
+    assert 'createElement("svg")' not in js
+    assert "createElement(spec[0])" not in js
+
+
+def test_barre_v050_theme_commun_hub18():
+    # v0.5.0 (HUB-18, fusion #132) : la barre apprend la préférence
+    # de thème du Hub et l'applique à l'ouverture. La vendange reste
+    # verbatim commons ; l'initialisation propre à ObsiGate vit dans
+    # app.js (écouteur draco:theme → applyTheme).
+    js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
+    assert "api/profil/theme" in js
+    assert 'credentials: "include"' in js
+    assert "draco-theme-hub" in js
+    assert "THEME_CACHE_TTL_MS" in js
+    assert 'CustomEvent("draco:theme"' in js
+    assert "themePref" in js and "themeMode" in js
+    # Aucun nom de Hub figé de plus que les défauts/dérivations
+    # documentés : l'URL du Hub reste la résolue de la barre.
+    assert "resolvedUrls.hub" in js
+    app = (FRONTEND / "app.js").read_text(encoding="utf-8")
+    assert 'addEventListener("draco:theme"' in app
+    assert "barre.themeMode" in app
@@ -20,6 +20,7 @@ def env_propre(monkeypatch):
    for nom in (
        "DRACO_AGENT_URL", "DRACO_OBSIGATE_URL", "DRACO_FLOWDECK_URL",
        "DRACO_TIKTAK_URL", "DRACO_KANBANTE_URL", "DRACO_SHAARIT_URL",
+        "DRACO_HUB_URL",
        "DRACO_GITEA_URL",
        "AGENT_EVENEMENTS_URL",
    ):
@@ -52,6 +53,22 @@ def test_shaarit_defaut_et_derivation(env_propre):
    assert draco_config.app_url("shaarit") == "https://bm.example.net"


+def test_hub_defaut_et_derivation(env_propre):
+    """Barre v0.3.0 (HUB-1) : le Hub suit le même mécanisme que les
+    autres sœurs — défaut officiel, dérivation -dev depuis l'hôte
+    de l'agent, variable explicite prioritaire ; il est servi dans
+    urls_publiques() (window.DRACO_URLS) pour les liens du menu
+    compte, sans onglet dans la barre."""
+    assert draco_config.app_url("hub") == "https://hub.dracodev.net"
+    env_propre.setenv(
+        "AGENT_EVENEMENTS_URL", "https://agent-dev.dracodev.net/api/v1/evenements")
+    assert draco_config.app_url("hub") == "https://hub-dev.dracodev.net"
+    assert draco_config.urls_publiques()["hub"] == \
+        "https://hub-dev.dracodev.net"
+    env_propre.setenv("DRACO_HUB_URL", "https://hub.example.net/")
+    assert draco_config.app_url("hub") == "https://hub.example.net"
+
+
 def test_agent_derive_des_evenements(env_propre):
    """Sans DRACO_AGENT_URL, l'origine suit AGENT_EVENEMENTS_URL —
    la configuration réelle du poste (dev inclus)."""
@@ -18,9 +18,13 @@ def _draco_env(monkeypatch, tmp_path):
    monkeypatch.setenv("DRACO_SESSION_SECRET", "secret-de-test")
    monkeypatch.setattr(draco_session, "REVOKED_FILE",
                         tmp_path / "draco_revoked.json")
+    monkeypatch.setattr(draco_session, "ISSUED_FILE",
+                         tmp_path / "draco_issued.json")
    draco_session._revoked = None
+    draco_session._issued = None
    yield
    draco_session._revoked = None
+    draco_session._issued = None


 # ── Jeton : émission / vérification ─────────────────────────────────────
@@ -232,3 +236,58 @@ def test_revocations_protegees_par_cle_machine(admin_client, monkeypatch):
                         headers={"X-Draco-Machine-Key": "cle-machine"})
    assert r.status_code == 200
    assert {"jti": jti, "exp": exp} in r.json()["revoked"]
+
+
+# ── Registre des sessions (HUB-22, #227) ────────────────────────────────
+
+AUTRE = {"id": "user-2", "username": "autre", "display_name": "Autre"}
+
+
+def test_sessions_emises_listees_triees_et_marquees():
+    _t1, jti1, exp1 = draco_session.issue_token(USER)
+    t2, jti2, exp2 = draco_session.issue_token(USER)
+    draco_session.issue_token(AUTRE)                     # autre sub : exclu
+    draco_session.revoke(jti2, exp2)
+
+    sessions = draco_session.issued_sessions_for_user("admin-1")
+    assert [s["jti"] for s in sessions] == [jti1, jti2]  # exp croissant
+    assert sessions[0] == {"jti": jti1, "exp": exp1, "revoquee": False}
+    assert sessions[1] == {"jti": jti2, "exp": exp2, "revoquee": True}
+    assert draco_session.verify_token(t2) is None        # cohérent
+
+
+def test_sessions_emises_expirees_purgees():
+    now = int(time.time())
+    with draco_session._lock:
+        store = draco_session._load_issued()
+        store["admin-1"] = {"ancien": now - 10, "frais": now + 600}
+    assert [s["jti"] for s in
+            draco_session.issued_sessions_for_user("admin-1")] == ["frais"]
+    with draco_session._lock:
+        assert "ancien" not in draco_session._load_issued()["admin-1"]
+    assert draco_session.issued_sessions_for_user("personne") == []
+    assert draco_session.issued_sessions_for_user("") == []
+
+
+def test_revoquer_une_session_appartenante():
+    token, jti, _exp = draco_session.issue_token(USER)
+    assert draco_session.revoke_one_for_user("admin-1", jti) is True
+    assert draco_session.verify_token(token) is None
+    assert draco_session.is_revoked(jti)
+
+
+def test_revoquer_une_session_cross_utilisateur_refusee():
+    token, jti, _exp = draco_session.issue_token(USER)
+    # Le jti existe, mais pas dans l'ensemble émis de cet autre sub.
+    assert draco_session.revoke_one_for_user("user-2", jti) is False
+    assert draco_session.verify_token(token) is not None
+    assert draco_session.revoke_one_for_user("admin-1", "inconnu") is False
+    assert draco_session.revoke_one_for_user("", jti) is False
+
+
+def test_revoquer_une_session_expiree_refusee():
+    now = int(time.time())
+    with draco_session._lock:
+        draco_session._load_issued()["admin-1"] = {"perime": now - 10}
+    assert draco_session.revoke_one_for_user("admin-1", "perime") is False
+    assert not draco_session.is_revoked("perime")
@@ -0,0 +1,213 @@
+# tests/test_hub_reglages.py
+# Hub HUB-21 (propagation) — Réglages généraux du Hub consommés par
+# ObsiGate : client (parsing de la forme figée, cache 60 s, repli
+# intégral), bannière injectée côté serveur (page principale et page
+# /recherche, texte échappé) et drapeau ``recherche_partout`` rendu
+# en attribut de la page /recherche. Patron posé par l'hôte pilote
+# TikTak 0.61.22. ``domaine_defaut`` n'est pas appliqué : ObsiGate
+# n'a pas de notion de domaine propre (voir backend/hub_reglages.py).
+
+import json
+import time
+import urllib.error
+
+import pytest
+
+from backend import hub_reglages
+
+
+@pytest.fixture(autouse=True)
+def _hub_env(monkeypatch):
+    """Cache vierge + Hub de test explicite pour chaque test."""
+    hub_reglages.reinitialiser_cache()
+    monkeypatch.setenv("DRACO_HUB_URL", "https://hub-test.dracodev.net")
+    yield
+    hub_reglages.reinitialiser_cache()
+
+
+def _reponse(corps=None, statut=200):
+    """Fausse réponse urlopen portant un payload du contrat D6(a)."""
+    if corps is None:
+        corps = {"recherche_partout": True, "banniere": "",
+                 "domaine_defaut": None, "ttl_secondes": 60}
+    charge = json.dumps(corps).encode("utf-8")
+
+    class _Resp:
+        status = statut
+
+        def read(self):
+            return charge
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            return False
+
+    return _Resp()
+
+
+def _patch_consultation(monkeypatch, reglages, appels=None):
+    """Remplace la consultation HTTP par des réglages fixes."""
+    def _faux(url):
+        if appels is not None:
+            appels.append(url)
+        return reglages
+    monkeypatch.setattr(hub_reglages, "_consulter_hub", _faux)
+
+
+# ── Client : parsing du contrat ─────────────────────────────────────
+
+def test_consultation_parse_le_contrat(monkeypatch):
+    vu = {}
+
+    def _faux_urlopen(requete, timeout=None):
+        vu["url"] = requete.full_url
+        vu["cookie"] = requete.get_header("Cookie")
+        vu["accept"] = requete.get_header("Accept")
+        vu["timeout"] = timeout
+        return _reponse({"recherche_partout": False,
+                         "banniere": "Maintenance dimanche",
+                         "domaine_defaut": "famille", "ttl_secondes": 60})
+
+    monkeypatch.setattr(hub_reglages.urllib.request, "urlopen", _faux_urlopen)
+    reglages = hub_reglages.reglages_effectifs()
+    assert reglages == {"recherche_partout": False,
+                        "banniere": "Maintenance dimanche",
+                        "domaine_defaut": "famille"}
+    assert vu["url"] == "https://hub-test.dracodev.net/api/reglages/effectifs"
+    assert vu["cookie"] is None            # endpoint public : aucun cookie
+    assert vu["accept"] == "application/json"
+    assert vu["timeout"] == 2              # délai du contrat
+
+
+@pytest.mark.parametrize("corps", [
+    {"recherche_partout": "oui", "banniere": "", "domaine_defaut": None},
+    {"recherche_partout": True, "banniere": 42, "domaine_defaut": None},
+    {"recherche_partout": True, "banniere": "", "domaine_defaut": "travail"},
+    {"banniere": "", "domaine_defaut": None},
+    ["pas", "un", "dict"],
+])
+def test_consultation_forme_inattendue_repli(monkeypatch, corps):
+    monkeypatch.setattr(hub_reglages.urllib.request, "urlopen",
+                        lambda requete, timeout=None: _reponse(corps))
+    assert hub_reglages.reglages_effectifs() == hub_reglages.DEFAUTS
+
+
+def test_consultation_erreur_http_repli(monkeypatch):
+    monkeypatch.setattr(hub_reglages.urllib.request, "urlopen",
+                        lambda requete, timeout=None: _reponse(statut=500))
+    assert hub_reglages.reglages_effectifs() == hub_reglages.DEFAUTS
+    assert hub_reglages.banniere() == ""
+    assert hub_reglages.recherche_partout() is True
+
+
+def test_consultation_hub_injoignable_repli(monkeypatch):
+    def _leve(requete, timeout=None):
+        raise urllib.error.URLError("injoignable")
+    monkeypatch.setattr(hub_reglages.urllib.request, "urlopen", _leve)
+    assert hub_reglages.reglages_effectifs() == hub_reglages.DEFAUTS
+
+
+def test_consultation_json_illisible_repli(monkeypatch):
+    class _Resp:
+        status = 200
+
+        def read(self):
+            return b"pas du json"
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            return False
+
+    monkeypatch.setattr(hub_reglages.urllib.request, "urlopen",
+                        lambda requete, timeout=None: _Resp())
+    assert hub_reglages.reglages_effectifs() == hub_reglages.DEFAUTS
+
+
+# ── Client : cache 60 s, ancien cache, pas de rafale ────────────────
+
+def test_cache_60_s(monkeypatch):
+    appels = []
+    _patch_consultation(monkeypatch, {
+        "recherche_partout": False, "banniere": "Annonce A",
+        "domaine_defaut": None}, appels)
+    assert hub_reglages.banniere() == "Annonce A"
+    assert hub_reglages.recherche_partout() is False
+    assert len(appels) == 1                       # cache 60 s
+    hub_reglages._cache_at = time.monotonic() - 61
+    assert hub_reglages.banniere() == "Annonce A"
+    assert len(appels) == 2                       # expiration → rappel
+
+
+def test_echec_ancien_cache_sans_rafale(monkeypatch):
+    appels = []
+    _patch_consultation(monkeypatch, {
+        "recherche_partout": True, "banniere": "Annonce A",
+        "domaine_defaut": None}, appels)
+    assert hub_reglages.banniere() == "Annonce A"
+    hub_reglages._cache_at = time.monotonic() - 61
+    _patch_consultation(monkeypatch, None, appels)   # Hub tombe
+    assert hub_reglages.banniere() == "Annonce A"    # ancien cache
+    assert len(appels) == 2                          # pas de rafale
+    assert hub_reglages.banniere() == "Annonce A"
+    assert len(appels) == 2
+
+
+# ── Intégration : bannière et drapeau dans les pages servies ────────
+
+@pytest.fixture()
+def hub_banniere(monkeypatch):
+    etat = {"reglages": None}
+    monkeypatch.setattr(hub_reglages, "_consulter_hub",
+                        lambda url: etat["reglages"])
+    hub_reglages.reinitialiser_cache()
+    return etat
+
+
+def test_banniere_presente_et_echappee_index(client, hub_banniere):
+    hub_banniere["reglages"] = {
+        "recherche_partout": True,
+        "banniere": "Maintenance dimanche <b>gras</b> & cie",
+        "domaine_defaut": None}
+    r = client.get("/")
+    assert r.status_code == 200
+    assert 'id="banniere-hub"' in r.text
+    assert "Maintenance dimanche &lt;b&gt;gras&lt;/b&gt; &amp; cie" in r.text
+    assert "obsigate_banniere_masquee" in r.text
+
+
+def test_banniere_absente_si_vide_ou_hub_muet(client, hub_banniere):
+    hub_banniere["reglages"] = {
+        "recherche_partout": True, "banniere": "", "domaine_defaut": "pro"}
+    r = client.get("/")
+    assert r.status_code == 200
+    assert "banniere-hub" not in r.text
+    hub_banniere["reglages"] = None
+    hub_reglages.reinitialiser_cache()
+    r = client.get("/")
+    assert r.status_code == 200
+    assert "banniere-hub" not in r.text
+
+
+def test_recherche_banniere_et_drapeau(client, hub_banniere):
+    hub_banniere["reglages"] = {
+        "recherche_partout": False, "banniere": "Annonce recherche",
+        "domaine_defaut": None}
+    r = client.get("/recherche")
+    assert r.status_code == 200
+    assert 'data-recherche-partout="false"' in r.text
+    assert 'id="banniere-hub"' in r.text
+    assert "Annonce recherche" in r.text
+    hub_banniere["reglages"] = {
+        "recherche_partout": True, "banniere": "", "domaine_defaut": None}
+    hub_reglages.reinitialiser_cache()
+    r = client.get("/recherche")
+    assert 'data-recherche-partout="true"' in r.text
+    assert "banniere-hub" not in r.text
+    hub_banniere["reglages"] = None              # Hub muet → défaut actif
+    hub_reglages.reinitialiser_cache()
+    r = client.get("/recherche")
+    assert 'data-recherche-partout="true"' in r.text
@@ -0,0 +1,291 @@
+# tests/test_hub_roles.py
+# Hub HUB-19 (propagation, #228) — Rôles par application : client du
+# registre du Hub (parsing, cache 60 s par sub, repli systématique) et
+# effets sur le chemin draco d'ObsiGate (refus « aucun », garde
+# administrateur des routes /api/auth/admin/* pour le canal draco).
+# Contrat posé par l'hôte pilote ShaarIt 0.7.0 (décision D3(a)).
+
+import io
+import json
+import time
+import urllib.error
+
+import pytest
+
+from backend import draco_session, hub_roles
+
+USER = {"id": "admin-1", "username": "admin", "display_name": "Admin"}
+USER_SIMPLE = {"id": "user-1", "username": "normaluser", "display_name": "normal"}
+
+
+@pytest.fixture(autouse=True)
+def _hub_env(monkeypatch):
+    """Cache vierge + Hub de test explicite pour chaque test."""
+    hub_roles.reinitialiser_cache()
+    monkeypatch.setenv("DRACO_HUB_URL", "https://hub-test.dracodev.net")
+    yield
+    hub_roles.reinitialiser_cache()
+
+
+def _reponse(role, statut=200, corps=None):
+    """Fausse réponse urlopen portant un payload du contrat D3(a)."""
+    if corps is None:
+        corps = {"app": "obsigate", "sub": "admin-1", "role": role,
+                 "explicite": True, "ttl_secondes": 60}
+    charge = json.dumps(corps).encode("utf-8")
+
+    class _Resp:
+        status = statut
+
+        def read(self):
+            return charge
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            return False
+
+    return _Resp()
+
+
+def _patch_hub(monkeypatch, role, appels):
+    """Remplace la consultation HTTP par un rôle fixe (compte les appels)."""
+    def _faux(url, cookie):
+        appels.append((url, cookie))
+        return role
+    monkeypatch.setattr(hub_roles, "_consulter_hub", _faux)
+
+
+# ── Client : parsing du contrat ─────────────────────────────────────────
+
+def test_consultation_parse_le_contrat(monkeypatch):
+    vu = {}
+
+    def _faux_urlopen(requete, timeout=None):
+        vu["url"] = requete.full_url
+        vu["cookie"] = requete.get_header("Cookie")
+        vu["accept"] = requete.get_header("Accept")
+        vu["timeout"] = timeout
+        return _reponse("administrateur")
+
+    monkeypatch.setattr(hub_roles.urllib.request, "urlopen", _faux_urlopen)
+    role = hub_roles.role_pour("admin-1", "draco_session=jeton; autre=1")
+    assert role == "administrateur"
+    assert vu["url"] == "https://hub-test.dracodev.net/api/roles/obsigate"
+    assert vu["cookie"] == "draco_session=jeton; autre=1"   # Cookie complet relayé
+    assert vu["accept"] == "application/json"
+    assert vu["timeout"] == 2                               # délai du contrat
+
+
+@pytest.mark.parametrize("role", ["aucun", "utilisateur", "administrateur"])
+def test_consultation_roles_reconnus(monkeypatch, role):
+    monkeypatch.setattr(hub_roles.urllib.request, "urlopen",
+                        lambda requete, timeout=None: _reponse(role))
+    assert hub_roles.role_pour("admin-1", "c=1") == role
+
+
+def test_consultation_role_hors_contrat_inconnu(monkeypatch):
+    monkeypatch.setattr(hub_roles.urllib.request, "urlopen",
+                        lambda requete, timeout=None: _reponse("super-admin"))
+    assert hub_roles.role_pour("admin-1", "c=1") is None
+
+
+def test_consultation_json_illisible_inconnu(monkeypatch):
+    class _Resp:
+        status = 200
+
+        def read(self):
+            return b"pas du json"
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            return False
+
+    monkeypatch.setattr(hub_roles.urllib.request, "urlopen",
+                        lambda requete, timeout=None: _Resp())
+    assert hub_roles.role_pour("admin-1", "c=1") is None
+
+
+def test_consultation_erreur_http_inconnu(monkeypatch):
+    def _erreur(requete, timeout=None):
+        raise urllib.error.HTTPError(requete.full_url, 500, "boom", {}, io.BytesIO(b""))
+
+    monkeypatch.setattr(hub_roles.urllib.request, "urlopen", _erreur)
+    assert hub_roles.role_pour("admin-1", "c=1") is None
+
+
+def test_consultation_hub_injoignable_inconnu(monkeypatch):
+    def _panne(requete, timeout=None):
+        raise urllib.error.URLError("injoignable")
+
+    monkeypatch.setattr(hub_roles.urllib.request, "urlopen", _panne)
+    assert hub_roles.role_pour("admin-1", "c=1") is None
+
+
+def test_url_hub_derivee_par_hote_soeur(monkeypatch):
+    # Sans variable explicite : dérivation depuis l'hôte de l'agent
+    # (agent-dev → hub-dev), comme la barre commune (#223).
+    monkeypatch.delenv("DRACO_HUB_URL")
+    monkeypatch.setenv("DRACO_AGENT_URL", "https://agent-dev.dracodev.net")
+    appels = []
+    _patch_hub(monkeypatch, "utilisateur", appels)
+    assert hub_roles.role_pour("admin-1", "c=1") == "utilisateur"
+    assert appels[0][0] == "https://hub-dev.dracodev.net/api/roles/obsigate"
+
+
+def test_url_hub_defaut_officiel(monkeypatch):
+    monkeypatch.delenv("DRACO_HUB_URL")
+    monkeypatch.delenv("DRACO_AGENT_URL", raising=False)
+    monkeypatch.delenv("AGENT_EVENEMENTS_URL", raising=False)
+    appels = []
+    _patch_hub(monkeypatch, "utilisateur", appels)
+    hub_roles.role_pour("admin-1", "c=1")
+    assert appels[0][0] == "https://hub.dracodev.net/api/roles/obsigate"
+
+
+# ── Client : cache 60 s par sub, horodatage avant l'appel ──────────────
+
+def test_cache_par_sub_et_ttl(monkeypatch):
+    appels = []
+    _patch_hub(monkeypatch, "utilisateur", appels)
+    assert hub_roles.role_pour("admin-1", "c=1") == "utilisateur"
+    assert hub_roles.role_pour("admin-1", "c=1") == "utilisateur"
+    assert len(appels) == 1                              # 2e lecture : cache
+    assert hub_roles.role_pour("user-1", "c=2") == "utilisateur"
+    assert len(appels) == 2                              # autre sub : nouvel appel
+    # TTL expiré → nouvel appel.
+    hub_roles._cache_at = time.monotonic() - hub_roles.CACHE_TTL_SECONDS - 1
+    assert hub_roles.role_pour("admin-1", "c=1") == "utilisateur"
+    assert len(appels) == 3
+
+
+def test_echec_conserve_ancien_cache_sans_rafale(monkeypatch):
+    appels = []
+    _patch_hub(monkeypatch, "administrateur", appels)
+    assert hub_roles.role_pour("admin-1", "c=1") == "administrateur"
+    assert len(appels) == 1
+    # Le Hub tombe ; le TTL expire : un appel est tenté, échoue, et
+    # l'horodatage posé avant l'appel empêche la rafale — l'ancien
+    # rôle connu n'est ni effacé ni réinterrogé aussitôt.
+    hub_roles._cache_at = time.monotonic() - hub_roles.CACHE_TTL_SECONDS - 1
+    _patch_hub(monkeypatch, None, appels)
+    assert hub_roles.role_pour("user-1", "c=2") is None
+    assert len(appels) == 2
+    # Dans la fenêtre qui suit l'échec, l'ancien cache sert toujours.
+    assert hub_roles.role_pour("admin-1", "c=1") == "administrateur"
+    assert len(appels) == 2
+
+
+def test_sub_vide_aucun_appel(monkeypatch):
+    appels = []
+    _patch_hub(monkeypatch, "utilisateur", appels)
+    assert hub_roles.role_pour("", "c=1") is None
+    assert appels == []
+
+
+# ── Intégration : chemin draco (admin_client, secret draco posé) ──────
+
+@pytest.fixture()
+def _draco_env(monkeypatch, tmp_path):
+    monkeypatch.setenv("DRACO_SESSION_SECRET", "secret-de-test")
+    monkeypatch.setattr(draco_session, "REVOKED_FILE",
+                        tmp_path / "draco_revoked.json")
+    monkeypatch.setattr(draco_session, "ISSUED_FILE",
+                        tmp_path / "draco_issued.json")
+    draco_session._revoked = None
+    draco_session._issued = None
+    yield
+    draco_session._revoked = None
+    draco_session._issued = None
+
+
+def _pose_cookie_draco(client, user):
+    token, _jti, _exp = draco_session.issue_token(user)
+    client.cookies.set("draco_session", token)
+    return token
+
+
+def test_draco_aucun_refuse_session_explicite(admin_client, _draco_env, monkeypatch):
+    appels = []
+    _patch_hub(monkeypatch, "aucun", appels)
+    _pose_cookie_draco(admin_client, USER)
+    r = admin_client.get("/api/auth/me")
+    assert r.status_code == 403
+    assert "niveau « aucun »" in r.json()["detail"]
+    assert "registre des rôles du Hub" in r.json()["detail"]
+    assert appels and appels[0][1].find("draco_session=") >= 0  # Cookie relayé
+
+
+def test_draco_aucun_mais_connexion_native_intacte(admin_client, _draco_env, monkeypatch):
+    # L'authentification native (émettrice, accès de secours) n'est
+    # jamais touchée par le registre : le login par mot de passe du
+    # même compte passe, même avec un niveau « aucun » au Hub.
+    _patch_hub(monkeypatch, "aucun", [])
+    r = admin_client.post("/api/auth/login",
+                          json={"username": "admin", "password": "chab30"})
+    assert r.status_code == 200, r.text
+    # Et la session native ainsi établie ouvre /me (canal natif, le
+    # rôle du Hub ne s'applique pas).
+    r = admin_client.get("/api/auth/me")
+    assert r.status_code == 200, r.text
+    assert r.json()["username"] == "admin"
+
+
+def test_draco_role_inconnu_comportement_actuel(admin_client, _draco_env, monkeypatch):
+    _patch_hub(monkeypatch, None, [])                    # Hub injoignable
+    _pose_cookie_draco(admin_client, USER)
+    r = admin_client.get("/api/auth/me")
+    assert r.status_code == 200, r.text
+    assert r.json()["username"] == "admin"
+    # Canal draco + rôle inconnu : les routes admin gardent les
+    # règles actuelles (le rôle local admin suffit).
+    r = admin_client.get("/api/auth/admin/users")
+    assert r.status_code == 200, r.text
+
+
+def test_draco_utilisateur_admin_local_refuse_admin(admin_client, _draco_env, monkeypatch):
+    # Compte local admin authentifié par draco, mais niveau Hub
+    # « utilisateur » : /api/auth/admin/* exige « administrateur ».
+    _patch_hub(monkeypatch, "utilisateur", [])
+    _pose_cookie_draco(admin_client, USER)
+    r = admin_client.get("/api/auth/me")
+    assert r.status_code == 200, r.text                  # session draco OK
+    r = admin_client.get("/api/auth/admin/users")
+    assert r.status_code == 403
+    assert "administrateur" in r.json()["detail"]
+
+
+def test_draco_administrateur_hub_admin_ok(admin_client, _draco_env, monkeypatch):
+    _patch_hub(monkeypatch, "administrateur", [])
+    _pose_cookie_draco(admin_client, USER)
+    r = admin_client.get("/api/auth/admin/users")
+    assert r.status_code == 200, r.text
+    assert any(u["username"] == "admin" for u in r.json())
+
+
+def test_draco_utilisateur_simple_admin_refuse_comme_avant(admin_client, _draco_env, monkeypatch):
+    # Compte local non admin, niveau Hub « administrateur » : le
+    # registre n'élève aucun privilège local — refus par la règle
+    # actuelle (rôle local), comme avant HUB-19.
+    _patch_hub(monkeypatch, "administrateur", [])
+    _pose_cookie_draco(admin_client, USER_SIMPLE)
+    r = admin_client.get("/api/auth/admin/users")
+    assert r.status_code == 403
+    assert r.json()["detail"] == "Accès admin requis"
+
+
+def test_natif_admin_sans_draco_jamais_bloque_par_hub(admin_client, _draco_env, monkeypatch):
+    # Session native (login) + niveau Hub « utilisateur » : le canal
+    # n'est pas draco, la garde du registre ne s'applique pas.
+    _patch_hub(monkeypatch, "utilisateur", [])
+    r = admin_client.post("/api/auth/login",
+                          json={"username": "admin", "password": "chab30"})
+    assert r.status_code == 200, r.text
+    # Le jeton natif valide prime : get_current_user ne passe pas par
+    # le repli draco, le dict utilisateur n'a ni _draco_sub ni
+    # _hub_role — la garde du registre ne peut pas s'appliquer.
+    r = admin_client.get("/api/auth/admin/users")
+    assert r.status_code == 200, r.text
@@ -38,17 +38,20 @@ def test_origin_of():


 def test_sister_origins_dev():
-    # Correctif 2026-10-28 : 10 origines officielles (8 sœurs + 2 agent), prod ET dev,
-    # quelle que soit la résolution.
+    # Correctif 2026-10-28 : origines officielles prod ET dev, quelle
+    # que soit la résolution ; ShaarIt ajoutée par la fédération
+    # v0.2.1 (12 origines : 10 sœurs + 2 agent).
    assert sister_origins(RESOLVED_DEV) == {
        "https://og.dracodev.net",
        "https://flowdeck.dracodev.net",
        "https://tiktak.dracodev.net",
        "https://kanbante.dracodev.net",
+        "https://shaarit.dracodev.net",
        "https://og-dev.dracodev.net",
        "https://flowdeck-dev.dracodev.net",
        "https://tiktak-dev.dracodev.net",
        "https://kanbante-dev.dracodev.net",
+        "https://shaarit-dev.dracodev.net",
        "https://agent.dracodev.net",
        "https://agent-dev.dracodev.net",
    }
Author	SHA1	Message	Date
Spark	b88191ffcb	feat: HUB-21 — réglages généraux du Hub consommés par ObsiGate (bannière + drapeau recherche_partout) #229 CI / lint (pull_request) Successful in 1m16s Details CI / security (pull_request) Successful in 19s Details CI / test (pull_request) Successful in 3m41s Details CI / build (pull_request) Successful in 13s Details CI / e2e (pull_request) Failing after 14m58s Details	2026-11-06 17:02:04 +00:00
bruno	15d015e59b	Merge pull request 'ObsiGate 2.85.1 — HUB-19 : propagation des rôles du Hub (consommatrice, registre D3(a)) (#228 )' (#69 ) from hub19-roles-obsigate-2-85-1 into main CI / lint (push) Successful in 1m14s Details CI / security (push) Successful in 19s Details CI / test (push) Successful in 3m34s Details CI / build (push) Successful in 11s Details CI / e2e (push) Failing after 15m26s Details	2026-11-06 11:31:25 -05:00
Spark	dcf847e2fd	feat: HUB-19 — rôles du Hub consommés par ObsiGate (registre D3(a)) #228 CI / lint (pull_request) Successful in 1m17s Details CI / security (pull_request) Successful in 21s Details CI / test (pull_request) Failing after 3m39s Details CI / build (pull_request) Skipped Details CI / e2e (pull_request) Skipped Details	2026-11-06 16:30:30 +00:00
bruno	a3f76e9b0c	Merge pull request 'ObsiGate 2.85.0 — HUB-22 : API machine des sessions draco (liste et révocation, #227 )' (#68 ) from hub22-sessions-machine into main CI / lint (push) Failing after 11s Details CI / test (push) Skipped Details CI / build (push) Skipped Details CI / e2e (push) Skipped Details CI / security (push) Successful in 24s Details	2026-11-06 11:25:26 -05:00
Spark	c157a22668	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 ) CI / lint (pull_request) Successful in 1m17s Details CI / security (pull_request) Successful in 17s Details CI / test (pull_request) Successful in 3m34s Details CI / build (pull_request) Successful in 17s Details CI / e2e (pull_request) Failing after 16m29s Details	2026-11-06 11:08:04 -05:00
Spark	cc3707be7a	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:08:01 -05:00
Spark	75c6f61235	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:58 -05:00
Spark	8d7692c6df	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:55 -05:00
Spark	318a20c652	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:51 -05:00
Spark	006cbeed64	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:46 -05:00
Spark	92ad47fc99	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:43 -05:00
Spark	84648591ea	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:39 -05:00
Spark	308f99cf63	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:35 -05:00
Spark	3bfda066ab	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:31 -05:00
Spark	0230f4fa72	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:30 -05:00
Spark	9f6f366870	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:27 -05:00
Spark	44a8154cae	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:24 -05:00
Spark	222cd0b562	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 )	2026-11-06 11:07:22 -05:00
Spark	5127510509	revert: HUB-22 — retrait du fichier poussé par erreur sur main (le PUT Contents a ignoré new_branch_name ; la livraison repart en branche hub22-sessions-machine, #227 ) CI / lint (push) Successful in 1m20s Details CI / security (push) Successful in 16s Details CI / test (push) Successful in 4m42s Details CI / build (push) Successful in 13s Details CI / e2e (push) Failing after 14m59s Details	2026-11-06 11:06:56 -05:00
Spark	3876f0e9c3	feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227 ) CI / lint (push) Successful in 1m18s Details CI / security (push) Successful in 16s Details CI / test (push) Successful in 3m35s Details CI / build (push) Successful in 14s Details CI / e2e (push) Failing after 15m32s Details	2026-11-06 11:06:00 -05:00
bruno	c8d2eb19db	Merge pull request 'ObsiGate 2.84.1 — HUB-18 : thème commun, barre v0.5.0 + initialisation thème Hub (fusion #132 )' (#67 ) from hub18-theme-commun into main CI / lint (push) Successful in 1m34s Details CI / security (push) Successful in 28s Details CI / test (push) Successful in 4m49s Details CI / build (push) Successful in 10s Details CI / e2e (push) Failing after 14m54s Details	2026-11-06 09:45:58 -05:00
Spark	2943e40e81	feat: HUB-18 thème commun — barre v0.5.0 + init thème Hub (2.84.1, fusion #132 ) CI / lint (pull_request) Successful in 1m16s Details CI / security (pull_request) Successful in 16s Details CI / test (pull_request) Successful in 3m38s Details CI / build (pull_request) Successful in 13s Details CI / e2e (pull_request) Failing after 15m2s Details	2026-11-06 14:22:45 +00:00
bruno	128deb248d	Merge pull request 'ObsiGate 2.84.0 — HUB-13 : API d'administration des comptes machine-à-machine (fusion #127 )' (#66 ) from hub13-api-admin-comptes-2-84-0 into main CI / lint (push) Successful in 1m15s Details CI / security (push) Successful in 15s Details CI / test (push) Successful in 3m45s Details CI / build (push) Successful in 10s Details CI / e2e (push) Successful in 14m48s Details	2026-11-06 08:40:24 -05:00
Spark	151d9faeab	chore: relance de la vérification de la PR (commit vide, aucun changement de code) CI / lint (pull_request) Successful in 1m17s Details CI / security (pull_request) Successful in 16s Details CI / test (pull_request) Successful in 3m46s Details CI / build (pull_request) Successful in 11s Details CI / e2e (pull_request) Successful in 15m53s Details	2026-11-06 13:34:29 +00:00
bruno	c335f57ea2	Merge PR #66 : ObsiGate 2.84.0 — HUB-13 API admin des comptes (go Bruno) CI / lint (push) Successful in 1m21s Details CI / security (push) Successful in 17s Details CI / test (push) Successful in 3m49s Details CI / build (push) Successful in 15s Details CI / e2e (push) Successful in 15m8s Details	2026-11-05 22:30:21 -05:00
Spark	c27fd977a8	ObsiGate 2.84.0 : version et changelog (HUB-13, fusion #127 ) — VERSION + fichiers dérivés synchronisés par scripts/bump_version.py CI / lint (pull_request) Successful in 1m23s Details CI / security (pull_request) Successful in 23s Details CI / test (pull_request) Successful in 3m34s Details CI / build (pull_request) Successful in 1m32s Details CI / e2e (pull_request) Successful in 15m8s Details	2026-11-06 00:58:19 +00:00
Spark	65d01f91b8	ObsiGate 2.84.0 : API d'administration des comptes machine-à-machine (HUB-13, fusion #127 , #226 ) — routes /api/admin/machine/comptes protégées par DRACO_ADMIN_MACHINE_KEY, révocation des jti draco à la désactivation, must_change_password, journalisation d'audit	2026-11-06 00:58:16 +00:00
bruno	0427c00015	Merge pull request 'ObsiGate 2.83.5 — barre v0.4.1 : correctif des icônes invisibles du menu compte (#125 )' (#65 ) from hub12-barre-v041 into main CI / lint (push) Successful in 2m28s Details CI / security (push) Successful in 25s Details CI / test (push) Successful in 3m34s Details CI / build (push) Successful in 9s Details CI / e2e (push) Successful in 16m51s Details	2026-11-05 02:09:20 -05:00
Spark	b83de53447	ObsiGate 2.83.5 : barre v0.4.1 — menu compte resserré à 232 px, re-vendange verbatim (fusion #125 ) CI / lint (pull_request) Successful in 1m21s Details CI / security (pull_request) Successful in 28s Details CI / test (pull_request) Successful in 5m18s Details CI / build (pull_request) Successful in 15s Details CI / e2e (pull_request) Successful in 16m40s Details	2026-11-05 07:08:02 +00:00
Spark	5eba3e2558	ObsiGate 2.83.5 : version et changelog (barre v0.4.1, fusion #125 ) — VERSION + fichiers dérivés synchronisés par scripts/bump_version.py CI / lint (pull_request) Successful in 1m28s Details CI / security (pull_request) Successful in 17s Details CI / test (pull_request) Successful in 3m57s Details CI / build (pull_request) Successful in 10s Details CI / e2e (pull_request) Successful in 17m0s Details	2026-11-05 05:53:14 +00:00
Spark	10aa88e03c	ObsiGate 2.83.5 : barre v0.4.1 — correctif des icônes invisibles du menu compte, vendange verbatim (fusion #125 ) + garde	2026-11-05 05:53:05 +00:00
bruno	e0e0f9af0f	Merge pull request 'ObsiGate 2.83.4 — barre v0.4.0 : icônes monoline dans le menu compte (HUB-11)' (#64 ) from hub11-barre-v040 into main CI / lint (push) Successful in 1m24s Details CI / security (push) Successful in 17s Details CI / test (push) Successful in 3m35s Details CI / build (push) Successful in 10s Details CI / e2e (push) Successful in 16m38s Details	2026-11-05 00:33:34 -05:00
Spark	35b828a4c5	ObsiGate 2.83.4 : version et changelog (barre v0.4.0, HUB-11) — VERSION + fichiers dérivés synchronisés par scripts/bump_version.py CI / lint (pull_request) Successful in 1m19s Details CI / security (pull_request) Successful in 21s Details CI / test (pull_request) Successful in 3m37s Details CI / build (pull_request) Successful in 12s Details CI / e2e (pull_request) Successful in 16m51s Details	2026-11-05 05:03:01 +00:00
Spark	6ebb3b3eae	ObsiGate 2.83.4 : barre v0.4.0 — icônes monoline du menu compte, vendange verbatim (HUB-11) + garde	2026-11-05 05:02:10 +00:00
bruno	569d0e33a6	Merge pull request 'ObsiGate 2.83.3 : barre v0.3.0 — liens Hub du menu compte (HUB-1)' (#63 ) from hub1-barre-v030 into main CI / lint (push) Successful in 1m31s Details CI / security (push) Successful in 22s Details CI / test (push) Successful in 3m55s Details CI / build (push) Successful in 11s Details CI / e2e (push) Successful in 17m28s Details	2026-11-04 19:48:18 -05:00
Spark	1d1ce5a848	ObsiGate 2.83.3 : barre v0.3.0, liens Hub du menu compte (VERSION + fichiers dérivés synchronisés) CI / lint (pull_request) Successful in 1m18s Details CI / security (pull_request) Successful in 18s Details CI / test (pull_request) Successful in 3m45s Details CI / build (pull_request) Successful in 12s Details CI / e2e (pull_request) Successful in 16m20s Details	2026-11-04 21:57:41 +00:00
Spark	f04369343d	ObsiGate 2.83.3 : barre v0.3.0, liens Hub du menu compte (tests)	2026-11-04 21:57:41 +00:00
Spark	8290abd675	ObsiGate 2.83.3 : barre v0.3.0, liens Hub du menu compte (frontend + draco_config)	2026-11-04 21:57:41 +00:00
bruno	ea60d7e172	Merge pull request 'ObsiGate 2.83.2 : recherche fédérée — ShaarIt, 5e source de « Rechercher partout »' (#62 ) from recherche-shaarit into main CI / lint (push) Successful in 1m29s Details CI / security (push) Successful in 18s Details CI / test (push) Successful in 3m48s Details CI / build (push) Successful in 46s Details CI / e2e (push) Successful in 17m17s Details	2026-11-04 12:23:55 -05:00
Spark	606d59f483	ObsiGate 2.83.2 : recherche fédérée — ShaarIt, 5e source de « Rechercher partout » CI / lint (pull_request) Successful in 1m25s Details CI / security (pull_request) Successful in 20s Details CI / test (pull_request) Successful in 4m4s Details CI / build (pull_request) Failing after 10m20s Details CI / e2e (pull_request) Skipped Details - frontend/js/recherche.js re-vendangé verbatim depuis commons v0.2.1 (source canonique ui/recherche/) : source ShaarIt (bases, onglet, normaliseur — lien profond {base}shaare/<shorturl>). - frontend/recherche.html : data-base-shaarit (jeton URL_SHAARIT), onglet et section « ShaarIt — bookmarks ». - backend/recherche_cors.py : origines ShaarIt prod/dev + clé sœur ; backend/main.py : origine ShaarIt dans le connect-src CSP de la page /recherche. - Version synchronisée par scripts/bump_version.py --set 2.83.2 (VERSION, package.json, desktop, README, ROADMAP, CHANGELOG). - Tests : recherche.test.mjs 67 assertions (5 sources), test_recherche_cors allowlist 12 origines ; suite backend complète 1916 passés / 0 échec, ruff et mypy verts.	2026-11-04 17:23:38 +00:00
@@ -1 +1 @@
 .83.1
 .85.2