grimoire-kit 3.82.0__tar.gz → 3.84.0__tar.gz

{grimoire_kit-3.82.0 → grimoire_kit-3.84.0}/CHANGELOG.md

@@ -7,6 +7,27 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 
 ## [Unreleased]
 
+## [3.84.0] - 2026-11-12
+
+- feat(cockpit): tout accepter les tâches fusionnées en un geste (#1186)
+- feat(cockpit): mandat, pilote et fournisseurs de n'importe quel projet (lot 3) (#1187)
+- feat(cockpit): un projet par onglet, chat compris (lot 4) (#1188)
+
+## [3.83.0] - 2026-11-08
+
+- perf(cockpit): la lecture du journal de session qui nourrit le payload `work` est bornée à 1 Mio par passe (1,9 s → 188 ms sur cinq journaux de 20 Mo), et la palette de la coque demande `annotations=0` pour que le montage de la Flotte ne paie plus jamais cette lecture (#1010) (#1171)
+- fix(missions): `task accept` lit le pack de preuve dans le worktree de la tâche, sans `--evidence-root`, et la question du merger donne la commande complète (#1169) (#1181)
+- fix(hosts): deux personas au même faisceau (outils, contexte, skills) restent distinctes quand leur corps (fiche) diffère — le refus « même faisceau et même fiche » ne frappe plus que des définitions réellement identiques (corps normalisé, ou description à défaut de corps) (#1180) (#1182)
+- fix(flows): un réveil programmé, une notification de tâche de fond ou un `claude -p` n'attestent plus un geste humain ; l'origine du tour est lue dans le journal de session de l'hôte par `prompt_id` (#992) (#1172)
+- feat(cockpit): écrire sur n'importe quel projet enrôlé depuis un seul cockpit (lot 1) (#1178)
+- feat(cockpit): gestes sensibles sur un autre projet avec confirmation nommée (lot 2) (#1184)
+- feat(cli): `grimoire digest` résume un fichier ou stdin par le fournisseur `chat`/`cheap` le moins cher (local préféré), découpe les textes longs et cite les lignes d'erreur mot pour mot ; les séquences ANSI (CSI/OSC) sont retirées de toute sortie de fournisseur, y compris pour `task dispatch`. (#1174)
+- perf(cockpit): les digests des fichiers de l'espace Source sont mémoïsés par `(mtime_ns, taille)` — seule une modification recalcule son empreinte (#1175)
+- perf(cockpit): le cache de lecture sert aussi l'ouverture de page — `tasks`, `attention`, `sessions` et `sheet` sont servis depuis le cache sans `pulse_reload`, l'empreinte du pouls couvre désormais `traces.jsonl` et les journaux écrits hors cockpit (tick, flows, preuves, reçus de revue), et ces routes JSON répondent `304` sur `If-None-Match` (#1176)
+- fix(cockpit): le refus d'une porte reste affiché — le pouls ne reconstruit plus l'inspecteur pendant une écriture en vol, sinon le refus partait dans un bloc déjà détaché et la page ne montrait rien (#1176)
+- fix(cockpit): une ouverture de page ne se dessine qu'une fois — la réponse de la boîte à idées ne relance plus un dessin complet quand la liste n'a pas changé (le tableau était reconstruit ~0,5 s après l'ouverture, faisait relire `tasks`/`sessions` et détachait le DOM sous les yeux de l'e2e mobile) (#1176)
+- perf(cockpit): `/api/workspace/tasks` et `/api/workspace/attention` ne reparcourent plus les 11 Mo de `traces.jsonl` à chaque requête — un index incrémental par `task_id` garde le regroupement en mémoire, indexé par `(mtime_ns, size)`, ne consomme que les lignes complètes ajoutées, et reconstruit sur troncature ou changement d'inode. Mesuré le 2026-11-07 (`curl -w %{time_total}`, journal de 10,5 Mo / 11 658 lignes) : `tasks` de 0,54–0,85 s à 0,24–0,27 s, `attention` de 0,81–1,25 s à 0,26–0,59 s à chaud ; la chaîne de regroupement des traces passe de 0,240 s à 0,0002 s après un unique parse complet (GAO-perf-cockpit-001) (#1177)
+
 ## [3.82.0] - 2026-11-07
 
 ### Added

{grimoire_kit-3.82.0 → grimoire_kit-3.84.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grimoire-kit
-Version: 3.82.0
+Version: 3.84.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.82.0 → grimoire_kit-3.84.0}/registry/kit-file-hashes.json

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

grimoire_kit-3.84.0/src/grimoire/__version__.py

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

{grimoire_kit-3.82.0 → grimoire_kit-3.84.0}/src/grimoire/cli/app.py

@@ -1311,6 +1311,7 @@ LazyTyperGroup.configure(
         "up": LazyCommandSpec("grimoire.cli.cmd_up", "up", rich_help_panel="Project"),
         "chat": LazyCommandSpec("grimoire.cli.cmd_chat", "chat_command", rich_help_panel="Project"),
         "context-pack": LazyCommandSpec("grimoire.cli.cmd_context_pack", "context_pack_command", rich_help_panel="Data"),
+        "digest": LazyCommandSpec("grimoire.cli.cmd_digest", "digest_command", rich_help_panel="Data"),
         "migrate": LazyCommandSpec("grimoire.cli.cmd_migrate", "migrate_command", rich_help_panel="Project"),
         "upgrade": LazyCommandSpec("grimoire.cli.cmd_upgrade", "upgrade_command", rich_help_panel="Utilities"),
         "verify-install": LazyCommandSpec("grimoire.cli.cmd_verify_install", "verify_install_command", rich_help_panel="Utilities"),
@@ -1322,7 +1323,7 @@ LazyTyperGroup.configure(
     # `LazyTyperGroup.configure`'s docstring for why this is needed.
     order=[
         "version", "init", "doctor", "status", "add", "remove", "agent-miss",
-        "validate", "lint", "update", "up", "context-pack", "migrate", "upgrade", "verify-install",
+        "validate", "lint", "update", "up", "context-pack", "digest", "migrate", "upgrade", "verify-install",
         "serve", "diff", "schema", "check", "merge", "setup", "env", "history",
         "repair",
         "memory", "hooks", "cadrage", "phase", "debugger", "dbg", "registry", "workflows",

{grimoire_kit-3.82.0 → grimoire_kit-3.84.0}/src/grimoire/cli/cmd_cockpit.py

@@ -35,7 +35,32 @@ 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.cli.cockpit_http import (
+    DRAIN_LIMIT,
+    CountingReader,
+    gzip_body,
+    send_json,
+    serve_asset,
+    warm_sheet,
+)
+from grimoire.cli.cockpit_memory import (
+    ALLOWED_ACTIONS,
+    MEMORY_TIMEOUT_S,
+    MUTATION_ACTIONS,
+    is_plain_argument,
+)
+from grimoire.cli.cockpit_write_target import (
+    body_confirms_slug,
+    body_mismatch_status,
+    enrolled_write_root,
+    explicit_query_slug,
+    journal_confirmation,
+    query_slug,
+    read_root,
+    sensitive_write_refusal,
+    unresolvable_status,
+    write_refusal_status,
+)
 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 (
@@ -48,11 +73,11 @@ from grimoire.tools.project_registry import (
     projects_payload,
     read_state,
     register_project,
+    registered_root,
     registry_file,
     registry_home,
     resolve_within_allowed,
     save_registry,
-    selected_slug,
     set_selected_slug,
     slug_for_path,
     state_file,
@@ -67,6 +92,7 @@ from grimoire.tools.request_guard import (
     new_session_token,
 )
 from grimoire.tools.workspace_legacy import legacy_redirect_target
+from grimoire.tools.workspace_read_cache import cacheable_read
 from grimoire.tools.workspace_write_guard import cockpit_journal_path, guard_write
 
 cockpit_app = typer.Typer(
@@ -143,12 +169,11 @@ def _resolve_project_path(slug: str | None) -> Path | None:
     return Path(projects[0]["path"]) if projects else None
 
 
-# Slug du projet servi en direct par CE process (#351/#356) — distinct de
-# `selected_slug()` (la sélection courante, persistée au disque, qui dérive
-# librement dès que l'UI navigue vers un autre projet du registre). Réglé une
-# fois, avant `serve_forever()` (voir `_select_cwd_project`), jamais ensuite :
-# c'est ce qui garde l'écriture ouverte sur LE projet de lancement même après
-# une navigation Flotte, et fermée sur tout autre projet du registre.
+# Slug du projet ouvert par défaut par CE process (#351/#356), figé au
+# démarrage. Depuis le lot 1 (2026-11-07), il ne restreint plus les écritures
+# (voir `cockpit_write_target`) ; il sert au repli de lecture (`home` de
+# `/api/status`) et, depuis le lot 2, à distinguer le projet d'ouverture (geste
+# historique) d'un autre projet enrôlé (confirmation nommée).
 _HOME_SLUG: str | None = None
 
 # Chemin du projet servi, figé au démarrage : la garde P02 compare des chemins,
@@ -187,13 +212,10 @@ def _project_api(proot: Path) -> Any:
 # Governance API (127.0.0.1 only): allowlisted ``grimoire memory`` reads, confirmed
 # mutations and correction gestures (P34), the last two on the served project only.
 
-_ALLOWED_ACTIONS: dict[str, list[str]] = {
-    "status": [],
-    "gate": ["--soft"],
-    "search": [],  # requires a query argument
-    "list": [],
-    "taxonomy": [],
-}
+_LOCAL_HOSTS = frozenset({"127.0.0.1", "::1", "localhost"})
+
+# Les actions mémoire (listes blanches, mutations, arguments sûrs) vivent dans
+# ``grimoire.cli.cockpit_memory`` pour tenir le cliquet de taille de ce module.
 
 
 def _forget_live_reads() -> None:
@@ -203,40 +225,6 @@ def _forget_live_reads() -> None:
     workspace_read_cache.clear()
 
 
-@dataclass(frozen=True)
-class _Mutation:
-    """A governed write action — runs only with explicit confirmation."""
-
-    args: tuple[str, ...] = ()
-    needs_id: bool = False
-    subcommand: str | None = None  # defaults to the action name
-
-
-# Each mutation maps to a real ``grimoire memory`` command and needs ``confirm: true``.
-_MUTATION_ACTIONS: dict[str, _Mutation] = {
-    "gc": _Mutation(),  # consolidate / compact the store
-    "delete": _Mutation(args=("--yes",), needs_id=True),  # remove one entry by id
-    # resync the Weaviate / Neo4j projections from the source store (reindex, no loss)
-    "sync": _Mutation(subcommand="gate", args=("--sync", "--soft")),
-}
-_LOCAL_HOSTS = frozenset({"127.0.0.1", "::1", "localhost"})
-
-# Longueur d'argument bornée : une requête n'a pas à pousser un roman dans argv.
-_MAX_ARGUMENT_LEN = 512
-
-
-def _is_plain_argument(value: str) -> bool:
-    """Vrai si la valeur peut être passée à la CLI comme simple positionnel.
-
-    Le dispatch n'utilise pas de shell, donc il n'y a pas d'injection de shell
-    possible — mais une valeur commençant par ``-`` serait lue comme une option
-    par la sous-commande. On refuse ce cas, les octets nuls et les longueurs
-    déraisonnables, et on passe malgré tout les valeurs après ``--``.
-    """
-    return bool(value) and not value.startswith("-") and "\x00" not in value and len(value) <= _MAX_ARGUMENT_LEN
-
-
-_MEMORY_TIMEOUT_S = 30
 # CliRunner remplace ``sys.stdout``/``sys.stderr`` pour tout le processus : deux
 # invocations simultanées s'écraseraient la sortie. Ce verrou ne protège que cela
 # (pas le répertoire courant, jamais modifié).
@@ -273,7 +261,7 @@ def _run_memory_in_process(proot: Path, argv: list[str]) -> _CliResult:
 
     pool = ThreadPoolExecutor(max_workers=1)
     try:
-        return pool.submit(_invoke_memory_cli, proot, argv).result(timeout=_MEMORY_TIMEOUT_S)
+        return pool.submit(_invoke_memory_cli, proot, argv).result(timeout=MEMORY_TIMEOUT_S)
     except FutureTimeout:
         raise TimeoutError from None
     finally:
@@ -362,6 +350,7 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             journal=cockpit_journal_path(),
             with_body=has_body(self.headers),
             peer=self.client_address[0],
+            project=self._explicit_query_slug() or None,
         )
         if refused:
             self._send_json(refused[0], {"ok": False, "error": refused[1]})
@@ -369,22 +358,16 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             return False
         return True
 
-    def _send_json(self, code: int, payload: dict[str, object]) -> None:
-        # Le corps de la requête est lu en entier avant la première ligne de
-        # réponse (#857) ; la connexion est fermée après cette réponse
-        # (``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, 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)))
-        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()
+    def _journal_confirmation(self, route: str, project: str, confirm_project: str) -> bool:
+        """Lot 2 : le journal de la garde note le slug ET la confirmation nommée."""
+        error = journal_confirmation(self.command, route, project, confirm_project)
+        if error:
+            self._send_json(503, {"ok": False, "error": error})
+            return False
+        return True
+
+    def _send_json(self, code: int, payload: dict[str, object], *, etag: bool = False) -> None:
+        send_json(self, code, payload, etag=etag)
 
     def send_error(self, code: int, message: str | None = None, explain: str | None = None) -> None:
         # Même contrat pour les refus de ``http.server`` lui-même (501, 404
@@ -396,20 +379,24 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
     # ── Lectures : registre + API projet, repli statique ──────────────────
 
     def _query_slug(self) -> str:
-        """Projet visé par la requête : ``?project=`` explicite, sinon la sélection courante."""
-        asked = parse_qs(urlparse(self.path).query).get("project", [""])[0]
-        return asked or selected_slug()
-
-    def _is_home_request(self) -> bool:
-        """Vrai si la requête cible le projet servi en direct par ce process.
-
-        `_HOME_SLUG` ne bouge jamais après le démarrage ; `_query_slug()` peut
-        pointer ailleurs dès que l'UI navigue vers un autre projet du
-        registre (carte Flotte, `?project=` explicite) — cette requête-là
-        reste en lecture seule, comme toute navigation cockpit vers un projet
-        qu'on ne fait que regarder (#356).
+        return query_slug(self.path)
+
+    def _explicit_query_slug(self) -> str:
+        return explicit_query_slug(self.path)
+
+    def _enrolled_write_root(self) -> Path | None:
+        return enrolled_write_root(self.path)
+
+    def _is_enrolled_write_target(self) -> bool:
+        """Vrai si l'écriture vise un projet enrôlé au dossier présent.
+
+        Remplace ``_is_home_request()`` : un slug absent de l'URL ou du
+        registre, ou un dossier disparu, ferme la porte (échec fermé).
         """
-        return bool(_HOME_SLUG) and self._query_slug() == _HOME_SLUG
+        return self._enrolled_write_root() is not None
+
+    def _body_confirms_slug(self, body: Any) -> bool:
+        return body_confirms_slug(body, self.path)
 
     def _serve_static(self) -> None:
         """Fichier statique ; une page HTML reçoit le jeton de session."""
@@ -462,12 +449,20 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             except PermissionError as exc:
                 self._send_json(403, {"ok": False, "error": str(exc)})
             return
-        proot = _resolve_project_path(self._query_slug() or None)
+        if path == "/api/status":
+            readonly = unresolvable_status(self.path, _HOME_SLUG)
+            if readonly is not None:
+                self._send_json(200, readonly)
+                return
+        # Lot 4 : une lecture nomme son projet (`?project=<slug>`), résolu par
+        # le registre ; sans paramètre, le repli reste la sélection courante.
+        proot = read_root(self.path)
         if proot is None or not proot.is_dir():
             self._send_json(404, {"ok": False, "error": "projet inconnu"})
             return
         from grimoire.tools.workspace_routes import (
             CHAT_STREAM_PATH,
+            LIVE_ROUTES,
             STREAM_HEADERS,
             STREAM_PATH,
             chat_stream,
@@ -493,10 +488,11 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             except ConnectionError:
                 pass  # la page est partie : fin du flux, pas une panne
             return
+        query = parse_qs(urlparse(self.path).query)
         try:
             from grimoire.tools.forge_routes import API_GET_UNHANDLED, api_get
 
-            payload = api_get(_project_api(proot), path, parse_qs(urlparse(self.path).query))
+            payload = api_get(_project_api(proot), path, query)
         except FileNotFoundError as exc:
             # Même traduction que l'atelier (``forge_http.py::do_GET``) et que
             # ``do_POST`` ci-dessous : un refus métier (tâche inconnue, chemin hors
@@ -544,21 +540,21 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
         # Même forme de réponse que l'atelier : la charge utile brute, pour que
         # le même code de page fonctionne contre les deux serveurs. Seul
         # ``/api/status`` est enrichi, pour que l'UI sache si l'hôte accepte
-        # des mutations. Depuis #356 ce n'est plus toujours faux : le projet
-        # de lancement direct (``_HOME_SLUG``) les honore, exactement comme le
-        # faisait l'ancien atelier avant que #351 ne l'y fasse succéder —
-        # naviguer vers un AUTRE projet du registre reste en lecture seule.
-        # ``home`` nomme ce projet ouvert (P31) : le bandeau de lecture seule
-        # en tire le geste « Revenir à … », ``None`` si le cockpit n'en a pas.
+        # des mutations. Depuis le lot 1 de l'écriture multi-projets, TOUT
+        # projet enrôlé en accepte : ``readOnly`` ne veut plus dire « pas le
+        # projet d'ouverture » mais « projet absent du registre, ou dossier
+        # disparu » — la seule cible qu'une écriture ne peut pas résoudre.
+        # ``home`` nomme le projet ouvert par défaut (P31).
         if path == "/api/status" and isinstance(payload, dict):
+            slug = self._query_slug()
             payload = {
                 **payload,
                 "host": "cockpit",
-                "readOnly": not self._is_home_request(),
-                "project": self._query_slug(),
+                "readOnly": not slug or registered_root(slug=slug) is None,
+                "project": slug,
                 "home": _HOME_SLUG or None,
             }
-        self._send_json(200, payload)
+        self._send_json(200, payload, etag=cacheable_read(path, query, live_routes=LIVE_ROUTES))
 
     def do_POST(self) -> None:  # http.server contract
         # P79 : toute écriture passée par le cockpit (tâche, agent, réglage…) peut changer ce que les lectures du direct
@@ -630,23 +626,22 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             # Le wizard exécute (issue #171) : `grimoire serve` n'est plus
             # qu'un alias déprécié de cette commande (#351), donc c'est ICI —
             # pas dans `forge_http.py` — que passe toute requête réelle du
-            # navigateur. Même garde que la vue de travail juste en dessous :
-            # seul le projet de lancement direct (`_HOME_SLUG`) accepte cette
-            # écriture, regarder un AUTRE projet du registre reste en lecture
-            # seule.
-            if not self._is_home_request():
+            # navigateur. Depuis le lot 1 de l'écriture multi-projets, le
+            # projet visé doit être ENRÔLÉ (résolu par le registre seul), pas
+            # forcément celui que ce process a ouvert.
+            proot = self._enrolled_write_root()
+            if proot is None:
                 self._send_json(403, {"ok": False, "error": "hôte en lecture seule"})
                 return
-            proot = _resolve_project_path(self._query_slug() or None)
-            if proot is None or not proot.is_dir():
-                self._send_json(404, {"ok": False, "error": "projet inconnu"})
-                return
             try:
                 length = int(self.headers.get("Content-Length", 0))
                 body = json.loads(self.rfile.read(length) or b"{}") if length else {}
             except (ValueError, json.JSONDecodeError):
                 self._send_json(400, {"ok": False, "error": "bad json"})
                 return
+            if not self._body_confirms_slug(body):
+                self._send_json(403, {"ok": False, "error": "le projet du corps ne correspond pas à l'URL"})
+                return
             try:
                 result = _project_api(proot).setup_plan(body)
             except ValueError as exc:
@@ -694,39 +689,28 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             return
         if path.startswith(WORKSPACE_PREFIX):
             # Écritures de la vue de travail (réclamer/réaliser une tâche,
-            # écrire un fichier, créer un override, lancer une commande) :
-            # l'ancien atelier les honorait, `cockpit serve` en a hérité sans
-            # les câbler quand #351 a fait de lui le seul serveur restant —
-            # même trouvaille que `--project-root` (d5047fc6), pour la même
-            # raison : fusionner deux commandes ne devait pas couper une
-            # capacité (#356). Restreint à `_HOME_SLUG` : le projet qu'on ne
-            # fait que regarder via le registre reste en lecture seule —
-            # SAUF décider une proposition (`is_proposal_decision`, #490) ou
-            # migrer les tâches d'un board vers le Mission Ledger
-            # (`is_registry_scoped_write`, #559 suite/#560) : ces deux
-            # écritures-là ouvrent la même porte que
-            # `POST /api/projects/update` juste au-dessus, parce que valider
-            # ou refuser un artefact déjà proposé, ou migrer les tâches d'un
-            # projet qu'on pilote depuis la flotte, sont les gestes explicites
-            # et ponctuels que le cockpit existe pour rendre possible sur
-            # toute la flotte, pas seulement sur le projet de lancement.
-            # Chaque dérogation est nommée : le reste de `WORKSPACE_PREFIX`
-            # (écrire un fichier, réclamer une tâche…) reste `_HOME_SLUG`
-            # seulement.
+            # décider une proposition, migrer un board, écrire un fichier…).
+            # Lot 1 de l'écriture multi-projets : la cible est le projet
+            # ENRÔLÉ nommé par `?project=`, résolu par le registre seul — le
+            # cockpit peut donc écrire sur n'importe quel projet qu'il pilote,
+            # pas seulement sur celui qu'il a ouvert. Lot 2 : `file/write`,
+            # `file/override` et `command` suivent la même résolution, mais
+            # exigent `confirm_project` égal au slug visé dès que la cible
+            # n'est pas le projet d'ouverture (voir `is_sensitive_write`).
             from grimoire.tools.workspace_routes import (
                 WORKSPACE_UNHANDLED,
-                is_proposal_decision,
-                is_registry_scoped_write,
+                is_sensitive_write,
                 workspace_post,
             )
 
-            registry_scoped = is_proposal_decision(path) or is_registry_scoped_write(path)
-            if not registry_scoped and not self._is_home_request():
-                self._send_json(403, {"ok": False, "error": "hôte en lecture seule"})
-                return
-            proot = _resolve_project_path(self._query_slug() or None)
-            if proot is None or not proot.is_dir():
-                self._send_json(404, {"ok": False, "error": "projet inconnu"})
+            # Lot 3 : les écritures d'autorité (mandat, pilote, fournisseurs)
+            # nomment leur projet dans le corps. Un slug d'URL non enrôlé est un
+            # 404, un corps qui contredit l'URL un 400 — les autres écritures
+            # gardent le refus générique « lecture seule » (403) du lot 1.
+            proot = self._enrolled_write_root()
+            if proot is None:
+                code, error = write_refusal_status(self.path)
+                self._send_json(code, {"ok": False, "error": error})
                 return
             try:
                 length = int(self.headers.get("Content-Length", 0))
@@ -734,6 +718,18 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             except (ValueError, json.JSONDecodeError):
                 self._send_json(400, {"ok": False, "error": "bad json"})
                 return
+            if not self._body_confirms_slug(body):
+                self._send_json(body_mismatch_status(path), {"ok": False, "error": "le projet du corps ne correspond pas à l'URL"})
+                return
+            slug = self._explicit_query_slug()
+            if is_sensitive_write(path):
+                refusal = sensitive_write_refusal(body, self.path, _HOME_SLUG)
+                if refusal:
+                    self._send_json(403, {"ok": False, "error": refusal})
+                    return
+                confirmed = str(body.get("confirm_project") or "").strip() if isinstance(body, dict) else ""
+                if not self._journal_confirmation(path, slug, confirmed):
+                    return
 
             # Même traduction que l'atelier (``forge_http.py::do_POST``) : sans
             # elle, un refus métier (skill inconnu, agent introuvable, chemin
@@ -765,15 +761,12 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             # persiste la section `compiled` dans le blueprint d'origine
             # (voir sa docstring) : ce n'est pas un calcul comme
             # `/validate`/`/simulate` juste en dessous. Même garde que
-            # `/api/setup` et `PUT` : seul le projet de lancement direct
-            # (`_HOME_SLUG`) accepte cette écriture.
-            if not self._is_home_request():
+            # `/api/setup` et `PUT` : le projet visé doit être enrôlé (lot 1
+            # de l'écriture multi-projets).
+            proot = self._enrolled_write_root()
+            if proot is None:
                 self._send_json(403, {"ok": False, "error": "hôte en lecture seule"})
                 return
-            proot = _resolve_project_path(self._query_slug() or None)
-            if proot is None or not proot.is_dir():
-                self._send_json(404, {"ok": False, "error": "projet inconnu"})
-                return
             try:
                 length = int(self.headers.get("Content-Length", 0))
                 body = json.loads(self.rfile.read(length) or b"{}") if length else {}
@@ -796,13 +789,12 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             # Calcul, pas écriture : `blueprint_lint`/`blueprint_simulate` ne
             # touchent jamais le disque (voir leurs docstrings — la simulation
             # « ne produit aucun effet »). Contrairement à `/compile` et `PUT`
-            # ci-dessus, aucune garde `_HOME_SLUG` ici — Concevoir doit
-            # pouvoir valider/simuler le projet déjà sélectionné sur le
-            # cockpit, comme sur l'atelier (#356), y compris un projet du
-            # registre qu'on ne fait que regarder. Vérifié par un test sur un
-            # vrai handler (`test_cmd_cockpit_blueprint_writes.py`, #546),
-            # pas seulement supposé sur la base de ce commentaire.
-            proot = _resolve_project_path(self._query_slug() or None)
+            # ci-dessus, aucune résolution enrôlée obligatoire ici — la
+            # lecture reste ouverte à tout projet du registre, comme sur
+            # l'atelier (#356). Vérifié par un test sur un vrai handler
+            # (`test_cmd_cockpit_blueprint_writes.py`, #546), pas seulement
+            # supposé sur la base de ce commentaire.
+            proot = read_root(self.path)
             if proot is None or not proot.is_dir():
                 self._send_json(404, {"ok": False, "error": "projet inconnu"})
                 return
@@ -840,8 +832,8 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             self._send_json(400, {"ok": False, "error": "bad json"})
             return
         action = str(data.get("action", ""))
-        is_read = action in _ALLOWED_ACTIONS
-        is_mutation = action in _MUTATION_ACTIONS
+        is_read = action in ALLOWED_ACTIONS
+        is_mutation = action in MUTATION_ACTIONS
         gesture = action == "gesture"  # P34 : aperçu puis application (workspace_memory_gestures)
         if not (is_read or is_mutation or gesture):
             self._send_json(400, {"ok": False, "error": f"action non autorisée: {action}"})
@@ -849,14 +841,22 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
         if is_mutation and data.get("confirm") is not True:
             self._send_json(403, {"ok": False, "error": "confirmation explicite requise"})
             return
-        proot = _resolve_project_path(str(data.get("project", "")) or None)
+        project_slug = str(data.get("project", "")).strip()
+        proot = _resolve_project_path(project_slug or None)
         if proot is None or not proot.is_dir():
             self._send_json(400, {"ok": False, "error": "projet inconnu"})
             return
         if (is_mutation or gesture) and not _is_served_project(proot):
-            # P02 : delete/gc/sync et gestes n'agissent que sur le projet servi (échec fermé).
-            self._send_json(403, {"ok": False, "error": "hôte en lecture seule"})
-            return
+            # P02 : un geste de correction (aperçu/apply) reste réservé au
+            # projet servi. Lot 2 : une MUTATION mémoire (delete/gc/sync)
+            # accepte n'importe quel projet ENRÔLÉ, à condition que la
+            # personne l'ait nommé (`confirm_project` égal au slug visé).
+            confirmed = str(data.get("confirm_project") or "").strip()
+            if not is_mutation or not project_slug or confirmed != project_slug:
+                self._send_json(403, {"ok": False, "error": "hôte en lecture seule"})
+                return
+            if not self._journal_confirmation("/api/memory", project_slug, confirmed):
+                return
         if gesture:
             from grimoire.tools.workspace_memory_gestures import handle as memory_gesture
 
@@ -865,7 +865,7 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
         subcmd = action
         values: list[str] = []
         if is_read:
-            flags = list(_ALLOWED_ACTIONS[action])
+            flags = list(ALLOWED_ACTIONS[action])
             if action == "search":
                 query = str(data.get("query", "")).strip()
                 if not query:
@@ -873,7 +873,7 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
                     return
                 values = [query]
         else:
-            spec = _MUTATION_ACTIONS[action]
+            spec = MUTATION_ACTIONS[action]
             subcmd = spec.subcommand or action
             flags = list(spec.args)
             if spec.needs_id:
@@ -882,7 +882,7 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
                     self._send_json(400, {"ok": False, "error": "id d'entrée requis"})
                     return
                 values = [entry_id]
-        if not all(_is_plain_argument(v) for v in values):
+        if not all(is_plain_argument(v) for v in values):
             self._send_json(400, {"ok": False, "error": "valeur d'argument refusée"})
             return
         # La commande est rejouée dans le processus, via l'application Typer :
@@ -912,9 +912,9 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
     def do_PUT(self) -> None:  # http.server contract
         """``PUT /api/blueprints/<id>`` — enregistrer un blueprint (issue #535).
 
-        Même garde que ``/api/setup`` : seul le projet de lancement direct
-        (``_HOME_SLUG``) accepte l'écriture (#356) ; sans ``do_PUT``,
-        ``http.server`` répondait 501 avant toute garde.
+        Même garde que ``/api/setup`` : le projet visé doit être enrôlé (lot 1
+        de l'écriture multi-projets) ; sans ``do_PUT``, ``http.server``
+        répondait 501 avant toute garde.
         """
         if not self._guard_mutation():
             return
@@ -929,13 +929,10 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
         if not path.startswith("/api/blueprints/"):
             self._send_json(404, {"ok": False, "error": "route inconnue"})
             return
-        if not self._is_home_request():
+        proot = self._enrolled_write_root()
+        if proot is None:
             self._send_json(403, {"ok": False, "error": "hôte en lecture seule"})
             return
-        proot = _resolve_project_path(self._query_slug() or None)
-        if proot is None or not proot.is_dir():
-            self._send_json(404, {"ok": False, "error": "projet inconnu"})
-            return
         try:
             length = int(self.headers.get("Content-Length", 0))
             body = json.loads(self.rfile.read(length) or b"{}") if length else {}
@@ -1091,10 +1088,12 @@ def _select_cwd_project(root: Path | None = None) -> str | None:
     Renvoie un message à afficher quand le projet vient d'être enregistré, ou
     ``None`` si rien n'a changé.
 
-    Retient aussi ce slug dans ``_HOME_SLUG`` (#356) : c'est le seul projet
-    pour lequel *ce* process honorera une écriture, même après que l'UI ait
-    navigué ailleurs dans le registre — voir ``_CockpitHandler._is_home_request``.
-    Son chemin résolu va dans ``_HOME_PATH`` (garde P02).
+    Retient aussi ce slug dans ``_HOME_SLUG`` : c'est le projet que le
+    cockpit ouvre par défaut (``home`` de ``/api/status``) et celui qui garde
+    le geste historique pour les écritures sensibles du lot 2 (``file/write``,
+    ``command``, ``file/override``, mutations mémoire) ; un AUTRE projet
+    enrôlé exige ``confirm_project``. Son chemin résolu va dans
+    ``_HOME_PATH`` (garde P02 des gestes mémoire).
     """
     global _HOME_PATH, _HOME_SLUG
     if os.environ.get("GRIMOIRE_NO_COCKPIT"):