grimoire-kit 3.75.0__tar.gz → 3.77.0__tar.gz

{grimoire_kit-3.75.0 → grimoire_kit-3.77.0}/CHANGELOG.md

@@ -7,6 +7,41 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 
 ## [Unreleased]
 
+## [3.77.0] - 2026-10-30
+
+- chore(release): correctifs intermédiaires des PR fusionnées par commit de fusion, déjà décrits par le fragment de leur PR : e56b9bde, 643cd839, 45360126, ea109781, efb3ea4e, 00f1a297, 195fcb60
+- fix(missions): le relecteur ne juge plus une tâche sur un run d'E2E périmé — un check relancé (échec ancien, run en cours) est en cours, pas rouge — et chaque `task.review_judged` porte le verdict CI lu (`ci`, `ci_detail`) (GAO-i8-le-relec-001)
+- fix(cockpit): « À traiter » ne compte plus les consignes des tâches finies ; une consigne non lue sur une tâche ouverte est « à entretenir », le badge et le titre d'onglet ne comptent que les gestes, et clôturer une tâche acquitte ses consignes (raison « tâche close »)
+- feat(missions): boîte à idées — `grimoire idea add|list|drop|promote`, outil MCP `idea_add` et « Garder pour plus tard » dans « Une idée ? » du cockpit : une idée se garde sans être triée, et se transforme en tâches plus tard (I13)
+- fix(cockpit): les cibles tactiles font 44 px à 390 px ou au doigt (jeton `--hit`) et les rubriques de Savoir et de Configuration ne s'effondrent plus à 18 px (GAO-i14-rendre-002)
+- perf(cockpit): le pouls porte une empreinte par projet et l'interface ne relit que le projet affiché quand il a bougé ; l'écart entre deux relectures suit leur durée réelle (3 à 15 s) et la barre d'état compte les relectures par minute (GAO-i11-ne-rech-001)
+- perf(cockpit): le panneau Preuves lit le board et les politiques une fois par requête, ne calcule que les tâches actives (les terminales sont comptées, `?all=1` les détaille) et borne son calcul à 5 s (`truncated`) — 283 tâches en moins de 1,5 s au lieu de plus de 30 s (GAO-i9-rendre-l-001)
+- fix(cockpit): `GET /api/workspace/evidence` n'écrit plus de `gate.checked` dans `runtime-journal.jsonl` (`check_evidence_gates(record=False)`), un journal périmé n'est plus rendu « frais » par l'ouverture du panneau (GAO-i9-rendre-l-001)
+- feat(missions): l'usage réel de chaque session est replié dans sa tâche à chaque tick (journal retrouvé dans le worktree ou par identifiant de session, au plus 5 journaux et 50 Mo par tick) ; `grimoire task usage --backfill [--dry-run]` rattrape les tâches closes ; un journal absent est dit « journal de session introuvable »
+
+## [3.76.0] - 2026-10-29
+
+- chore(release): correctifs intermédiaires des PR fusionnées par commit de fusion, déjà décrits par le fragment de leur PR : a4b0e8a7, 077bba97, e82f2a3f, 7198f1de, abd4ef41, d17c4672, 27fe2020, 5de84791, 773d7441, bcb735df
+- feat(cockpit): le chat d'orchestrateur branché sur le pilote automatique (ACP4, `GAO-acp4-chat-d-001`). Pilote activé, une question qui reste à l'humain (liste réservée de P82 ou confiance basse) est posée dans le chat en plus de « À traiter » ; la réponse tapée après « Répondre ici » est une réponse humaine par le canal du cockpit. À l'ouverture, le chat résume les décisions du pilote depuis la dernière visite, avec un lien vers le journal. L'orchestrateur peut proposer `[[pilote:on]]` / `[[pilote:off]]` : le chat en fait un bouton que la personne clique avec la clé de contrôle, l'agent n'a aucun chemin pour activer ou couper le pilote.
+- fix(intake): l'intake propose ses titres et justifications en français (« Écrire les tests : … », « Tâche principale détectée dans la demande », etc.), sans changer le découpage ni les types, risques et vérifiabilités proposés (GAO-i7-l-intake-001)
+- feat(cockpit): dix-neuf icônes d'action `i-act-*` dans le sprite (P38, GAO-p38-ic-nes-001) : exception Lucide accordée — pause, skip, save, send, unlock, ban, back, next, approve, reject (déjà présentes), plus copy, close, preview, retry, add, filter, remove, launch, stop, choisies d après la fréquence des verbes du cockpit. Tracés Lucide (ISC) au trait 1,75, `web/workspace/icons/NOTICE` porte la licence, la charte écrit « aucune icône d'identité empruntée ». Aucun appel dans le cockpit encore.
+- feat(memory): correction mémoire déléguée à un agent (P42, GAO-p42-correct-001) : « Demander une correction… » ouvre une tâche au critère généré selon le résultat attendu (`corrects: <id>` pour remplacer ou fusionner) ; l'agent dépose sa correction par `grimoire memory correct propose` comme proposition `memory-correction` (`grimoire.proposals`), sans écrire en mémoire ; accepter applique par `MemoryManager`, le journal P14 porte `proposed_by` et `applied_by` ; une proposition dont une entrée a changé depuis la demande est périmée (refusée, aperçu sur l'état actuel) ; le formulaire prévient que l'annulation de la tâche n'arrête pas la session de l'agent, qui peut encore travailler (tant que GAO-annuler-arr-001 n'est pas livré).
+- feat(cockpit): chat d'orchestrateur, étape 3 (ACP3, GAO-acp3-chat-d-001) : tous les hôtes, choix par projet, doctor ACP, repli kanban
+  - **Table de lancement** (`HostProfile.acp_command`) : Gemini CLI `gemini --acp`, Copilot CLI `copilot --acp` (preview, à valider), Codex `npx -y @agentclientprotocol/codex-acp` (exige `npx` et `codex`), Cursor `agent acp`, opencode `opencode acp`. Le profil porte aussi `acp_binary`, `acp_preview` et `acp_note`.
+  - **Choix de l'hôte** par projet : sélecteur dans l'onglet Orchestrateur (`GET /api/workspace/chat/hosts`, `POST /api/workspace/chat/host`), mémorisé sous `_grimoire-runtime-output/cockpit/chat-host.json` ; sans réglage, l'hôte détecté. Les hôtes non installés sont grisés avec leur raison. `GRIMOIRE_CHAT_HOST` et `GRIMOIRE_CHAT_AGENT_COMMAND` passent toujours avant.
+  - **Doctor** : `grimoire doctor` négocie `initialize` avec le mode ACP de chaque hôte installé (aucun `session/new`, aucun prompt, donc aucun coût) ; un mode muet est un avertissement, le chat se replie sur le kanban.
+  - **Repli kanban** (Copilot dans VS Code n'a pas d'interface externe, ni tout hôte sans ACP lançable) : le chat dépose une consigne humaine sur la tâche tenue (ou `task_id`), et le fil affiche les notes, questions et commentaires que les sessions y déposent ; le fil se relit du ledger, il survit au redémarrage. En différé, mais disponible partout.
+  - **Pérennité** : Gemini CLI cède la place à Antigravity CLI pour les comptes gratuits (juin 2026) — `gemini --acp` reste valable tant que la CLI est installée, la commande du profil est à mettre à jour à la migration ; le mode ACP de Copilot CLI est en preview, signalé dans le sélecteur et par le doctor.
+- feat(cockpit): « Lancer » dans le guide Démarrer — le plan de P36 s'exécute par les actions typées de P40, étape par étape (P45, `GAO-p45-premier-001`)
+  - **Étapes** : démarrer les services du profil (sautable), composer la mémoire (`memory.compose`), vérifier par un aller-retour mémoire réel (écrire, retrouver, retirer un souvenir de test, relu absent), lancer doctor (sautable). Un échec est traduit en phrase avec son remède (motif brut à part) ; **Réessayer**, **Sauter** (étapes non bloquantes seulement) et **Revenir en arrière** (inverse consigné, dernière étape d'abord). Un écart de vérification s'affiche avec sa commande de remède.
+  - **Avancement enregistré** (`_grimoire-runtime-output/setup/launch.json`, écrit avant chaque étape) : après rechargement, l'étape interrompue est dite telle et reprise là, sans rejouer ce qui est fait.
+  - **Routes** : `GET /api/workspace/setup/launch`, `POST /api/workspace/setup/launch` (`verb` : `start`, `next`, `retry`, `skip`, `rollback`, `reset`). Aucune écriture à l'ouverture du guide ; sans `project-context.yaml` (S0) il n'existe pas d'action typée d'initialisation : l'étape de composition est bloquée et dit `grimoire init` à copier.
+- feat(cockpit): carte de décision v2 dans « À traiter › Décisions » — titre et contexte en deux lignes, puces de pièces dépliables (diff, CI, lien, fichier, capture, commande), recommandation avec sa raison, choix unique ou multiple avec conséquence, « Tout cocher / Tout décocher », consigne facultative, « Plus tard » qui n'envoie rien ; la réponse part en texte lisible et en `answer_data`, « Demandes précédentes » (ce que tu as répondu et la suite, lus au ledger via `waiting.rounds`), badge « 2e demande », raccourcis 1-9, R, E, H et Ctrl+Entrée (aucun envoi en un seul appui), barre « Envoyer » collante et cibles de 48 px à 390 px ; une question v1 garde la carte actuelle (GAO-p93-carte-d-001)
+- perf(cockpit): réponses JSON et fichiers texte en gzip au-delà de 1 Ko, `ETag` + `Last-Modified` + 304 sur les fichiers statiques (`no-cache` conservé), HTTP/1.1 avec keep-alive (flux SSE inchangés), liste `tasks` allégée (consignes, description, garde-fous, dépendances par `tasks/<id>`), lecture du board du standard en libyaml et mise en cache : la fiche Piloter passe de ~0,9 s à ~0,15 s (GAO-p94-cockpit-001)
+- feat(cockpit): « Une idée ? » dans l'espace Travail (raccourci `n`, palette) transforme une phrase en tâches prêtes (I2, `GAO-i2-transfor-001`). `POST /api/workspace/tasks/intake` rend, sans LLM et de façon déterministe, des propositions avec type, risque, vérifiabilité et critère proposé par classe ; une commande de vérification est requise pour passer en prête (V0/V1) ; les propositions critiques ne sont jamais cochées d'office ; « Créer N tâches (prêtes) » passe par `TaskService.add`, un refus du gate laisse la tâche proposée avec sa raison. CLI : `grimoire task add --intake "<texte>" --create [--json]` ; sans `--create`, rien n'est écrit.
+- fix(windows): la commande de notification d'une décision attendue se découpe comme le shell du système (`grimoire.core.command_line.split_command`, partagé avec le chat ACP) : sous Windows, un chemin `C:\…\python.exe` n'est plus réduit par `shlex` en mode POSIX (main rouge sous Windows, 2026-10-29).
+- feat(cockpit): prévenir d'une décision attendue, onglet masqué ou fermé (I1, `GAO-i1-pr-venir-001`). Le titre de l'onglet devient « (N) Grimoire » avec une pastille sur le favicon, rendus à l'identique à zéro. L'interrupteur « Me prévenir dans le navigateur » émet une notification par nouvelle question (dédupliquée par identifiant, même après rechargement) et garde le flux ouvert onglet masqué — seule exception au gel, absente tant qu'il est coupé. Configuration gagne la « Commande de notification » (`options.notify.command`) avec un bouton « Tester » (`POST /api/workspace/notify/test`), `grimoire doctor` signale une commande illisible, et le guide `docs/guides/etre-prevenu-d-une-decision.md` donne des recettes `notify-send` et `ntfy`.
+
 ## [3.75.0] - 2026-10-29
 
 - chore(release): correctifs intermédiaires des PR fusionnées par les lots #1079 et précédents (commit de fusion), déjà décrits par le fragment de leur PR : 1ef3a7e4, df5d4745, c9ab5169, 1327282a, 6f8f19ba, 12ede29d, fe3db122, d92ca3d1, adcfed29, 1a2eb076, 2635f82b, 279bd31b

{grimoire_kit-3.75.0 → grimoire_kit-3.77.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grimoire-kit
-Version: 3.75.0
+Version: 3.77.0
 Summary: Dashboard, task board, project memory and evidence check for code you delegate to agents (Claude Code, Copilot).
 Project-URL: Homepage, https://github.com/Guilhem-Bonnet/Grimoire-kit
 Project-URL: Repository, https://github.com/Guilhem-Bonnet/Grimoire-kit

grimoire_kit-3.77.0/docs/assets/captures/i1/README.md

@@ -0,0 +1,11 @@
+---
+audience: contributeur
+---
+
+# Captures I1 — prévenir d'une décision attendue
+
+Playwright, projet de test avec deux décisions en attente, le 2026-10-29. Le titre d'onglet relevé par `page.title()` dans les trois cas est « (2) Grimoire — vue de travail ».
+
+- `interrupteur-{clair,sombre}.png` : barre d'état à 1440 px, interrupteur « Me prévenir dans le navigateur » actif (`aria-pressed="true"`).
+- `interrupteur-390px.png` : la même barre à 390 px — icône seule, nom accessible conservé, aucun défilement horizontal.
+- `reglage-{clair,sombre,390px}.png` : carte « Commande de notification » de Configuration, avec ses boutons Enregistrer et Tester.

grimoire_kit-3.77.0/docs/captures/p42-correction/README.md

@@ -0,0 +1,12 @@
+---
+audience: contributeur
+---
+
+# Captures P42 — correction mémoire déléguée à un agent
+
+Quatre captures, clair et sombre, de l'inspecteur Savoir (cockpit, kit 3.73.0, projet de démonstration `forge-p34`) :
+
+- `p42-demander-une-correction-*.png` : « Demander une correction… » ouvert sur une décision en vigueur ; mode « Remplacer par une entrée corrigée », consigne libre, bouton « Créer la tâche » ;
+- `p42-tache-creee-*.png` : après envoi, le retour nomme la tâche créée (`GAO-corriger-la-002`) et son critère vérifiable (« l'entrée … est remplacée par une entrée qui porte … ») ; l'entrée d'origine reste lisible.
+
+Validées par Claude sous délégation explicite de Guilhem (2026-10-28 : « tu as le droit d'approuver tout en mon nom » ; 2026-10-29 : « fais aussi les revues »), le 2026-10-29 : le parcours est complet, lisible dans les deux thèmes, sans action destructive implicite (« Supprimer… » reste distinct et en rouge).

{grimoire_kit-3.75.0 → grimoire_kit-3.77.0}/registry/kit-file-hashes.json

@@ -1,6 +1,6 @@
 {
  "schema": "grimoire-kit-file-hashes/v1",
- "generated_for": "3.75.0",
+ "generated_for": "3.77.0",
  "digests": {
   "002d1e68ce00769ee09d1e94f4af260b952837f7d1557080c2fd505216c23ac0": {
    "version": "3.11.2",

grimoire_kit-3.77.0/src/grimoire/__version__.py

@@ -0,0 +1 @@
+__version__ = "3.77.0"

{grimoire_kit-3.75.0 → grimoire_kit-3.77.0}/src/grimoire/cli/_lazy_extra.py

@@ -13,4 +13,5 @@ from grimoire.cli._lazy import LazyGroupSpec
 #: Nom → groupe, dans l'ordre d'affichage de ``grimoire --help --all``.
 EXTRA_GROUPS: dict[str, LazyGroupSpec] = {
     "steward": LazyGroupSpec("grimoire.cli.cmd_steward", "steward_app", rich_help_panel="Project"),
+    "idea": LazyGroupSpec("grimoire.cli.cmd_idea", "idea_app", rich_help_panel="Project"),
 }

{grimoire_kit-3.75.0 → grimoire_kit-3.77.0}/src/grimoire/cli/app.py

@@ -606,7 +606,7 @@ def doctor(
 
     with _timed_phase("host_brake"):  # P86 : le frein de la version d'hôte courante est-il prouvé ?
         from grimoire.cli.doctor_brake import apply_host_brake_check
-        apply_host_brake_check(results, fmt=fmt, console=console)
+        apply_host_brake_check(results, fmt=fmt, console=console, project_root=target)
 
     # 4quinquies. Override drift (issue #427) — un override est une copie ou
     # une extension du kit, jamais une garantie qu'il en reçoit encore les

{grimoire_kit-3.75.0 → grimoire_kit-3.77.0}/src/grimoire/cli/cmd_chat.py

@@ -6,8 +6,6 @@ projet ; ses demandes de permission sont posées dans le terminal. Rien n'est ac
 
 from __future__ import annotations
 
-import os
-import shlex
 import sys
 from pathlib import Path
 from typing import Annotated
@@ -16,6 +14,7 @@ import typer
 from rich.console import Console
 
 from grimoire.acp import AcpClient, AcpError, PermissionRequest
+from grimoire.core.command_line import split_command
 from grimoire.hosts.capabilities import profile_for, resolve_host
 
 console = Console(stderr=True)
@@ -23,19 +22,6 @@ console = Console(stderr=True)
 _ALLOW = ("allow_once", "allow_always")
 
 
-def split_command(text: str, *, posix: bool | None = None) -> tuple[str, ...]:
-    """Découpe une ligne de commande comme le shell du système : sous Windows, l'antislash n'est pas un échappement.
-
-    ``shlex`` en mode POSIX lit ``C:\\tools\\python.exe`` comme ``C:toolspython.exe`` (CI Windows du 2026-10-28) ;
-    hors POSIX, il garde les antislashs mais laisse les guillemets autour d'un argument, retirés ici.
-    """
-    posix = os.name != "nt" if posix is None else posix
-    parts = shlex.split(text, posix=posix)
-    if not posix:
-        parts = [p[1:-1] if len(p) >= 2 and p[0] == p[-1] == '"' else p for p in parts]
-    return tuple(parts)
-
-
 def ask_in_terminal(request: PermissionRequest) -> str | None:
     """Pose la demande au terminal ; une réponse vide, invalide ou un EOF annule."""
     console.print(f"\n[bold yellow]Permission demandée[/bold yellow] (outil {request.tool_call_id})")

{grimoire_kit-3.75.0 → grimoire_kit-3.77.0}/src/grimoire/cli/cmd_cockpit.py

@@ -35,6 +35,7 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
+from grimoire.cli.cockpit_http import DRAIN_LIMIT, CountingReader, gzip_body, serve_asset, warm_sheet
 from grimoire.data import site_script, web_path
 from grimoire.tools.cockpit_registry_routes import REGISTRY_ROUTES, registry_post
 from grimoire.tools.project_registry import (
@@ -82,12 +83,14 @@ console = Console(stderr=True)
 # écrivent le même fichier, et deux copies de cette logique finiraient par
 # diverger. Seul le dossier de service reste propre au cockpit.
 
+
 def _serve_dir() -> Path:
     return registry_home() / "serve"
 
 
 # ── Daemon helpers (background start/stop) ────────────────────────────────────
 
+
 def _read_state() -> dict[str, Any] | None:
     """État du démon, ``None`` quand il n'y en a pas — les appelants testent la
     présence d'un cockpit démarré, pas le contenu d'un dictionnaire vide."""
@@ -128,6 +131,7 @@ def _terminate(pid: int) -> bool:
 # ── Registry I/O ──────────────────────────────────────────────────────────────
 # Délégué à ``grimoire.tools.project_registry`` (voir les imports en tête).
 
+
 def _resolve_project_path(slug: str | None) -> Path | None:
     """Map a registry slug to its absolute project path (first project if slug is empty)."""
     projects = load_registry()
@@ -276,66 +280,31 @@ def _run_memory_in_process(proot: Path, argv: list[str]) -> _CliResult:
         pool.shutdown(wait=False)
 
 
-#: Borne du drainage d'un corps refusé, comme ``request_guard.drain_body``.
-_DRAIN_LIMIT = 1 << 20
-
-
-class _CountingReader:
-    """``rfile`` qui compte les octets lus — pour savoir ce qu'il reste du corps.
-
-    ``http.client`` envoie l'en-tête et le corps en deux ``send`` distincts ;
-    sous charge, le serveur peut parser l'en-tête, refuser (403/404), répondre
-    et fermer avant que le corps n'arrive. Le corps atteint alors un socket
-    fermé : RST, que Windows répercute au client en jetant la réponse déjà
-    reçue (``WinError 10053``, #857). Compter ce qui a été lu permet à
-    :meth:`_CockpitHandler._drain_unread_body` de consommer *exactement* le
-    reste déclaré par ``Content-Length`` avant de répondre, sans jamais
-    bloquer sur un corps déjà lu.
-    """
-
-    def __init__(self, raw: Any) -> None:
-        self._raw = raw
-        self.consumed = 0
-
-    def read(self, *args: Any) -> bytes:
-        data: bytes = self._raw.read(*args)
-        self.consumed += len(data)
-        return data
-
-    def readline(self, *args: Any) -> bytes:
-        data: bytes = self._raw.readline(*args)
-        self.consumed += len(data)
-        return data
-
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._raw, name)
-
-
 class _CockpitHandler(SimpleHTTPRequestHandler):
     """Static file server + a tiny POST ``/api/memory`` governance endpoint."""
 
     def log_message(self, *args: object) -> None:
         return  # quiet by default
 
-    def send_header(self, keyword: str, value: str) -> None:
-        super().send_header(keyword, value)
-        # Seuls les fichiers statiques portent ``Last-Modified``. Sans
-        # ``Cache-Control``, le navigateur gardait d'anciens modules JS/CSS
-        # après une mise à jour du kit ; icons.svg et polices prennent une
-        # minute (``no-cache`` y coûtait une requête par rendu d'icône).
-        if keyword.lower() == "last-modified":
-            js_css = Path(urlparse(self.path).path).suffix.lower() in {".js", ".mjs", ".css"}
-            super().send_header("Cache-Control", "no-cache" if js_css else "max-age=60")
+    # P94 : HTTP/1.1 et keep-alive — une connexion TCP sert plusieurs requêtes.
+    # Chaque réponse porte un ``Content-Length`` ; seuls les flux SSE
+    # (``Connection: close``) n'en ont pas. Un client silencieux libère son
+    # fil au bout de ``timeout`` secondes.
+    protocol_version = "HTTP/1.1"
+    timeout = 60
+    # En-tête et corps partent en deux écritures : sans cela, Nagle + ACK différé
+    # retardent le corps d'~40 ms par réponse sur une connexion qui reste ouverte.
+    disable_nagle_algorithm = True
 
     def setup(self) -> None:
         super().setup()
-        self.rfile = _CountingReader(self.rfile)  # type: ignore[assignment]
+        self.rfile = CountingReader(self.rfile)  # type: ignore[assignment]
 
     def parse_request(self) -> bool:
         ok = super().parse_request()
         # Les octets lus jusqu'ici sont la ligne de requête et les en-têtes ;
         # à partir de maintenant, le compteur ne mesure que le corps.
-        cast(_CountingReader, self.rfile).consumed = 0
+        cast(CountingReader, self.rfile).consumed = 0
         return ok
 
     def _drain_unread_body(self) -> None:
@@ -346,12 +315,12 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
         réponse (``ConnectionAbortedError``). Le reste est borné par
         ``Content-Length`` et ignoré, jamais interprété.
         """
-        rfile = cast(_CountingReader, self.rfile)
+        rfile = cast(CountingReader, self.rfile)
         try:
             declared = int(self.headers.get("Content-Length") or 0)
         except (ValueError, TypeError):
             return
-        remaining = min(declared - rfile.consumed, _DRAIN_LIMIT)
+        remaining = min(declared - rfile.consumed, DRAIN_LIMIT)
         if remaining > 0:
             with contextlib.suppress(OSError, ValueError):
                 rfile.read(remaining)
@@ -406,11 +375,13 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
         # (``HTTP/1.0``), l'en-tête le dit au client, et le tampon est vidé
         # avant que ``finish`` ne ferme le socket.
         self._drain_unread_body()
-        body = json.dumps(payload).encode("utf-8")
+        body = json.dumps(payload, separators=(",", ":")).encode("utf-8")
         self.send_response(code)
         self.send_header("Content-Type", "application/json; charset=utf-8")
+        body = gzip_body(self, body)
         self.send_header("Content-Length", str(len(body)))
-        self.send_header("Connection", "close")
+        if self.close_connection:  # le client l'a demandé (ou l'erreur de requête l'impose) : on le dit
+            self.send_header("Connection", "close")
         self.end_headers()
         self.wfile.write(body)
         self.wfile.flush()
@@ -445,16 +416,20 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
         target = Path(self.translate_path(self.path))
         if target.is_dir():
             target = target / "index.html"
-        if target.suffix.lower() != ".html" or not target.is_file():
+        if not target.is_file():
             super().do_GET()
             return
-        body = inject_session_token(target.read_bytes())
-        self.send_response(200)
-        self.send_header("Content-Type", "text/html; charset=utf-8")
-        self.send_header("Content-Length", str(len(body)))
-        self.send_header("Cache-Control", "no-store")
-        self.end_headers()
-        self.wfile.write(body)
+        if target.suffix.lower() == ".html":
+            body = inject_session_token(target.read_bytes())
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Cache-Control", "no-store")
+            body = gzip_body(self, body)
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+            return
+        serve_asset(self, target)
 
     def do_GET(self) -> None:  # http.server contract
         parsed = urlparse(self.path)
@@ -505,6 +480,8 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             self.send_response(200)
             for name, value in STREAM_HEADERS:
                 self.send_header(name, value)
+            # Un flux n'a pas de longueur : sous HTTP/1.1 il se clôt avec la connexion.
+            self.send_header("Connection", "close")
             self.end_headers()
             self.close_connection = True
             try:
@@ -882,6 +859,7 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             return
         if gesture:
             from grimoire.tools.workspace_memory_gestures import handle as memory_gesture
+
             self._send_json(*memory_gesture(proot, data))
             return
         subcmd = action
@@ -919,11 +897,17 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
         except TimeoutError:
             self._send_json(504, {"ok": False, "error": "timeout"})
             return
-        self._send_json(200, {
-            "ok": res.returncode == 0, "code": res.returncode,
-            "stdout": res.stdout, "stderr": res.stderr, "action": action,
-            "mutation": is_mutation,
-        })
+        self._send_json(
+            200,
+            {
+                "ok": res.returncode == 0,
+                "code": res.returncode,
+                "stdout": res.stdout,
+                "stderr": res.stderr,
+                "action": action,
+                "mutation": is_mutation,
+            },
+        )
 
     def do_PUT(self) -> None:  # http.server contract
         """``PUT /api/blueprints/<id>`` — enregistrer un blueprint (issue #535).
@@ -969,6 +953,7 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
 
 # ── Commands ──────────────────────────────────────────────────────────────────
 
+
 @cockpit_app.command("add")
 def add(
     path: Annotated[Path, typer.Argument(help="Path to a local Grimoire project.")],
@@ -1271,7 +1256,9 @@ def _generate_data(serve_dir: Path, with_tests: bool) -> bool:
 
 @cockpit_app.command("refresh")
 def refresh(
-    with_tests: Annotated[bool, typer.Option("--with-tests", help="Run pytest --collect-only per project (slow).")] = False,
+    with_tests: Annotated[
+        bool, typer.Option("--with-tests", help="Run pytest --collect-only per project (slow).")
+    ] = False,
 ) -> None:
     """Regenerate the cockpit data layer without serving."""
     serve_dir = _serve_dir()
@@ -1279,8 +1266,7 @@ def refresh(
     if _generate_data(serve_dir, with_tests):
         console.print(f"[green]✓[/green] Données régénérées → {serve_dir / 'data'}")
     else:
-        console.print("[dim]Aucun projet enregistré — rien à générer. "
-                      "[b]grimoire cockpit scan <dossier>[/b][/dim]")
+        console.print("[dim]Aucun projet enregistré — rien à générer. [b]grimoire cockpit scan <dossier>[/b][/dim]")
 
 
 @cockpit_app.command("serve")
@@ -1288,7 +1274,9 @@ def serve(
     port: Annotated[int, typer.Option("--port", "-p", help="Local port.")] = 8420,
     open_browser: Annotated[bool, typer.Option("--open/--no-open", help="Open the browser.")] = True,
     do_refresh: Annotated[bool, typer.Option("--refresh/--no-refresh", help="Regenerate data before serving.")] = True,
-    with_tests: Annotated[bool, typer.Option("--with-tests", help="Run pytest --collect-only per project (slow).")] = False,
+    with_tests: Annotated[
+        bool, typer.Option("--with-tests", help="Run pytest --collect-only per project (slow).")
+    ] = False,
     project_root: Annotated[
         Path | None,
         typer.Option("--project-root", help="Projet à ouvrir (défaut : dossier courant)."),
@@ -1305,8 +1293,10 @@ def serve(
             console.print("[green]✓[/green] Data layer régénéré depuis le registre.")
         else:
             console.print("[dim]Registre vide → cockpit vide (aucune donnée inventée).[/dim]")
-            console.print("[dim]Ajoute des projets : [b]grimoire cockpit add <path>[/b] "
-                          "ou [b]grimoire cockpit scan <dossier>[/b][/dim]")
+            console.print(
+                "[dim]Ajoute des projets : [b]grimoire cockpit add <path>[/b] "
+                "ou [b]grimoire cockpit scan <dossier>[/b][/dim]"
+            )
     if cwd_notice is None:
         notice = _unregistered_cwd_notice(load_registry())
         if notice:
@@ -1330,6 +1320,10 @@ def serve(
     console.print(f"[bold green]Cockpit[/bold green] → [link]{url}[/link]  [dim](Ctrl-C pour arrêter)[/dim]")
     if open_browser:
         webbrowser.open(url)
+    if _HOME_PATH is not None:
+        # P94 : la première lecture de la fiche paie imports et caches froids ;
+        # elle se fait ici, avant que la page ne la demande.
+        threading.Thread(target=warm_sheet, args=(_HOME_PATH,), daemon=True).start()
     try:
         httpd.serve_forever()
     except KeyboardInterrupt:
@@ -1342,7 +1336,9 @@ def serve(
 def start(
     port: Annotated[int, typer.Option("--port", "-p", help="Local port.")] = 8420,
     open_browser: Annotated[bool, typer.Option("--open/--no-open", help="Open the browser.")] = True,
-    with_tests: Annotated[bool, typer.Option("--with-tests", help="Run pytest --collect-only per project (slow).")] = False,
+    with_tests: Annotated[
+        bool, typer.Option("--with-tests", help="Run pytest --collect-only per project (slow).")
+    ] = False,
 ) -> None:
     """Start the cockpit in the background (non-blocking) and open it."""
     state = _read_state()
@@ -1361,11 +1357,11 @@ def start(
     if _generate_data(serve_dir, with_tests):
         console.print("[green]✓[/green] Data layer régénéré depuis le registre.")
     else:
-        console.print("[dim]Registre vide → cockpit vide. "
-                      "[b]grimoire cockpit add <path>[/b] ou [b]scan <dossier>[/b][/dim]")
+        console.print(
+            "[dim]Registre vide → cockpit vide. [b]grimoire cockpit add <path>[/b] ou [b]scan <dossier>[/b][/dim]"
+        )
 
-    cmd = [sys.executable, "-m", "grimoire", "cockpit", "serve",
-           "--port", str(port), "--no-open", "--no-refresh"]
+    cmd = [sys.executable, "-m", "grimoire", "cockpit", "serve", "--port", str(port), "--no-open", "--no-refresh"]
     pid = _spawn_detached(cmd)
     url = f"http://127.0.0.1:{port}/workspace/index.html"
     for _ in range(24):
@@ -1423,15 +1419,21 @@ def status() -> None:
 # Le parcours est dans ``project_registry`` : ``grimoire serve`` expose la même
 # découverte depuis l'atelier (POST /api/projects/scan).
 
+
 @cockpit_app.command("scan")
 def scan(
     root: Annotated[Path, typer.Argument(help="Root directory to crawl for local projects.")],
     depth: Annotated[int, typer.Option("--depth", help="Maximum crawl depth.")] = 4,
-    yes: Annotated[bool, typer.Option("--yes", "-y", help="Enrol all grimoire-managed projects without prompting.")] = False,
-    include_uninitialized: Annotated[bool, typer.Option(
-        "--include-uninitialized",
-        help="Also enrol bare git repos that are not grimoire-initialized.",
-    )] = False,
+    yes: Annotated[
+        bool, typer.Option("--yes", "-y", help="Enrol all grimoire-managed projects without prompting.")
+    ] = False,
+    include_uninitialized: Annotated[
+        bool,
+        typer.Option(
+            "--include-uninitialized",
+            help="Also enrol bare git repos that are not grimoire-initialized.",
+        ),
+    ] = False,
 ) -> None:
     """Discover projects under a root directory and enrol them in the cockpit."""
     base = root.expanduser().resolve()
@@ -1459,10 +1461,7 @@ def scan(
         table.add_row(_rel(cand.path), kind, reg)
     console.print(table)
 
-    to_enrol = [
-        c for c in candidates
-        if (c.managed or include_uninitialized) and str(c.path) not in registered_paths
-    ]
+    to_enrol = [c for c in candidates if (c.managed or include_uninitialized) and str(c.path) not in registered_paths]
     uninitialized = [c for c in candidates if not c.managed]
 
     if to_enrol:

grimoire_kit-3.77.0/src/grimoire/cli/cmd_idea.py

@@ -0,0 +1,118 @@
+"""CLI ``grimoire idea`` — la boîte à idées : garder maintenant, décider plus tard (I13)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Annotated
+
+import typer
+from rich.console import Console
+from rich.markup import escape
+
+if TYPE_CHECKING:
+    from grimoire.missions.ideas import Idea, IdeaStore
+
+idea_app = typer.Typer(help="Boîte à idées : add, list, drop, promote.", no_args_is_help=True)
+console = Console()
+
+_PROJECT_ROOT = typer.Option("--project-root", help="Racine du projet.", show_default=False)
+_LEDGER_ROOT = typer.Option("--ledger-root", help="Racine du Mission Ledger (relative au projet).")
+_DEFAULT_LEDGER = Path("_grimoire-runtime-output/ledger")
+
+
+def _store(project_root: Path, ledger_root: Path) -> IdeaStore:
+    from grimoire.missions.ideas import IdeaStore
+
+    return IdeaStore(project_root.resolve(), ledger_root)
+
+
+def _fail(message: str) -> typer.Exit:
+    console.print(f"[red]✗[/red] {escape(message)}")
+    return typer.Exit(1)
+
+
+def _line(idea: Idea) -> str:
+    tasks = f" → {', '.join(idea.tasks)}" if idea.tasks else ""
+    return f"{idea.id}  {escape(f'[{idea.state}]')}  {escape(idea.text)}{tasks}"
+
+
+@idea_app.command("add")
+def idea_add(
+    text: Annotated[str, typer.Argument(help="L'idée, en une phrase (500 caractères au plus).")],
+    project_root: Annotated[Path, _PROJECT_ROOT] = Path(),
+    ledger_root: Annotated[Path, _LEDGER_ROOT] = _DEFAULT_LEDGER,
+    json_output: Annotated[bool, typer.Option("--json", help="Sortie JSON.")] = False,
+) -> None:
+    """Garde une idée sans la trier."""
+    from grimoire.missions.ideas import IdeaError
+
+    try:
+        idea = _store(project_root, ledger_root).add(text, "cli")
+    except IdeaError as exc:
+        raise _fail(str(exc)) from exc
+    if json_output:
+        typer.echo(json.dumps(idea.to_dict(), indent=2, ensure_ascii=False))
+        return
+    console.print(f"[green]✓[/green] {_line(idea)}")
+
+
+@idea_app.command("list")
+def idea_list(
+    project_root: Annotated[Path, _PROJECT_ROOT] = Path(),
+    ledger_root: Annotated[Path, _LEDGER_ROOT] = _DEFAULT_LEDGER,
+    state: Annotated[str, typer.Option("--state", help="Filtrer : open, promoted ou dropped.")] = "",
+    json_output: Annotated[bool, typer.Option("--json", help="Sortie JSON.")] = False,
+) -> None:
+    """Les idées, dans l'ordre où elles ont été gardées."""
+    ideas = _store(project_root, ledger_root).list(state)
+    if json_output:
+        typer.echo(json.dumps([i.to_dict() for i in ideas], indent=2, ensure_ascii=False))
+        return
+    if not ideas:
+        console.print("[dim]Aucune idée.[/dim]")
+    for idea in ideas:
+        console.print(_line(idea))
+
+
+@idea_app.command("drop")
+def idea_drop(
+    idea_id: Annotated[str, typer.Argument(help="Identifiant de l'idée.")],
+    project_root: Annotated[Path, _PROJECT_ROOT] = Path(),
+    ledger_root: Annotated[Path, _LEDGER_ROOT] = _DEFAULT_LEDGER,
+) -> None:
+    """Écarte une idée ouverte (le journal garde la trace)."""
+    from grimoire.missions.ideas import IdeaError
+
+    try:
+        idea = _store(project_root, ledger_root).drop(idea_id)
+    except IdeaError as exc:
+        raise _fail(str(exc)) from exc
+    console.print(f"[green]✓[/green] {_line(idea)}")
+
+
+@idea_app.command("promote")
+def idea_promote(
+    idea_id: Annotated[str, typer.Argument(help="Identifiant de l'idée.")],
+    project_root: Annotated[Path, _PROJECT_ROOT] = Path(),
+    ledger_root: Annotated[Path, _LEDGER_ROOT] = _DEFAULT_LEDGER,
+    json_output: Annotated[bool, typer.Option("--json", help="Sortie JSON.")] = False,
+) -> None:
+    """Crée les tâches que l'intake propose (comme `task add --intake --create`), puis marque l'idée promue."""
+    from grimoire.core.exceptions import GrimoireError
+    from grimoire.missions.ideas import IdeaError
+    from grimoire.missions.service import TaskService
+
+    service = TaskService(project_root.resolve(), ledger_root)
+    try:
+        idea, created = _store(project_root, ledger_root).promote(idea_id, service)
+    except (IdeaError, GrimoireError, ValueError) as exc:
+        raise _fail(str(exc)) from exc
+    if json_output:
+        typer.echo(json.dumps({"idea": idea.to_dict(), "created": created}, indent=2, ensure_ascii=False))
+        return
+    console.print(f"[green]✓[/green] {_line(idea)}")
+    for entry in created:
+        console.print(f"    {entry['id']} ({entry['status']}) {escape(entry['title'])}")
+        if entry["reason"]:
+            console.print(f"    [yellow]{escape(entry['reason'])}[/yellow]")

{grimoire_kit-3.75.0 → grimoire_kit-3.77.0}/src/grimoire/cli/cmd_memory.py

@@ -900,6 +900,36 @@ def memory_recall(
     console.print(tbl)
 
 
+# ── grimoire memory correct propose (P42) ──────────────────────────────────
+
+
+correct_app = typer.Typer(help="Correction mémoire déléguée : l'agent propose, l'humain accepte.")
+memory_app.add_typer(correct_app, name="correct")
+
+
+@correct_app.command("propose")
+def memory_correct_propose(
+    task_id: str = typer.Argument(..., help="Tâche de correction ouverte par « Demander une correction »."),
+    action: str = typer.Option(..., "--action", help="replace | merge | attach_source | retract."),
+    text: str = typer.Option("", "--text", help="Texte corrigé (replace, merge)."),
+    source: str = typer.Option("", "--source", help="Source à rattacher (attach_source)."),
+    reason: str = typer.Option("", "--reason", help="Raison (retract)."),
+    by: str = typer.Option("", "--by", help="Qui propose (agent ou session)."),
+) -> None:
+    """Déposer la correction comme proposition à accepter ou refuser — sans écrire dans la mémoire."""
+    from grimoire.memory.correction import propose_correction
+
+    _, root = _load_config_context()
+    try:
+        out = propose_correction(
+            root, task_id, action=action, text=text, source=source, reason=reason, proposed_by=by
+        )
+    except (ValueError, GrimoireMemoryError) as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(1) from None
+    console.print(f"Proposition {out['slug']} déposée (en attente) — à accepter : grimoire proposals accept {out['slug']}")
+
+
 # ── grimoire memory list ──────────────────────────────────────────────────────