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

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

@@ -7,6 +7,12 @@ 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)

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

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

@@ -1,6 +1,6 @@
 {
  "schema": "grimoire-kit-file-hashes/v1",
- "generated_for": "3.83.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.83.0 → grimoire_kit-3.84.0}/src/grimoire/cli/cmd_cockpit.py

@@ -51,12 +51,15 @@ from grimoire.cli.cockpit_memory import (
 )
 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
@@ -451,7 +454,9 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             if readonly is not None:
                 self._send_json(200, readonly)
                 return
-        proot = _resolve_project_path(self._query_slug() or None)
+        # 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
@@ -698,9 +703,14 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
                 workspace_post,
             )
 
+            # 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:
-                self._send_json(403, {"ok": False, "error": "hôte en lecture seule"})
+                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))
@@ -709,7 +719,7 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
                 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"})
+                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):
@@ -784,7 +794,7 @@ class _CockpitHandler(SimpleHTTPRequestHandler):
             # 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 = _resolve_project_path(self._query_slug() or None)
+            proot = read_root(self.path)
             if proot is None or not proot.is_dir():
                 self._send_json(404, {"ok": False, "error": "projet inconnu"})
                 return

{grimoire_kit-3.83.0 → grimoire_kit-3.84.0}/src/grimoire/cli/cockpit_write_target.py

@@ -1,9 +1,10 @@
-"""Cibles d'écriture du cockpit : slug de requête, racine enrôlée, corps.
+"""Cibles du cockpit : slug de requête, racine enrôlée, corps.
 
 Sorti de ``cmd_cockpit`` pour ne pas en gonfler le module (cliquet de taille) :
 les fonctions ici sont pures — elles prennent le chemin de requête ou le slug
-déjà extrait — et toute la politique d'écriture multi-projets vit à un seul
-endroit, avec sa documentation.
+déjà extrait — et toute la politique de résolution multi-projets vit à un seul
+endroit, avec sa documentation. Les écritures (lots 1 et 2) et les lectures
+(lot 4) résolvent leur projet ici.
 
 Depuis le lot 1 de l'écriture multi-projets (2026-11-07), une écriture vise
 n'importe quel projet ENRÔLÉ : le slug de ``?project=`` est **obligatoire** et
@@ -21,8 +22,55 @@ from typing import Any
 from urllib.parse import parse_qs, urlparse
 
 from grimoire.tools.project_registry import registered_root, selected_slug
+from grimoire.tools.workspace_routes import PREFIX
 from grimoire.tools.workspace_write_guard import cockpit_journal_path, journal_event
 
+#: Écritures d'AUTORITÉ (lot 3, 2026-11-08) : le mandat, le pilote automatique
+#: et les fournisseurs. Comme toute écriture de la vue de travail, elles visent
+#: la racine ENRÔLÉE résolue depuis ``?project=``. Elles nomment en plus leur
+#: projet dans le corps : un slug d'URL inconnu est un 404 et un slug du corps
+#: qui ne désigne pas la même racine est un 400 — plutôt que le refus générique
+#: « lecture seule » (403) des autres écritures. Absent du corps, le slug ne dit
+#: rien (compatibilité des appels historiques).
+AUTHORITY_WRITES = frozenset(
+    {
+        f"{PREFIX}autonomy/autopilot",
+        f"{PREFIX}autonomy/mandate/grant",
+        f"{PREFIX}autonomy/mandate/revoke",
+        f"{PREFIX}providers",
+        f"{PREFIX}providers/set-key",
+    }
+)
+
+
+def is_authority_write(path: str) -> bool:
+    """Vrai pour une écriture qui nomme son projet dans le corps (mandat, pilote, fournisseurs)."""
+    return path in AUTHORITY_WRITES
+
+
+def write_refusal_status(path: str) -> tuple[int, str]:
+    """``(code, message)`` quand la cible d'une écriture ne résout pas.
+
+    Les autres écritures gardent le 403 « lecture seule » du lot 1. Une écriture
+    d'autorité (lot 3) nomme sa cible : slug absent de l'URL → 400 (rien ne dit
+    où écrire), slug inconnu ou dossier disparu → 404 (le registre ne le rend pas).
+    """
+    if not is_authority_write(urlparse(path).path):
+        return 403, "hôte en lecture seule"
+    if not explicit_query_slug(path):
+        return 400, "projet non nommé"
+    return 404, "projet inconnu ou non enrôlé"
+
+
+def body_mismatch_status(path: str) -> int:
+    """Code de refus quand le ``project`` du corps contredit ``?project=``.
+
+    Une écriture d'autorité (lot 3) nomme sa cible dans le corps : le
+    contredire est une requête mal formée, donc 400. Les autres écritures
+    gardent le refus du lot 1 (403), qui ne promettait pas de cible au corps.
+    """
+    return 400 if is_authority_write(urlparse(path).path) else 403
+
 
 def query_slug(path: str) -> str:
     """Projet visé par la requête : ``?project=`` explicite, sinon la sélection.
@@ -57,6 +105,23 @@ def enrolled_write_root(path: str) -> Path | None:
     return registered_root(slug=slug) if slug else None
 
 
+def read_root(path: str) -> Path | None:
+    """Racine ENRÔLÉE visée par une LECTURE, ou ``None`` (404).
+
+    Lot 4 (2026-11-08) : une lecture nomme son projet comme une écriture. Le
+    slug de ``?project=`` sert de clé à ``registered_root`` — jamais de chemin —
+    et un slug inconnu ne mène à aucune racine, au lieu de retomber en silence
+    sur un autre projet. Deux onglets peuvent donc lire deux projets différents
+    sans partager d'état.
+
+    Sans paramètre, le repli historique reste en place : la sélection courante
+    (``selected_slug``, elle-même retombant sur le projet primaire), pour que
+    les liens ouverts avant le lot 4 continuent de marcher.
+    """
+    slug = explicit_query_slug(path)
+    return registered_root(slug=slug or selected_slug())
+
+
 def body_confirms_slug(body: Any, path: str) -> bool:
     """Le ``project`` du corps, s'il est présent, doit viser le même projet.
 

{grimoire_kit-3.83.0 → grimoire_kit-3.84.0}/src/grimoire/tools/project_registry.py

@@ -268,6 +268,36 @@ def registered_root(*, slug: str = "", path: str = "") -> Path | None:
     return None
 
 
+def body_project_refusal(project_root: Path, body: Any) -> str | None:
+    """Refus si le ``project`` du corps ne désigne pas ``project_root`` dans le registre.
+
+    Pendant de :func:`grimoire.cli.cockpit_write_target.body_confirms_slug`, côté
+    route : le transport compare le corps au slug de l'URL, mais une route ne
+    reçoit que la racine déjà résolue. Absent, le champ ne dit rien — les appels
+    historiques ne le portent pas. Présent, il doit nommer CETTE racine et rester
+    un slug du registre : un slug non enrôlé n'est jamais accepté, et un chemin
+    fourni par le client ne résout rien (``registered_root`` ne lit que des slugs).
+    """
+    wanted = str(body.get("project") or "").strip() if isinstance(body, dict) else ""
+    if not wanted:
+        return None
+    if registered_root(slug=wanted) != project_root.resolve():
+        return f"le corps visait le projet {wanted!r}, la cible résolue diffère"
+    return None
+
+
+def refuse_foreign_body(project_root: Path, body: Any) -> None:
+    """Lève ``ValueError`` (400) si le ``project`` du corps vise une autre racine.
+
+    Variante levante de :func:`body_project_refusal` : les routes d'écriture du
+    workspace traduisent ``ValueError`` en 400, ce qui évite de répéter le test
+    dans chaque geste d'autorité (mandat, pilote, fournisseurs) — lot 3.
+    """
+    refusal = body_project_refusal(project_root, body)
+    if refusal is not None:
+        raise ValueError(refusal)
+
+
 def primary_slug() -> str:
     projects = load_registry()
     return str(projects[0].get("slug", "")) if projects else ""

grimoire_kit-3.84.0/src/grimoire/tools/workspace_accept_merged.py

@@ -0,0 +1,211 @@
+"""« Tout accepter » (GAO-cockpit-tout-001) : fermer en un geste les tâches que le merger a laissées à l'humain.
+
+Le 2026-11-07, treize tâches attendaient « Accepter … ? » dans le cockpit : une PR
+qui touche un chemin réservé demande la fusion, puis ``grimoire task accept``.
+Cette route fait le second geste pour toutes les tâches qu'elle peut prouver
+prêtes, et **jamais** pour les autres.
+
+Une tâche est candidate si et seulement si :
+
+- son état est ``needs_verification`` ;
+- un ``task.merged`` est noté au ledger depuis le dernier lancement ;
+- la dernière question ouverte est celle que le merger pose pour l'acceptation
+  (``task.merge_escalated`` avec ``gesture: accept``, ou son texte
+  « Accepter <id> (PR #N fusionnée) ? ») ;
+- le reçu de revue du worktree de la tâche porte le verdict ``READY``.
+
+Le geste est celui d'un humain : la route exige la clé de contrôle
+(``~/.grimoire/control/cockpit-key``), comme l'octroi du mandat et le pilote
+automatique — le jeton de session, injecté dans toute page servie sur la
+loopback, ne suffit pas à fermer des tâches. Chaque acceptation passe par
+:func:`grimoire.missions.human_acceptance.accept_task`, avec les racines de
+:func:`~grimoire.missions.human_acceptance.acceptance_roots` (#1169 : la preuve
+est dans le worktree quand elle y a été rangée). Une tâche qui échoue est
+rapportée, les autres continuent : c'est un lot, pas une transaction.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any
+
+from grimoire.missions.human_acceptance import accept_task, acceptance_roots
+from grimoire.missions.launcher import LAUNCHED_EVENT
+from grimoire.missions.mandate import verify_control_key
+from grimoire.missions.questions import OPEN, records_of, status_of
+from grimoire.missions.review_receipt import READY, read_receipt
+from grimoire.missions.schemas import ORIGIN_HUMAN, TaskState
+from grimoire.missions.service import TaskService
+from grimoire.missions.task_worktree import MERGED_EVENT
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from grimoire.missions.questions import QuestionRecord
+    from grimoire.missions.schemas import LedgerEvent, MissionTask
+
+__all__ = ["ACTOR", "accept_merged", "accept_merged_candidates", "accept_merged_view"]
+
+#: L'acteur inscrit au ledger : le canal, jamais un nom fourni par le corps.
+ACTOR = "cockpit"
+
+#: La question d'acceptation posée par le merger (``merger._ask_human``) : le
+#: préfixe suffit à reconnaître le geste, l'identifiant est vérifié à part.
+_ACCEPT_TEXT = re.compile(r"^\s*Accepter\s+(?P<task>\S+)\s+\(PR\s+#(?P<pr>\d+)\s+fusionnée\)\s*\?")
+
+
+def _last_launch_index(events: list[LedgerEvent]) -> int:
+    """L'indice du dernier lancement, ou ``-1`` : une tâche faite à la main n'en a pas."""
+    return max((i for i, e in enumerate(events) if e.event_type == LAUNCHED_EVENT), default=-1)
+
+
+def _merged_after_launch(events: list[LedgerEvent]) -> LedgerEvent | None:
+    """Le dernier ``task.merged`` depuis le dernier lancement, sinon ``None``.
+
+    Même règle que le merger (``_accept``) : une fusion notée avant un nouveau
+    lancement ne dit rien du travail présent.
+    """
+    after = _last_launch_index(events)
+    merged = [e for e in events[after + 1 :] if e.event_type == MERGED_EVENT]
+    return merged[-1] if merged else None
+
+
+def _last_open_question(task: MissionTask) -> QuestionRecord | None:
+    """La dernière question encore ouverte du registre, sinon ``None``."""
+    opened = [record for record in records_of(task) if status_of(task, record) == OPEN]
+    return opened[-1] if opened else None
+
+
+def _is_merger_accept_question(task: MissionTask, question: QuestionRecord, events: list[LedgerEvent]) -> bool:
+    """Vrai si *question* est celle que le merger pose pour l'acceptation de *task*.
+
+    L'événement ``task.merge_escalated`` fait foi ; le texte de la question sert
+    de repli pour un ledger qui porterait la question sans son événement.
+    """
+    from grimoire.missions.merger import MERGE_ESCALATED_EVENT
+
+    if any(
+        e.event_type == MERGE_ESCALATED_EVENT
+        and e.payload.get("gesture") == "accept"
+        and e.payload.get("question_id") == question.id
+        for e in events
+    ):
+        return True
+    match = _ACCEPT_TEXT.match(question.question.text or "")
+    return match is not None and match.group("task") == task.id
+
+
+def _question_pr(question: QuestionRecord, merged: LedgerEvent) -> int:
+    """Le numéro de PR que la question nomme, sinon celui de la fusion notée."""
+    match = _ACCEPT_TEXT.match(question.question.text or "")
+    if match is not None:
+        return int(match.group("pr"))
+    return int(merged.payload.get("pr") or 0)
+
+
+def _ready_receipt(proof_root: Path, task_id: str) -> bool:
+    """Vrai si le reçu de revue existe et porte ``READY`` — un reçu illisible n'est pas un READY."""
+    try:
+        receipt = read_receipt(proof_root, task_id)
+    except ValueError:
+        return False
+    return receipt is not None and receipt.verdict == READY
+
+
+def _candidate_row(service: TaskService, task: MissionTask) -> dict[str, Any] | None:
+    """La ligne de *task* si elle réunit les quatre conditions, sinon ``None``.
+
+    Un ledger, un reçu ou un worktree illisible n'est pas une candidate : la
+    route rend la liste de ce qui se prouve, pas une erreur d'affichage.
+    """
+    try:
+        events = service.ledger.events_for(task.id)
+        merged = _merged_after_launch(events)
+        if merged is None:
+            return None
+        question = _last_open_question(task)
+        if question is None or not _is_merger_accept_question(task, question, events):
+            return None
+        _evidence_root, proof_root = acceptance_roots(service, task.id)
+        if not _ready_receipt(proof_root, task.id):
+            return None
+    except Exception:
+        return None
+    return {
+        "task_id": task.id,
+        "title": task.title,
+        "pr": _question_pr(question, merged),
+        "question_id": question.id,
+    }
+
+
+def accept_merged_candidates(project_root: Path) -> list[dict[str, Any]]:
+    """Les tâches que « Tout accepter » fermerait maintenant, sans rien écrire.
+
+    Une ligne : ``task_id``, ``title``, ``pr``, ``question_id``. Une tâche dont
+    la preuve, le reçu ou le ledger ne se lisent pas reste hors de la liste :
+    la candidate est celle qu'on peut prouver prête, pas celle qu'on espère.
+    """
+    service = TaskService(project_root.resolve())
+    if not service.has_ledger:
+        return []
+    rows: list[dict[str, Any]] = []
+    for task in service.list_tasks(status=TaskState.NEEDS_VERIFICATION.value):
+        row = _candidate_row(service, task)
+        if row is not None:
+            rows.append(row)
+    return rows
+
+
+def accept_merged_view(project_root: Path, _query: Any) -> dict[str, Any]:
+    """La lecture de la route GET : candidates et compte, pour le libellé du bouton."""
+    rows = accept_merged_candidates(project_root)
+    return {"candidates": rows, "count": len(rows)}
+
+
+def _reason(pr: int) -> str:
+    """Le motif fixe : il nomme le lot (et son canal), et la PR, jamais une justification inventée par tâche."""
+    return f"Tout accepter (lot cockpit) : PR #{pr} fusionnée, relue READY"
+
+
+def accept_merged(project_root: Path, body: dict[str, Any]) -> dict[str, Any]:
+    """Accepte et ferme les candidates de *project_root* ; rend les acceptées et les refusées.
+
+    Sans clé de contrôle valide : :class:`PermissionError` (403), rien n'est écrit.
+    Chaque refus est attribué à sa tâche ; les autres continuent.
+    """
+    if not verify_control_key(body.get("control_key")):
+        raise PermissionError("clé de contrôle absente ou invalide : accepter en lot est un geste d'humain")
+    root = project_root.resolve()
+    service = TaskService(root)
+    accepted: list[str] = []
+    refused: list[dict[str, str]] = []
+    for row in accept_merged_candidates(root):
+        task_id = str(row["task_id"])
+        try:
+            task = service.require(task_id)
+            evidence_root, proof_root = acceptance_roots(service, task_id)
+            reason = _reason(int(row.get("pr") or 0))
+            outcome = accept_task(
+                task,
+                root,
+                evidence_root,
+                reason,
+                ACTOR,
+                origin=ORIGIN_HUMAN,
+                proof_root=proof_root,
+            )
+            service.comment(
+                task_id,
+                f"Acceptation humaine ({outcome.verdict.id}, pack {outcome.pack.id}) : {reason}",
+                ACTOR,
+                origin=ORIGIN_HUMAN,
+            )
+            # La clôture relit la preuve et le reçu là où l'acceptation vient de les écrire : dans
+            # le worktree noté, un TaskService posé là retrouve le ledger du projet par son marqueur.
+            TaskService(proof_root).transition(task_id, TaskState.CLOSED, ACTOR, reason)
+        except Exception as exc:  # un refus par tâche, jamais l’arrêt du lot
+            refused.append({"task_id": task_id, "reason": str(exc) or type(exc).__name__})
+        else:
+            accepted.append(task_id)
+    return {"accepted": accepted, "refused": refused}

{grimoire_kit-3.83.0 → grimoire_kit-3.84.0}/src/grimoire/tools/workspace_providers_write.py

@@ -31,7 +31,11 @@ def providers_write_route(project_root: Path, body: dict[str, Any]) -> Any:
         set_provider_enabled,
     )
     from grimoire.tools import workspace_config
+    from grimoire.tools.project_registry import body_project_refusal
 
+    refusal = body_project_refusal(project_root, body)
+    if refusal is not None:
+        raise ValueError(refusal)
     if not verify_control_key(body.get("control_key")):
         raise PermissionError("clé de contrôle absente ou invalide : modifier les fournisseurs est un geste d'humain")
     action = str(body.get("action") or "")
@@ -70,7 +74,11 @@ def providers_set_key_route(project_root: Path, body: dict[str, Any]) -> Any:
     """``POST /api/workspace/providers/set-key`` — pose une clé API en magasin, jamais dans le registre."""
     from grimoire.missions.mandate import verify_control_key
     from grimoire.providers.secrets import set_secret
+    from grimoire.tools.project_registry import body_project_refusal
 
+    refusal = body_project_refusal(project_root, body)
+    if refusal is not None:
+        raise ValueError(refusal)
     if not verify_control_key(body.get("control_key")):
         raise PermissionError("clé de contrôle absente ou invalide : poser une clé API est un geste d'humain")
     provider_id = str(body.get("provider_id") or "")

{grimoire_kit-3.83.0 → grimoire_kit-3.84.0}/src/grimoire/tools/workspace_routes.py

@@ -52,6 +52,7 @@ from grimoire.memory.correction import request_correction_from_body as _memory_c
 from grimoire.missions.liveness import probe_entries
 from grimoire.tools import (
     source_assist,
+    workspace_accept_merged,
     workspace_actions,
     workspace_api,
     workspace_attention,
@@ -75,6 +76,7 @@ from grimoire.tools import (
     workspace_setup_guide,
     workspace_since,
 )
+from grimoire.tools.project_registry import refuse_foreign_body
 
 __all__ = [
     "CHAT_STREAM_PATH",
@@ -121,6 +123,7 @@ def is_sensitive_write(path: str) -> bool:
     """
     return path in SENSITIVE_WRITES
 
+
 #: Sentinelle, même contrat que ``forge_routes.API_GET_UNHANDLED`` : distingue
 #: « chemin inconnu » d'une route qui rendrait légitimement ``None``.
 WORKSPACE_UNHANDLED = object()
@@ -613,6 +616,7 @@ def _autopilot_state(project_root: Path, _query: _Query) -> Any:
 GET_ROUTES: dict[str, _GetHandler] = {
 f"{PREFIX}autonomy/autopilot": _autopilot_state,
 f"{PREFIX}autonomy/mandate": _mandate_state,
+    f"{PREFIX}tasks/accept-merged": workspace_accept_merged.accept_merged_view,
     f"{PREFIX}glossary": _glossary,
     f"{PREFIX}capacity": _capacity,
     f"{PREFIX}tasks": _tasks,
@@ -668,7 +672,9 @@ f"{PREFIX}autonomy/mandate": _mandate_state,
 #: gardé » (portefeuille et sonde exclus) vit avec le cache ; ``pulse_reload``, que la page posait sur un
 #: rechargement du direct, reste accepté (et retiré) : il ne change jamais la réponse.
 PULSE_RELOAD = "pulse_reload"
-LIVE_ROUTES = frozenset({f"{PREFIX}tasks", f"{PREFIX}attention", f"{PREFIX}sessions", f"{PREFIX}sheet"})
+LIVE_ROUTES = frozenset(
+    {f"{PREFIX}tasks", f"{PREFIX}attention", f"{PREFIX}sessions", f"{PREFIX}sheet", f"{PREFIX}tasks/accept-merged"}
+)
 
 
 #: Le flux Server-Sent Events du pouls (P10) : même charge utile que ``pulse``,
@@ -960,7 +966,7 @@ def _mandate_grant(project_root: Path, body: dict[str, Any]) -> Any:
         verify_control_key,
     )
     from grimoire.missions.schemas import ORIGIN_HUMAN
-
+    refuse_foreign_body(project_root, body)
     if not verify_control_key(body.get("control_key")):
         raise PermissionError("clé de contrôle absente ou invalide : accorder un mandat est un geste d'humain")
     try:
@@ -977,7 +983,7 @@ def _mandate_grant(project_root: Path, body: dict[str, Any]) -> Any:
 def _mandate_revoke(project_root: Path, body: dict[str, Any]) -> Any:
     """Révoque le mandat actif — toujours permis derrière le jeton : retirer une autorité n'en demande aucune."""
     from grimoire.missions.mandate import REVOKE_MANUAL, MandateStore
-
+    refuse_foreign_body(project_root, body)
     revoked = MandateStore(project_root).revoke(REVOKE_MANUAL, str(body.get("reason") or ""))
     return {"revoked": revoked.to_dict() if revoked else None}
 
@@ -992,7 +998,7 @@ def _autopilot_set(project_root: Path, body: dict[str, Any]) -> Any:
     from grimoire.missions.autopilot import AutopilotStore
     from grimoire.missions.mandate import JournalError, MandateRefusedError, verify_control_key
     from grimoire.missions.schemas import ORIGIN_HUMAN
-
+    refuse_foreign_body(project_root, body)
     if not verify_control_key(body.get("control_key")):
         raise PermissionError("clé de contrôle absente ou invalide : le pilote automatique est un geste d'humain")
     if not isinstance(body.get("on"), bool):
@@ -1021,6 +1027,7 @@ POST_ROUTES: dict[str, _PostHandler] = {
     f"{PREFIX}assist": _assist,
     f"{PREFIX}tasks/migrate-standard": _task_migrate_standard,
     f"{PREFIX}tasks/add": _task_add,
+    f"{PREFIX}tasks/accept-merged": workspace_accept_merged.accept_merged,
     f"{PREFIX}memory/correct": _memory_correct,
     f"{PREFIX}tasks/intake": workspace_ideas.task_intake,
     f"{PREFIX}tasks/intake/create": workspace_ideas.task_intake_create,

grimoire_kit-3.84.0/version.txt

@@ -0,0 +1 @@
+3.84.0

{grimoire_kit-3.83.0 → grimoire_kit-3.84.0}/web/workspace/README.md

@@ -20,9 +20,14 @@ haut (`#project-chip`, palette réduite aux projets, sans plafond). Plus de zoom
 Flotte/Projet par espace. **L'URL dit tout** : `?project=<slug>` ou
 `?scope=all`, puis `#<espace>[/<rubrique>][?<élément>]` — par exemple
 `?project=grimoire-forge#travail?task=GAO-12`. Les anciens `#piloter`,
-`#executer`… mènent à la rubrique qui les remplace. Un projet consulté depuis
-un cockpit ouvert ailleurs est en **lecture seule** : un bandeau le dit en tête,
-avec « Revenir à … » et la commande qui l'ouvre en écriture.
+`#executer`… mènent à la rubrique qui les remplace. **Le projet est celui de
+l'onglet** (lot 4) : le choix est retenu dans `sessionStorage` et chaque
+requête porte `?project=` ; deux onglets sur deux projets ne se déplacent
+plus l'un l'autre, et le chat de l'orchestrateur suit l'onglet. La sélection
+globale du serveur ne sert plus qu'à ouvrir un onglet neuf ou un lien ancien
+sans paramètre. Un projet absent du registre, ou dont le dossier a disparu,
+reste en **lecture seule** : un bandeau le dit en tête, avec la commande qui
+le réenrôle.
 
 Décisions et alternatives écartées :
 [`docs/adr-006-vue-de-travail.md`](../../docs/adr-006-vue-de-travail.md).
@@ -235,12 +240,17 @@ d'écrire l'entrée, jamais de retirer la citation.
 ## Les routes
 
 Tout ce que la vue de travail ajoute vit sous `/api/workspace/`. Les lectures
-sont servies par **les deux hôtes**. Les écritures visent le projet désigné
-par `?project=` : l'atelier l'ignore (il n'en sert qu'un), le cockpit le résout
-dans son registre — tout projet ENRÔLÉ est inscriptible, pas seulement celui
-qu'il a ouvert (lot 1, 2026-11-07). Les écritures SENSIBLES (fichier, override,
-commande, mutations mémoire) exigent en plus, sur un autre projet que celui
-d'ouverture, `confirm_project: "<slug>"` égal au slug visé (lot 2).
+sont servies par **les deux hôtes**. Depuis le lot 4, une lecture nomme elle
+aussi son projet : `?project=<slug>` est résolu par le registre, un slug
+inconnu est un 404, et sans paramètre le cockpit garde son repli historique
+(sélection courante, sinon projet primaire). Les écritures visent le projet
+désigné par `?project=` : l'atelier l'ignore (il n'en sert qu'un), le cockpit
+le résout dans son registre — tout projet ENRÔLÉ est inscriptible, pas
+seulement celui qu'il a ouvert (lot 1, 2026-11-07). Les écritures SENSIBLES
+(fichier, override, commande, mutations mémoire) exigent en plus, sur un autre
+projet que celui d'ouverture, `confirm_project: "<slug>"` égal au slug visé
+(lot 2). Les écritures d'AUTORITÉ — mandat, pilote automatique, fournisseurs —
+nomment en plus leur projet dans le corps (lot 3, voir plus bas).
 
 ### Lectures — atelier et cockpit
 
@@ -306,6 +316,34 @@ Les écritures d'agents (`skill`, `fields`), les mouvements de tâche, les
 blueprints et `/compile` ont suivi la même ouverture au lot 1 : tout projet
 enrôlé est inscriptible, le slug venant de `?project=` et jamais d'un chemin.
 
+### Écritures d'autorité — mandat, pilote, fournisseurs (lot 3)
+
+Depuis un seul cockpit, le mandat, le pilote automatique et les fournisseurs de
+**n'importe quel projet enrôlé** se pilotent par les mêmes routes qu'avant ;
+seule la résolution change. Le projet visé est nommé **dans l'URL et dans le
+corps** (`{"project": "<slug>", ...}`) :
+
+| Route | Corps (en plus de `project`) |
+|---|---|
+| `POST /api/workspace/autonomy/mandate/grant` | `{gestures[], task_types[], max_sessions_per_day, until, control_key}` |
+| `POST /api/workspace/autonomy/mandate/revoke` | `{reason?}` |
+| `POST /api/workspace/autonomy/autopilot` | `{on: bool, control_key}` |
+| `POST /api/workspace/providers` | `{action: enable\|disable, provider_id, control_key}` |
+| `POST /api/workspace/providers/set-key` | `{provider_id, env_var, value, control_key}` |
+
+Le slug est résolu par le registre (`registered_root`) — jamais un chemin envoyé
+par le client. Un `project` de corps qui ne désigne pas la racine de `?project=`
+est refusé (400), y compris pour un appel direct à la route ; absent, il ne dit
+rien (compatibilité des appels historiques). Une écriture d'autorité sans slug
+d'URL vaut 400 (« projet non nommé ») et un slug inconnu, non enrôlé ou dont le
+dossier a disparu vaut 404 — au lieu du 403 « lecture seule » générique des
+autres écritures. La garde de la clé de contrôle reste **identique** sur tous les
+projets : `control_key_path()`, la même clé lue dans le terminal, les mêmes
+refus (403 sans clé valide). Le front nomme le projet cible avant le champ de la
+clé (carte Fournisseurs, rubrique Mandat et pilote, geste du pilote dans le
+chat) ; en portée « Tous les projets », il invite à choisir un projet au lieu de
+deviner la cible.
+
 ## Ce que la Console accepte
 
 `POST /api/workspace/command` n'exécute que des sous-commandes `grimoire` de