grimoire-kit 3.63.0__tar.gz → 3.64.0__tar.gz

{grimoire_kit-3.63.0 → grimoire_kit-3.64.0}/CHANGELOG.md

@@ -7,6 +7,76 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 
 ## [Unreleased]
 
+## [3.64.0] - 2026-10-20
+
+- feat(registry): `grimoire registry dispatches` mesure les rafales de délégation par session (#687, lot B). Le rapport agrégeait les délégations (#657) par agent et par modèle, sans les regrouper ni par session ni dans le temps : impossible de savoir si la règle « plusieurs sous-agents dans un seul message » est suivie. Nouveau `TraceLedger.delegation_bursts()` (`src/grimoire/traces/ledger.py`) : par `run_id` (= `session_id` de l'hôte), les délégations triées par `started_at` sont chaînées, un écart <= `DELEGATION_BURST_WINDOW_S` (10 s, valeur de départ non mesurée) prolonge la rafale, une rafale compte >= 2 délégations. Rendu : sessions avec délégation, sessions avec rafale, nombre de rafales, taille moyenne, en texte et dans le JSON (clé `bursts`). Datation corrigée (revue) : `_record_delegation` (`src/grimoire/hosts/decisions/evidence_trace.py`) datait la délégation à `now` au `PostToolUse`, soit la FIN d'un sous-agent au premier plan, ce qui biaisait la mesure vers zéro. `started_at` vaut désormais `now - totalDurationMs` (champ `tool_response`, observé dans les transcripts locaux) ; un lancement en arrière-plan (`tool_input.run_in_background`) reçoit le tag `background` et reste daté à maintenant ; sans durée, tag `timing:completion`, et `delegation_bursts` compte ces sessions à part (`sessions_timing_approx`) au lieu de taire le biais. Aucun autre champ ajouté côté écriture : `run_id` et `started_at` existaient déjà. Les événements sans horodatage lisible, ou sans session fournie par l'hôte (`run_id` de repli `delegation-<uuid>`), sont ignorés. Test : `tests/unit/cli/test_app.py` (session avec rafale de 3, isolée, sans rafale, horodatage absent ou illisible, journal vide).
+- fix(hosts): la commande de hook émise se lance dans l'environnement de l'hôte, et `grimoire doctor` le vérifie (#760). Constat : sous Windows, kit installé par `uv pip install` dans un venv, tous les outils du concierge étaient bloqués sous Copilot. Les émetteurs écrivaient le nom nu `grimoire-hook` (`hosts/emitters/base.py`), introuvable hors d'un shell où le venv est activé ; ni l'émission ni `doctor` ne le détectaient.
+  - `hosts/hook_launcher.py` résout le programme à l'émission : `GRIMOIRE_HOOK_COMMAND` s'il est posé ; nom nu si `grimoire-hook` se résout dans le PATH sans le venv actif (pipx, `uv tool` : fichiers inchangés) ; chemin relatif au projet si le venv est sous la racine (Copilot : `./.venv/bin/grimoire-hook`, variante `windows` `.\.venv\Scripts\grimoire-hook.exe`, `cwd: "."` ; Claude Code : `"$CLAUDE_PROJECT_DIR"/.venv/bin/grimoire-hook`) ; sinon chemin absolu, signalé en dégradation « propre à cette machine ».
+  - `grimoire doctor` : contrôle `hook_commands` (fail, module `cli/doctor_hooks.py`) quand le programme d'un hook généré ne se lance pas hors du venv actif, avec le fichier fautif et le remède (`uv tool install` ou `grimoire host sync`).
+  - `docs/troubleshooting.md` §18. La suite fige `GRIMOIRE_HOOK_COMMAND=grimoire-hook` (`tests/conftest.py`) pour que les fichiers générés ne dépendent pas du poste.
+  - Preuve : `tests/unit/test_hook_launcher.py` (13 tests : résolution, émission Copilot et Claude Code, guillemets, `doctor`). Rejeu de bout en bout sous Linux : projet avec `.venv` local (`uv pip install -e`), PATH sans installation globale → les commandes générées rendent `allow`, le nom nu sort en 127 ; `doctor` vert sur les nouveaux fichiers, rouge sur des fichiers 3.62.1.
+  - Non vérifié : aucun hôte Windows réel ; le shell que VS Code utilise sous Windows et son traitement d'une commande de hook introuvable ne sont pas documentés ; le lien entre ce défaut et le blocage observé reste une hypothèse. Une équipe multi-OS sur Claude Code reçoit la forme de l'OS qui a lancé la synchro. `.mcp.json` (`grimoire-mcp`) a le même défaut, non traité ici.
+- fix(workspace): le pouls du cockpit (UI-3) ratait une session réécrite en place sous Windows : un journal de session ou un bail de même taille, réécrit dans le même tic d'horloge du système de fichiers, gardait la même empreinte, et l'interface ne se rafraîchissait pas. Les petits JSON surveillés (≤ 64 Kio) entrent dans l'empreinte par leur contenu ; le journal d'événements, qui ne fait que croître, reste jugé par mtime et taille. Rouge-avant / vert-après : `test_un_battement_de_session_change_l_empreinte` fige la taille et le mtime (`os.utime`) et échoue sur l'ancien code.
+- fix(policies): les suppressions destructives PowerShell et cmd sont reconnues comme `rm -rf` (#761). Constat sur 3.62.1 : en profil governed, sous Copilot (`runInTerminal`), `rm -rf build` était refusé mais `Remove-Item -Recurse -Force`, `Remove-Item build -Recurse`, `rd /s`, `rmdir /s` et `del /s` sortaient en `allow` : `_DESTRUCTIVE_PATTERNS` (`hosts/decisions/tool_facts.py`) ne connaissait que des formes POSIX, le garde était inopérant sous Windows.
+  - Nouveaux motifs, bornés à un segment de commande : `Remove-Item` et ses alias (`ri`, `rm`, `rd`, `rmdir`, `del`, `erase`) avec `-Recurse` ou `-Force` sous n'importe quel préfixe PowerShell (`-r`, `-Rec`, `-Recurse:$true`), un pipeline vers `Remove-Item`, `rd|rmdir /s`, `del|erase /s|/q`, `Format-Volume`, `Clear-Disk`, `Initialize-Disk`.
+  - `pwsh -Command`, `powershell -c` et `cmd /c` rejoignent `bash -c` parmi les introducteurs dont l'argument entre guillemets reste inspecté.
+  - Rouge-avant / vert-après : `tests/test_policy_windows_destructive.py` (22 formes reconnues, 10 témoins non destructifs dont `Remove-Item fichier.txt`, `Get-ChildItem -Recurse`, `dir /s`, `rd build`, un message de commit qui les cite).
+  - Non fait : pas de test sur un hôte Windows réel ; les alias PowerShell redéfinis par l'utilisateur et `Remove-Item` lancé via un script `.ps1` ne sont pas lus.
+- fix(missions): la réservation de fichiers exclusifs est jugée sous le verrou d'écriture du ledger, et un claim hérité sans `expires_at` ne dure plus éternellement (campagne « Dépasser AI-DLC », chantier W1-07). Constat : `TaskService._check_exclusive_files` lisait les claims des autres tâches puis `transition_task` écrivait, le second hors du verrou (reproduit : un claim s'intercale entre les deux, deux tâches réservent le même fichier ; deux threads et deux processus de même) ; `TaskClaim.is_expired` tient un `expires_at` vide pour « jamais », donc un claim d'avant les baux gardait ses fichiers à vie.
+  - Changement : la règle vit dans `missions/reservation.py` et `TaskService` s'en sert toujours en amont (verdict `exclusive_files`, trace du refus) ; le ledger la rappelle sous son verrou par `claim_guard` (K10 WIP, K11 pause), qui reçoit désormais le claim demandé en troisième argument optionnel. Un perdant de la course reçoit un `GrimoireMissionError` qui nomme le fichier et la tâche détentrice, rien n'est écrit. Au rejeu, un claim sans `expires_at` reçoit l'horodatage de son événement plus le TTL par défaut (4 h) : déterministe, sans écriture à la lecture ; un claim hérité plus vieux que le TTL est expiré et libère ses fichiers. Aucun verrou nouveau : celui de `fsio.locked` (avec ou sans `fcntl`) déjà tenu par `transition_task`.
+  - Rouge-avant / vert-après : `tests/unit/missions/test_locked_reservation.py` (7 cas) ; sur `origin/main` 5 échecs (fenêtre de course, deux threads, deux processus x10, deux claims hérités), 0 après.
+  - Non fait : pas d'événement d'audit à la dérivation du TTL (le rejeu ne peut pas écrire) ; `ledger.claim_task` appelé directement sans `claim_guard` (ledger hors `TaskService`) n'est pas gardé.
+
+- feat(evidence): `grimoire evidence resolve <base>..<head>` juge chaque preuve écrite dans une plage git contre les objets git de sa tête (campagne « Dépasser AI-DLC », chantier D-13, ENG-6/ENG-9). Constat : la fiche était différée faute d'ancrage ; W3-02 ne résout la cellule Preuve que contre l'arbre de travail courant, et le journal chaîné de W4-03 (`evidence-log.jsonl`) vit sous `.runs/`, ignoré par git, avec une ancre qui se réécrit avec lui. Aucune commande ne disait si les preuves d'un ensemble de commits tiennent encore.
+  - Décision d'ancrage : `<range>` est une plage de révisions git. Ses preuves sont les jetons de la cellule Preuve (forme W3-02) des lignes de `claim-ledger.md` qu'un commit de la plage a écrites ou modifiées (`git blame` à la tête) ; chaque jeton est jugé contre les blobs de la tête et du commit qui a écrit l'affirmation, jamais contre l'arbre de travail.
+  - Changement : `core/standard_checks/evidence_resolve.py` (plage `A..B` ou commit seul, plage symétrique refusée, projet dans un sous-dossier du dépôt, variables `GIT_DIR` & co. retirées de l'environnement de git) et `cli/cmd_evidence.py` (groupe `evidence`, chargé à la demande). Statuts : `resolved` (lignes citées identiques depuis le commit de l'affirmation, empreinte `@sha256:` égale, run `test-run.json` commité, vert, même `run_id`, avec `tree_fingerprint`), `stale`, `missing`, `unknown` (mémoire, URL, texte libre, fichier absent au commit de l'affirmation, run illisible ou sans empreinte, erreur du résolveur). Une affirmation « prouvé » sans preuve est `missing`. Sortie texte et `-o json` (`anchor` avec base, tête, nombre de commits et `head_published`, `summary`, `fingerprint` des lignes citées) ; code 1 dès qu'une preuve n'est pas `resolved`, 2 sur une plage illisible ou hors d'un dépôt git ; une plage sans preuve rend `empty` (code 0) et le dit.
+  - Rouge-avant / vert-après : `tests/unit/cli/test_cmd_evidence_resolve.py` (33 cas, dépôts git jetables) ; contre les sources de `origin/main` 33 échecs (commande `evidence` inconnue), 33 verts après.
+  - Non fait / non mesuré : pas de provenance chemin -> tâche -> verdict (ENG-6) ni d'échelle de confiance : le seul lien entre un chemin commité et une tâche est le journal local, et l'attribuer depuis lui paraîtrait plus fort que son ancrage ; pas de check requis en CI (ENG-9). Une ligne citée déplacée sans être modifiée est `stale` (comparaison à numéro de ligne égal) ; une référence au fichier entier est `stale` dès que le fichier change ; un dossier cité est `missing` ; `@sha256:` est comparé aux octets du blob git (fins de ligne du dépôt, pas celles d'un checkout Windows avec `autocrlf`) ; une URL d'archive est `unknown` (aucun accès réseau), alors que W3-02 l'accepte ; seul `claim-ledger.md` est lu, pas `evidence-pack.md`.
+- feat(cadrage): questions structurées dans le ledger, posées par lot (campagne « Dépasser AI-DLC », chantier W6-07, issue #564, ADP-8). Constat : K6 (#771) garait une tâche sur une seule question à la fois (`Waiting.question`) ; deux clarifications faisaient deux interruptions et deux notifications (la seconde `task ask` est refusée tant que la première attend : `waiting → waiting`), une question n'avait ni « bloquante ou non », ni « pourquoi », ni identité stable (une reprise la reposait), aucune réponse ne pouvait être déduite par l'agent avec sa source, et rien ne disait au bout de la tâche combien de questions avaient été posées, à qui et pourquoi.
+  - Changement : le ledger existant est étendu, sans second registre. `Question` gagne `blocking`, `why` et `key` (écrits seulement hors défaut : une ligne K6 se relit à l'identique) ; `Waiting.batch` porte les autres questions du lot. `missions/questions.py` rejoue `task.question_asked`, `task.human_answered` (origine humaine seulement) et le nouveau `task.question_resolved` dans `MissionTask.questions`, et lit le statut (`open`, `answered`, `deduced`, `not_awaited`). `TaskService.ask_batch` pose un lot en une transition vers `waiting(human)` (une carte, une notification), ne repose pas une question dont la clé est déjà répondue ou déduite, inscrit une non bloquante sans garer la tâche et trace une déduite (non bloquante, `source` obligatoire) sans la poser. `answer` accepte toute question ouverte du lot et ne rend la tâche que quand toutes les bloquantes sont tranchées (le tick aussi) ; `resolve_question` refuse une bloquante. Surfaces : `task ask --from lot.yaml` / `--non-blocking` / `--why` / `--key`, `task questions [--open]`, `task resolve --source`, `task decisions` liste les questions ouvertes du lot ; MCP `task_update` (`ask` avec `questions`, `resolve`) et `task_show.questions_summary` ; cockpit : la carte de la vue Décisions montre une réponse par question ouverte du lot, avec son « pourquoi ».
+  - Rouge-avant / vert-après : `tests/unit/test_question_batches.py` (13 cas : test de fait de l'issue — deux clarifications, une interruption, une notification —, libération seulement quand toutes les bloquantes sont tranchées, tick, agent qui ne répond pas, reprise sans re-création, registre relu et questions K6 incluses, non bloquante, déduction sourcée, forme K6 inchangée, CLI, MCP, route du cockpit) et `tests/e2e/test_workspace_executer_question_batch.py` (lot tranché question par question depuis la vue Décisions). Sur `origin/main` le module échoue à la collecte (`grimoire.missions.questions` absent) ; sonde comportementale sur la base : 2 interruptions pour 2 clarifications, question déjà répondue reposée, `task ask --from` et `task questions` inconnus (exit 2), `task_update(questions=…)` refusé. Après : 13/13 et e2e 194/194.
+  - Non fait / non mesuré : `grimoire cadrage plan` (exigences acceptées vers tâches à critère mécanique, ADP-9) et l'échec de `standard verify` quand une question bloquante du cadrage reste ouverte (ADP-8, critère 2) ne sont pas livrés ; le reçu portable (lot 4.7) n'existe pas, le registre est dans `task show`/`task questions` ; « jamais poser ce qui se déduit du dépôt » reste une discipline de l'agent (la déduction est tracée, pas vérifiée) ; `task ask` sans les options du lot et les checkpoints de flow gardent le comportement K6 (une question, sans déduplication) ; la notification reste une par lot, pas une par question restante.
+- feat(web): sources du teaser de la vitrine sous `web/teaser/` (tâche GAO-sources-du-t-001) : scène HTML, scripts de rendu et de son, listes de rushes avec leurs licences, polices woff2 avec licences OFL, README en français sur l'ordre de rendu. Les chemins sont relatifs au dossier ; ni rushes, ni images extraites, ni `.mp4`/`.wav` ne sont commités (`.gitignore`). Non fait / non mesuré : le teaser n'a pas été re-rendu depuis ce dossier.
+- fix(missions): reprise d'une tâche garée, claim expiré re-réclamable, revue sans checks (KAN-FRICTIONS). Constat du 2026-10-19 sur la Forge (kit 3.63.0, profil governed, WIP global 5) : une session qui gare sa tâche (`task wait --reason paused`) ne pouvait plus la reprendre une fois le bail plus vieux que son TTL (le frein du bail demandait au ledger de le renouveler, le ledger refusait « tâche waiting, aucun bail », et toute commande Bash de la session était refusée, `grimoire task resume` compris) ; un claim dont `expires_at` était passé répondait « déjà claimed … jusqu'à <date passée> » ; le WIP global comptait ce claim mort ; `task move --to needs_verification` exigeait un pack que `task verify` refusait de produire sans commande déclarée.
+  - Changement : le frein du bail (`hosts/decisions/lease_brake.py`) ne renouvelle plus le bail d'une tâche garée ; au-delà du TTL il refuse avec un motif qui nomme la reprise, et laisse passer `grimoire task resume|show|attach|renew <sa tâche>` (options `--epoch`, `--actor`, `--session-id` seulement ; guillemets, `$`, enchaînement, autre tâche, `--project-root`/`--ledger-root` refusés). La sortie d'attente renouvelle le battement de cœur (`lease.mark_waiting`) : une reprise après une longue pause n'est plus aussitôt jugée perdue. `lease.lost_reason` porte la règle de perte (`fence_pending`, `expires_at`, `heartbeat`) que `lease_view` utilise ; un claim perdu se réclame directement (`missions/reclaim.py`, sous le verrou : barrière du bail, `task.transitioned` vers `ready` marqué `reclaimed`, nouveau claim au nouvel epoch, non compté comme tentative) par son titulaire, ou par un autre acteur si l'hôte du claim a un frein vérifié ; horloge incohérente ou bail vivant : refus inchangé. Le WIP (garde du claim et vue d'admission du tick) ne compte que les claims vivants. `task verify --evidence <fichier>` (tâche sans commande seulement) écrit un pack déclaratif : fichiers du projet hachés (SHA-256, taille, `file:<chemin>`), verdict `skipped` (`created_by: declarative`), code de sortie 4 ; la revue s'ouvre, la clôture reste refusée par `review_gate`, qui le dit. MCP : `task_update move` refuse le sentinelle `unknown` comme un état inconnu. L'exemption « `grimoire task` simple » du frein refuse aussi `"$(…)"` et l'accent grave entre guillemets doubles.
+  - Déjà corrigé sur `main` (prouvé par test, inchangé) : le MCP connaît `waiting` depuis K6 (#801, 3.63.0) et lit un état d'une version plus récente comme `unknown` sans planter ; l'erreur « 'waiting' is not a valid TaskState » venait d'un serveur MCP lancé depuis un clone en 3.57.0. Les appels MCP `task_update(resume)` et `task_show` d'une session garée passaient déjà le frein.
+  - Rouge-avant / vert-après : `tests/unit/missions/test_kanban_resume_frictions.py` (33 cas, dont un de bout en bout par le point d'entrée réel du hook dans un processus séparé) ; 25 échecs sur `origin/main`, 33 verts après.
+  - Non fait / non mesuré : la reprise directe d'un claim perdu ne rejoue pas les autres prudences de la récolte (travail non poussé du worktree, tentatives épuisées) ; un claim repris puis refusé par une autre garde (pause, WIP par rôle) reste `ready` ; la clôture d'une tâche à preuve déclarative reste sans chemin gouverné (#707).
+
+- fix(missions): le classifieur de vérifiabilité ne fait plus monter en V2 sur une preuve attendue en prose, et reconnaît « fichier attendu X existe » (#835). Constat du 2026-10-19 : une tâche aux critères « fichier _scratch/x.json existe » et « fichier _scratch/x.md existe » restait V2 parce que la preuve attendue « x.json et x.md » était comptée comme critère non reconnu, donc `recommended_model` nul et délégation sur le modèle de la session.
+  - Changement : `_criteres` garde toute l'`acceptance` mais n'ajoute une `expected_evidence` que si elle est reconnue (mécanique ou revue), car la preuve décrit ce qu'on produit, pas un verdict (le champ avait été inclus pour qu'un critère sérieux logé là ne passe pas en V0 faute d'être lu, cela reste vrai). Le motif `fichier_attendu` accepte un qualificatif fermé (attendu, généré, produit, créé, livré, de sortie) et « est présent / créé / généré / produit », « existe bien » ; aucun mot libre entre « fichier » et le verbe.
+  - Rouge-avant / vert-après : `tests/unit/missions/test_verifiability.py` et le corpus étiqueté, 3 échecs sur `origin/main`, 0 après ; « un fichier décrit pourquoi X existe » reste V2. Non fait : formulations anglaises voisines (« expected file X exists »).
+
+- test(e2e): scénario live Claude Code, le hook de preuve bloque une clôture sans preuve puis le gate se ferme, rapport JSON (campagne « Dépasser AI-DLC », chantier D-12). Constat : aucun e2e ne faisait tourner un vrai hôte sur un projet enrôlé ; le dossier e2e ne couvre que le cockpit (Playwright), et rien ne montrait qu'un `Stop` refusé par le kit l'est aussi sous `claude -p`.
+  - Changement : `scripts/bench/live_claude_e2e.py` prépare un projet jetable `governed` (hooks émis pour Claude Code, relais `grimoire`/`grimoire-hook` vers `src/`), fait attester l'octroi W5-06 et l'approbation de la commande de vérification par deux tours d'une session d'hôte, puis joue deux appels sans humain (`GRIMOIRE_UNATTENDED=1`) : U1 écrit le code sans preuve, U2 (`--resume`) remet la preuve. Le rapport lit le TraceLedger, le Mission Ledger, les journaux d'autorité et les packs, jamais ce que la session déclare ; il compte le coût réel (delta de session sous `--resume`, inconnu = arrêt, reste du plafond en `--max-budget-usd`, garde de B-06), refuse `--bare`, construit l'environnement de zéro, charge seul le MCP du projet (`--strict-mcp-config`), écarte les `CLAUDE.md` parents (`claudeMdExcludes`), purge et cherche les identifiants en fin de run. `tests/live/test_claude_code_live.py` (marqueur `live_host`, désélectionné par `addopts`, ignoré sans `GRIMOIRE_LIVE_CLAUDE_MAX_USD`, en échec avec `GRIMOIRE_REQUIRE_LIVE=1`). Procédure : `docs/bench-three-arms.md` §16.
+  - Rouge-avant / vert-après : `tests/unit/test_live_claude_e2e.py` (28 cas, sans modèle) : erreur de collecte sur `origin/main` (module absent), 28 verts après.
+  - Passe réelle (2026-10-19, autorisée par Guilhem, plafond 5 $) : 1,0118 $ au total, dont 0,4875 $ pour le passage retenu (4 appels `claude-opus-5-5`, Claude Code 2.1.302) ; deux premiers passages à 0 $ (« Not logged in » : MCP d'un dépôt parent, `HOME` isolé par la suite de tests), un diagnostic haiku à 0,0652 $. Premier `Stop` de U1 en `block` (`refusal:task_unparked`, aucun pack au ledger), premier `Stop` de U2 en `allow`, `gate check --strict` vert, tâche en `needs_verification`.
+  - Non fait / non mesuré : n = 1 sur une tâche d'un fichier ; Copilot non couvert ; aucun job CI ni garde de release n'exige ce test (décision 11 du plan) ; l'octroi est obtenu et relu mais ne décide aucun checkpoint (aucun flow ne tourne) ; les tours humains sont des messages pré-enregistrés rejoués avec l'autorisation de l'opérateur.
+- fix(hooks): une session qui a rendu sa tâche (`needs_verification`) ou l'a bloquée, échouée, annulée ou fermée n'est plus refusée au `Stop` comme « clôture hors tâche » ; le motif de chaque refus est écrit au TraceLedger (chantier D-12). Constat du scénario live : `stop_scope` ne résout une tâche que `claimed`/`running` ; rendue, elle retombait sur `bootstrap`, et la session qui avait écrit était refusée — après avoir fait le geste même que le refus de `Stop` lui demandait. Et cette consigne, pour une tâche `claimed`, était une transition que le ledger refuse (`claimed → needs_verification`).
+  - Changement : `enrolment.parked_task_of_session` (états `waiting`, `needs_verification`, `blocked`, `failed`, `cancelled`, `closed`, claim de cette session) remplace la seule attente K6 dans `evidence_gate._parked_task` ; `needs_verification` reste jugée sur ses gates de preuve (refus nommé si rouges). La consigne d'une tâche `claimed` passe par `--to running`. `runtime._record_decision` ajoute `refusal:<motif>` (`task_unparked`, `no_active_task`, `gates_red`, `guard_error`) aux traces de refus.
+  - Rouge-avant / vert-après : `tests/unit/test_stop_handover.py` (7 cas) : 5 échecs sur `origin/main` (« Clôture hors tâche » au lieu de la sortie ou du refus nommé, consigne `claimed` invalide, aucun motif de refus dans la trace), 7 verts après ; `test_waiting_surfaces.py` inchangé et vert.
+  - Non fait : une session qui a rendu sa tâche puis réécrit hors tâche n'est pas distinguée (la dernière tâche du journal de session la couvre) ; la sortie d'une tâche `blocked`/`failed`/`cancelled` ne revérifie rien.
+- docs(bench): campagne B-06 palier 1, bras `aidlc` seul (AI-DLC 2.11.0, scope `express`, pilote `scripted-person`), les 20 tâches du lot L, k=1, sous plafond dur de 160 $ (`docs/bench-three-arms.md` §15.6 pré-enregistrement, §15.7 résultats). Dépense exacte 87,2406 $ (125 appels, aucun coût inconnu ; la somme des `costUSD` du `modelUsage` final de chaque session donne le même total). Succès aux tests cachés 17/17 runs valides (IC95 Wilson [81,6 %, 100 %]), 20/20 tous runs ; coût par run médian 4,592 $ (0,886 à 5,930 $), environ 28 fois le `nu` et 22 fois `kit-gov` du lot L sur les mêmes tâches ; 494 s médians ; 4 interventions humaines simulées par tâche résolue (B-05). Comparaison descriptive seulement : le banc est saturé et l'écart minimal détectable à 20 tâches est de 44 points.
+  - Constat : dans 18 runs sur 20, l'agent principal écrit la solution avant le stage Code Generation ; le succès mesure surtout le modèle, le coût mesure la cérémonie AI-DLC. Deux runs parquent le workflow en Reverse Engineering sur la consigne commune et reçoivent 12 `Approved.` inutiles (0,51 $ comptés). Trois signalements W1-08b relus : faux positifs (`./` et `/`).
+  - Palier 2 recalculé à la médiane mesurée : 40 runs de plus, 183,68 $, soit 270,92 $ pour le bras `aidlc` paliers 1 et 2 (362,76 $ avec la marge de 1,5) ; non lancé, non autorisé.
+  - Non fait : aucun code modifié ; `build_report` n'agrège toujours pas `aidlc` ; données brutes hors dépôt, comme celles du lot L.
+- feat(hosts): matrice règle × hôte calculée depuis les émetteurs, `grimoire host matrix` / `grimoire host probe`, et `host_sync.ok` exigé (campagne « Dépasser AI-DLC », chantier D-07). Constat : la dégradation par hôte était déclarée (`Degradation`) mais jamais confrontée à ce que l'émetteur écrit, et `host sync` / `up` annonçaient « à jour » alors qu'un fichier hôte modifié à la main avait été préservé, donc non régénéré.
+  - Changement : `hosts/matrix.py` rend le plan réel de chaque hôte et cherche chaque hook (commande `--event`) et chaque règle de couche (ligne et `globs:`/`applyTo:`) dans ce que le plan écrit, sinon la `Degradation` qui le dit ; sont des échecs `undeclared` (ni écrit ni déclaré), `inert` (écrit pour un événement que l'hôte ne déclenche pas) et `misscoped` (règle scopée écrite sans sa portée). `hosts/probe.py` confronte la matrice au disque sans rien écrire (`applied`, `declared`, `missing`, `stale`, `conflict`) ; `host probe` sort en 1 si un fichier émis manque, est périmé ou édité à la main, et aussi si aucun hôte n'a été sondé. `HostSyncOutcome.ok` est faux quand un fichier est préservé (champ `conflicts`) ; l'étape `host_sync` de `up` échoue sur un conflit d'un hôte activé ; `upgrade-flow apply` échoue (`host_sync`, champ `host_drift`) si des surfaces hôtes manquent ou sont périmées après `up`. Les hôtes sans fichier de règles scopées déclarent aussi les règles non livrées (couche extérieure, à l'ombre, en conflit).
+  - Rouge-avant / vert-après : `tests/unit/test_hosts_matrix_probe.py`, `test_hosts_sync_ok.py` et `tests/unit/cli/test_cmd_host_probe.py` (27 cas) ; sur `origin/main` 10 échecs et 1 erreur de collecte (module `grimoire.hosts.matrix` absent), 0 après.
+  - Non fait / non mesuré : la sonde vérifie que le hook est câblé dans le fichier que l'hôte lit, pas que l'hôte l'exécute (le rejeu reste `upgrade-flow probe-hook`, Claude seul) ; un fichier modifié à la main reste préservé (`conflict`) et fait désormais échouer `up` au lieu de passer pour synchronisé, `host sync --force` l'écrase ; seuls les hooks de gouvernance et les règles de couche sont des lignes de la matrice, pas les agents, skills ni commandes.
+  - Correction de revue (D-07-S1-01) : `up` rendait `host_sync failed` à chaque passage sur un fichier hôte légitime de l'utilisateur (un `.claude/agents/concierge.md` à lui, un `settings.json` avec commentaires), `doctor` répondait 28/28 et la seule issue offerte, `host sync --force`, l'écrasait. Nouvelle clé `hosts.preserve` (liste de chemins, schéma et validation) : le fichier n'est jamais écrit, `up` passe en le listant « user-owned », `host probe` le rend `user-owned` (jamais `applied`), `host matrix` ajoute `file:<chemin>` au statut `preserved` et marque `preserved` les hooks et règles qu'il aurait portés (non livrés). Sans déclaration, `up` reste en échec mais nomme les deux issues (déclarer, ou `--force`), et `doctor` échoue aussi (`host_sync_<hôte>`) : un fichier préservé n'est jamais présenté comme synchronisé. La sonde rend `disabled` (non verte) un hook câblé quand `disableAllHooks: true` figure dans `.claude/settings.json` ou `settings.local.json`.
+  - Correction de CI (parité Rust) : `hosts.preserve` est aussi déclaré dans le cœur Rust `grimoire-schema-core` (schéma identique, clé connue, validation relatif / sans `..`) et dans `validator.py`, qui signalait la clé comme inconnue ; 6 cas de parité ajoutés.
+  - Rouge-avant / vert-après (correction) : `tests/unit/test_hosts_preserve.py` (18 cas) ; 15 rouges sur le commit précédent, 18 verts après ; scénario `init` + `up` avec un `concierge.md` à l'utilisateur rejoué en CLI (échec nommant les deux issues avant déclaration, `up` rc 0 deux fois de suite après, fichier intact, `host sync --force` ne l'écrase pas).
+  - Non fait / non mesuré (correction) : `disableAllHooks` n'est lu que dans les deux fichiers du projet (pas `~/.claude/settings.json` ni les réglages d'organisation) et seulement pour Claude Code ; `hosts.preserve` ne s'applique qu'à un chemin émis par le kit (une entrée sans correspondance est ignorée sans avertissement) ; l'échec de `doctor` sans déclaration est un changement de comportement (28/28 devient 27/28 sur un tel projet).
+- test(cli): les 11 commandes de file, d'orchestration et de vague arrivées sans preuve (`queue plan`, `queue release`, `orchestrate pause|resume|status|tick|install-timer|uninstall-timer`, `task wave-checkpoint|approve-check|review`) portent le marqueur `covers` (D-09). Les tests existants qui les exerçaient par un sous-groupe Typer passent par l'application racine (`["queue", "plan", ...]`), les cas manquants sont écrits : `task review` (nominal, NOT-READY fondé, refus), `task approve-check` (JSON, terminal nu refusé, sans commande), `task wave-checkpoint` (action inconnue, empreinte périmée), `orchestrate tick` sans `--apply` (rien d'écrit), minuteur avec `systemctl` injecté et sans systemd. Aucun défaut trouvé dans les commandes. Non mesuré : le marqueur reste une déclaration que le script ne rejoue pas.
+- feat(bench): bras `aidlc` du banc comparatif, AI-DLC 2.11.0 épinglé, scope `express`, HOME isolé, dry-run sans modèle et plafond en dollars fermé par défaut (campagne « Dépasser AI-DLC », chantier B-06). Constat : le protocole comparatif (section 6 du plan) n'avait aucun bras AI-DLC, son coût n'était « pas mesuré » et `three_arms.py` lance ses campagnes sans plafond en dollars. AI-DLC ne documente aucun mode sans humain qui lève ses gates : `AIDLC_UNATTENDED=1` retient l'autorité humaine (`CHANGELOG.md` d'AI-DLC 2.11.0, l. 129 et 281-284).
+  - Changement : `scripts/bench/aidlc_arm.py` vérifie le tag `v2.11.0` d'un clone de référence (commit `6a378b53`, lecture seule), installe AI-DLC par l'installeur du tag sous `homes/aidlc` (`AIDLC_BIN_DIR`, `AIDLC_INSTALL_ROOT`, `XDG_DATA_HOME`), lance `aidlc config --harness claude --mcp none --yes` dans chaque dépôt de tâche et joue les mêmes tâches que `nu`/`kit-gov` (préparation W1-08a, contrôle de transcription W1-08b, tests cachés, `RunRecord` sous `arm: "aidlc"`). Deux pilotes au choix du pré-enregistrement : `unattended` (mode documenté, une intervention déclarée par run) et `scripted-person` (configuration spéciale déclarée : `Approved.` rejoué par `claude -p --resume`, au plus 12 fois). `--dry-run` n'appelle aucun modèle et écrit le pré-enregistrement (empreinte sha256) que `--run` exige à l'identique. `--run` refuse de partir sans `--max-total-usd` ; `state/aidlc-budget.jsonl` encadre chaque appel (`begin`/`end`), le cumul connu est comparé au plafond avant chaque appel, et un coût inconnu, un appel jamais terminé ou une ligne illisible bloquent tout appel suivant. `--estimate` chiffre un run (2,13 à 7,70 $ en `scripted-person`) et le protocole (151 à 485 $ à 20 tâches par bras, 2 963 à 9 527 $ au n requis par B-02) depuis le tarif implicite et les coûts mesurés du lot L, hypothèses dans `docs/bench-three-arms.md` §15. `run_claude_headless` accepte `extra_args`, `append_log` (seules les lignes de l'appel comptent) et `bare` ; le bras `aidlc` n'utilise jamais `--bare`, qui ignorerait les hooks et la skill d'AI-DLC.
+  - Rouge-avant / vert-après : `tests/unit/test_bench_aidlc_arm.py` (31 cas : plafond absent, nul, négatif, non fini ; arrêt au plafond ; coût inconnu bloquant ; journal rejoué, appel commencé jamais terminé, ligne illisible ; pilotes ; dry-run de bout en bout sans appel modèle, `subprocess.Popen` refusant `claude` ; pré-enregistrement exigé ; tarif reproduit sur une ligne du lot L). Sur la base (`origin/main`), le module échoue à la collecte (`aidlc_arm.py` absent) ; avec `aidlc_arm.py` sur le `three_arms.py` de la base, les 2 cas de `run_claude_headless` échouent (`TypeError`, paramètres absents) ; tous verts avec le correctif, `tests/unit/test_bench_*.py` complet vert. Dry-run réel sur le clone AI-DLC et le polyglotte du lot L (`--no-install`) : 20 tâches préparées, pré-enregistrement écrit, aucun modèle lancé.
+  - Pilote payant (2026-10-19, autorisé par Guilhem, plafond 16 $ pour la passe) : 6,5416 $ dépensés, `python/zipper`, k=1, Opus 5.5, `oauth-copy`, jamais `--bare`. Un run de contrôle montre que, sous `claude -p --resume`, `total_cost_usd` et `modelUsage` cumulent la session (`usage` reste propre à l'appel) : le garde-fou compte désormais la différence avec le total précédent de la session (sans quoi le run `scripted-person` aurait été compté 19,37 $ au lieu de 4,90 $), passe le reste du plafond en `--max-budget-usd` à chaque appel, et `--budget-ledger` partage un plafond entre workspaces. `scripted-person` : 4,8963 $, 6 appels (5 reprises), 85 tours, 618 s, 4 gates levés et 2 questions, `WORKFLOW_COMPLETED`, tests cachés réussis, dans la fourchette estimée (2,13 à 7,70 $). `unattended` : 1,4835 $ (au-dessus de l'hypothèse haute de 1,33 $), 1 appel, 168 s, arrêt en Reverse Engineering ; l'agent principal avait écrit `zipper.py` avant le workflow, donc les tests cachés passent sans qu'AI-DLC ait produit le code, et W1-08b classe le run `invalid` (faux positif probable : gras Markdown lu comme glob). Campagne recalculée à k=3 : 316,62 $ à 20 tâches, 1 567,27 $ à 99, 6 221,57 $ à 393 ; plafond proposé en deux paliers (160 $ puis 500 $ à 20 tâches). n = 1 : aucune conclusion de supériorité. Détail dans `docs/bench-three-arms.md` §15.5. Tests : 7 cas ajoutés (delta de session, total en baisse compté en entier, `modelUsage` non sommé, reste du plafond par appel, `--max-budget-usd` dans la commande, journal partagé), 6 rouges sur le code d'avant, 38 verts.
+  - Non fait / non mesuré : n = 1 par pilote, sur une tâche où le `nu` n'échoue jamais ; ce que `--max-budget-usd` compte sous `--resume` (jamais atteint) ; les champs de jetons de `RunRecord` somment `usage`, sans les sous-agents ; `--auth api-key` ajoute `--bare`, qui coupe les hooks : le banc le refuse désormais pour tout bras gouverné (voir ci-dessous ; aucun résultat publié concerné, lots J à L en `oauth-copy`) ; `build_report` n'agrège pas encore `aidlc` ; le plafond de campagne reste la décision de Guilhem (décision 5).
+  - Correctif `--bare` (fail-closed). `scripts/bench/bare_guard.py` : `refuse_bare_for_governed_arms` fait échouer `main` (`SystemExit`, avant tout appel payant) quand `--auth api-key` est demandé avec un bras autre que `nu`, et `run_claude_headless(arm=...)` refuse aussi un `--bare` forcé pour ces bras ; seul `nu` garde `--bare`. Rouge-avant / vert-après : 8 cas dans `test_bench_three_arms.py` (rouges sur la base : `arm` inconnu de `run_claude_headless`, `main` démarre le run). `test_bench_model_pin.py` jouait tous les bras sous un `api-key` simulé : il simule désormais `oauth-copy`. Non fait : un `api-key` sans `--bare` pour les bras gouvernés.
+  - Correctif W1-08b (faux positif du pilote). `hidden_reads._writes_prose_only` : le corps d'un heredoc écrit par `cat`/`tee` vers un fichier de prose n'est plus lu comme des références (le gras `**zipper**` valait un glob qui visait `hidden-tests/`). Les corps envoyés à un shell ou à un interpréteur, écrits vers un script ou vers une cible inconnue restent analysés ; vraies lectures inchangées. Rouge-avant / vert-après : 16 cas (6 `clean`, dont le cas réel du pilote en extrait minimal ; 10 contre-épreuves `invalid`). La transcription réelle du pilote `unattended` passe de `invalid` à `clean`. Aucun résultat publié n'est reclassé.
+
 ## [3.63.0] - 2026-10-19
 
 Le texte intégral des entrées (constat, changement, rouge-avant / vert-après, non fait / non mesuré) est dans [`docs/changelog-3.63.0-detail.md`](docs/changelog-3.63.0-detail.md) : la note de release GitHub est tronquée en silence au-delà de 125 000 unités UTF-16, et ce détail en pèse plus de 500 000.

{grimoire_kit-3.63.0 → grimoire_kit-3.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grimoire-kit
-Version: 3.63.0
+Version: 3.64.0
 Summary: Composable AI agent platform — personas, memory, workflows, and quality automation for any project.
 Project-URL: Homepage, https://github.com/Guilhem-Bonnet/Grimoire-kit
 Project-URL: Repository, https://github.com/Guilhem-Bonnet/Grimoire-kit

{grimoire_kit-3.63.0 → grimoire_kit-3.64.0}/pyproject.toml

@@ -234,7 +234,8 @@ testpaths = ["tests"]
 pythonpath = ["src"]
 # Pas de `-x` ici : il masquait chaque échec derrière le premier, y compris en CI (D-10).
 # `perf` (bancs de latence, K13) est hors CI par défaut ; `-m perf` les lance (le dernier `-m` l'emporte).
-addopts = "-q --tb=short -m 'not perf'"
+# `live_host` (D-12, vrais appels `claude -p`, payants) aussi : `-m live_host` avec un plafond explicite.
+addopts = "-q --tb=short -m 'not perf and not live_host'"
 markers = [
     "covers(*units, level='unit'): surfaces que le test couvre (cli:flow run, genre:fanout, hook:tool-policy, host:opencode), relevées par scripts/check-surface-coverage.py ; level borné par ce que le fichier permet (D-09)",
     "no_session_token: le test envoie ses écritures sans le jeton de session des serveurs locaux",
@@ -244,6 +245,7 @@ markers = [
     "bench: marks performance benchmark tests",
     "crash_bench: banc de coupure du tick (K12) — coupures simulées, rapides ; `-m crash_bench` les isole",
     "perf: bancs de latence chronométrés (budgets de D21), hors CI par défaut ; lancer avec -m perf",
+    "live_host: e2e live d'un hôte réel (D-12, `claude -p` payant), hors CI ; exige GRIMOIRE_LIVE_CLAUDE_MAX_USD, lancer avec -m live_host",
 ]
 
 [tool.coverage.run]

{grimoire_kit-3.63.0 → grimoire_kit-3.64.0}/registry/kit-file-hashes.json

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

grimoire_kit-3.64.0/src/grimoire/__version__.py

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

{grimoire_kit-3.63.0 → grimoire_kit-3.64.0}/src/grimoire/cli/_registry_dispatches_report.py

@@ -28,6 +28,7 @@ def render(
     counts: dict[str, dict[str, Any]],
     misses: dict[str, dict[str, Any]],
     delegations: dict[str, dict[str, Any]],
+    bursts: dict[str, Any],
     freshness: FreshnessReport | None,
     freshness_payload: dict[str, Any] | None,
 ) -> None:
@@ -39,6 +40,7 @@ def render(
                     "dispatches": counts,
                     "misses": misses,
                     "delegations": delegations,
+                    "bursts": bursts,
                     "freshness": freshness_payload,
                 },
                 indent=2,
@@ -95,6 +97,21 @@ def render(
 
         console.print(deleg_tbl)
 
+    if bursts["sessions_with_delegation"]:
+        # #687 : mesure de la règle « plusieurs sous-agents dans un seul message ».
+        console.print(
+            f"Rafales de délégation (>= 2 en {bursts['window_seconds']:g} s, par session) : "
+            f"{bursts['sessions_with_burst']}/{bursts['sessions_with_delegation']} sessions avec délégation, "
+            f"{bursts['burst_count']} rafale(s), taille moyenne {bursts['mean_burst_size']:g}."
+        )
+        if bursts["sessions_timing_approx"]:
+            console.print(
+                f"[yellow]{bursts['sessions_timing_approx']} session(s) avec délégation datée à sa fin "
+                "(durée absente) : rafales possiblement sous-estimées.[/yellow]"
+            )
+    else:
+        console.print("[dim]Rafales de délégation : aucune session avec délégation datée.[/dim]")
+
     console.print()
     if freshness is None:
         console.print("[dim]Fraîcheur des agents : non évaluée (liste des agents indisponible).[/dim]")

{grimoire_kit-3.63.0 → grimoire_kit-3.64.0}/src/grimoire/cli/app.py

@@ -702,14 +702,13 @@ def doctor(
         for w in warnings:
             _record("semantic", passed=False, detail=w)
 
-    # 5bis. Hosts declared vs emitted (issue #177) — jamais FAIL : une dette de
-    # déclaration, pas une panne. INFO pour les fichiers orphelins d'un hôte
-    # désactivé (`hosts.enabled`), WARN si un hôte activé n'a rien émis du tout.
+    # 5bis. Hosts declared vs emitted (issue #177) : INFO orphelins d'un hôte désactivé, WARN hôte activé
+    # sans fichier, FAIL fichier hôte préservé non déclaré dans `hosts.preserve` (D-07, comme `up`).
     if cfg:
         with _timed_phase("hosts_enabled"):
             from grimoire.hosts.collect import build_surface
             from grimoire.hosts.detection import alias_for_host, enabled_host_ids
-            from grimoire.hosts.emitters import emitter_for, owned_managed_paths, supported_hosts
+            from grimoire.hosts.emitters import emitter_for, host_conflict_detail, owned_managed_paths, supported_hosts
 
             host_surface = build_surface(target)
             enabled = enabled_host_ids(target, cfg)
@@ -721,6 +720,8 @@ def doctor(
                 owned = owned_managed_paths(plan, target)
                 alias = alias_for_host(host_id)
                 if host_id in enabled:
+                    if detail := host_conflict_detail(plan, target, alias):  # D-07 : `up` échoue dessus, doctor aussi
+                        _record(f"host_sync_{alias}", passed=False, detail=detail)
                     if not owned:
                         detail = (
                             f"Hôte {alias} activé (`hosts.enabled`) mais aucun fichier émis — "
@@ -1310,6 +1311,7 @@ LazyTyperGroup.configure(
         "queue": LazyGroupSpec("grimoire.cli.cmd_queue", "queue_app", rich_help_panel="Project"),
         "orchestrate": LazyGroupSpec("grimoire.cli.cmd_orchestrate", "orchestrate_app", rich_help_panel="Project"),
         "needs": LazyGroupSpec("grimoire.cli.cmd_needs", "needs_app", rich_help_panel="Project"),
+        "evidence": LazyGroupSpec("grimoire.cli.cmd_evidence", "evidence_app", rich_help_panel="Project"),
         "gates": LazyGroupSpec("grimoire.cli.cmd_gates", "gates_app", rich_help_panel="Utilities"),
         "policies": LazyGroupSpec("grimoire.cli.cmd_policies", "policies_app", rich_help_panel="Project"),
         "proposals": LazyGroupSpec("grimoire.cli.cmd_proposals", "proposals_app", rich_help_panel="Agents"),
@@ -1337,7 +1339,7 @@ LazyTyperGroup.configure(
         "repair",
         "memory", "hooks", "cadrage", "debugger", "dbg", "registry", "workflows",
         "wf", "standard", "ext", "blueprint", "flow", "cockpit", "task", "mission",
-        "stigmergy", "features", "host", "providers", "dispatch", "route", "queue", "orchestrate", "needs", "gates", "proposals", "upgrade-flow", "agent", "web",
+        "stigmergy", "features", "host", "providers", "dispatch", "route", "queue", "orchestrate", "needs", "evidence", "gates", "proposals", "upgrade-flow", "agent", "web",
         "autonomy",
         "config", "completion", "self", "plugins",
     ],
@@ -1471,6 +1473,7 @@ def registry_dispatches(ctx: typer.Context) -> None:
     counts = ledger.agent_dispatch_counts()
     misses = ledger.agent_miss_counts()
     delegations = ledger.delegation_counts()
+    bursts = ledger.delegation_bursts()
 
     cfg: GrimoireConfig | None = None
     try:
@@ -1507,6 +1510,7 @@ def registry_dispatches(ctx: typer.Context) -> None:
         counts=counts,
         misses=misses,
         delegations=delegations,
+        bursts=bursts,
         freshness=freshness,
         freshness_payload=freshness_payload,
     )

grimoire_kit-3.64.0/src/grimoire/cli/cmd_evidence.py

@@ -0,0 +1,50 @@
+"""``grimoire evidence resolve <range>`` (D-13) : chaque preuve d'une plage git, résolue ou non."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from grimoire.core.standard_checks.evidence_resolve import RangeError, resolve_range
+
+evidence_app = typer.Typer(help="Resolve the proofs written in a git range.", no_args_is_help=True)
+
+
+@evidence_app.command("resolve")
+def resolve_command(
+    ctx: typer.Context,
+    range_spec: str = typer.Argument(..., metavar="RANGE", help="<base>..<head>, or one commit (its own changes)."),
+    project_root: Path = typer.Option(Path(), "--project-root", help="Project root inside the git repository."),  # noqa: B008
+) -> None:
+    """Judge every proof of the claim-ledger rows written in RANGE against git at its head.
+
+    Each proof is resolved, stale, missing or unknown; only resolved counts.
+    Exit 1 as soon as one proof is not resolved, 2 on a bad range.
+    """
+    try:
+        report = resolve_range(project_root, range_spec)
+    except RangeError as exc:
+        typer.echo(f"evidence resolve: {exc}", err=True)
+        raise typer.Exit(2) from exc
+    if str((ctx.obj or {}).get("output", "text")) == "json":
+        typer.echo(json.dumps(report.to_dict(), indent=2, ensure_ascii=False))
+    else:
+        published = {True: "published", False: "not published", None: "no remote"}[report.published]
+        base = report.base[:12] if report.base else "(root)"
+        typer.echo(f"Range {base}..{report.head[:12]}: {report.commits} commit(s), judged at head ({published}).")
+        for proof in report.proofs:
+            mark = proof.status if proof.status == "resolved" else proof.status.upper()
+            shown = proof.token or "(no proof)"
+            typer.echo(f"{mark:9} {proof.task_id} {proof.claim}  {shown}  ({proof.reason})")
+        counts = report.counts()
+        if report.verdict == "empty":
+            typer.echo("No proof written in this range: nothing proven, nothing refuted.")
+        else:
+            typer.echo(
+                f"{len(report.proofs)} proof(s): {counts['resolved']} resolved, {counts['stale']} stale, "
+                f"{counts['missing']} missing, {counts['unknown']} unknown."
+            )
+    if report.verdict == "unresolved":
+        raise typer.Exit(1)

{grimoire_kit-3.63.0 → grimoire_kit-3.64.0}/src/grimoire/cli/cmd_host.py

@@ -23,7 +23,16 @@ from grimoire.bridges.schemas import HostId
 from grimoire.hosts.capabilities import all_profiles, gaps_for, profile_for, resolve_host
 from grimoire.hosts.collect import build_surface, collect_commands, entry_agent_name
 from grimoire.hosts.detection import alias_for_host, enabled_host_ids
-from grimoire.hosts.emitters import apply_plan, apply_plans, emitter_for, owned_managed_paths, supported_hosts
+from grimoire.hosts.emitters import (
+    apply_plan,
+    apply_plans,
+    conflict_exits,
+    emitter_for,
+    owned_managed_paths,
+    supported_hosts,
+)
+from grimoire.hosts.matrix import build_matrix
+from grimoire.hosts.probe import probe_hosts
 from grimoire.hosts.runtime import parse_event, run_hook
 from grimoire.hosts.surface import Enforcement
 
@@ -31,6 +40,7 @@ host_app = typer.Typer(help="Surfaces hôtes : agents, compétences, commandes e
 console = Console()
 
 _PROJECT_ROOT_OPTION = typer.Option(Path.cwd(), "--project-root", help="Racine du projet.", show_default=False)
+_HOST_ALL_OPTION = typer.Option("all", "--host", help="claude | copilot | codex | cursor | gemini | opencode | all | auto.")
 _HOST_OPTION = typer.Option("auto", "--host", help="claude | copilot | codex | cursor | gemini | opencode | all | auto.")
 _DRY_RUN_OPTION = typer.Option(False, "--dry-run", help="Montrer sans écrire.")
 _FORCE_OPTION = typer.Option(False, "--force", help="Écraser un fichier non généré occupant un chemin géré.")
@@ -256,7 +266,9 @@ def host_sync(
             console.print(f"    [green][OK][/green] {label}")
         for label in result.skipped:
             cause = _CONFLICT_TEXT.get(result.conflicts.get(label, ""), "conflit")
-            console.print(f"    [yellow][!][/yellow] {label} — {cause}, préservé (utilisez --force)")
+            console.print(f"    [yellow][!][/yellow] {label} — {cause}, préservé ({conflict_exits([label])})")
+        for label in result.preserved:
+            console.print(f"    [dim]{label} — à l'utilisateur (hosts.preserve), non écrit[/dim]")
         for label in result.removed:
             console.print(f"    [yellow][-][/yellow] {label} — {'retirerait' if dry_run else 'retiré'} : la règle source n'existe plus")
         for degradation in result.degradations:
@@ -376,6 +388,80 @@ def host_status(
     raise typer.Exit(0 if all(item.in_sync for item in payload) else 1)
 
 
+@host_app.command("matrix")
+def host_matrix(
+    ctx: typer.Context,
+    project_root: Path = _PROJECT_ROOT_OPTION,
+    host: str = _HOST_ALL_OPTION,
+) -> None:
+    """Matrice règle × hôte, calculée depuis ce que chaque émetteur écrit réellement.
+
+    Sort en 1 si une règle n'est ni appliquée ni déclarée dégradée (`undeclared`),
+    écrite pour un événement que l'hôte ne déclenche pas (`inert`) ou écrite sans sa portée (`misscoped`).
+    """
+    targets = tuple(_resolve_targets(host, project_root))
+    matrix = build_matrix(project_root, targets)
+    if _get_fmt(ctx) == "json":
+        typer.echo(json.dumps(matrix.to_dict(), indent=2, ensure_ascii=False))
+        raise typer.Exit(0 if matrix.ok and matrix.hosts else 1)
+    if not matrix.hosts:
+        console.print("[red]Aucun hôte activé[/red] : rien n'a été calculé.")
+        raise typer.Exit(1)
+    table = Table(title="Matrice règle × hôte")
+    table.add_column("Règle")
+    for host_id in matrix.hosts:
+        table.add_column(profile_for(host_id).display_name)
+    subjects = list(dict.fromkeys(c.subject for c in matrix.cells))
+    for subject in subjects:
+        row = [subject]
+        for host_id in matrix.hosts:
+            cell = next((c for c in matrix.for_host(host_id) if c.subject == subject), None)
+            row.append("" if cell is None else (cell.status if cell.ok else f"[red]{cell.status}[/red]"))
+        table.add_row(*row)
+    console.print(table)
+    for cell in matrix.failing:
+        console.print(f"  [red][!][/red] {cell.host} {cell.subject} — {cell.status} : {cell.reason}")
+    raise typer.Exit(0 if matrix.ok else 1)
+
+
+@host_app.command("probe")
+def host_probe(
+    ctx: typer.Context,
+    project_root: Path = _PROJECT_ROOT_OPTION,
+    host: str = _HOST_ALL_OPTION,
+) -> None:
+    """Vérifier sur le disque que ce que chaque hôte doit appliquer l'est, à jour. N'écrit rien.
+
+    Sort en 1 si un fichier émis manque, est périmé ou modifié à la main, si une règle n'est
+    plus dans le fichier de l'hôte, ou si aucun hôte n'a pu être sondé (inconnu n'est pas OK).
+    """
+    targets = tuple(_resolve_targets(host, project_root))
+    report = probe_hosts(project_root, targets)
+    if _get_fmt(ctx) == "json":
+        typer.echo(json.dumps(report.to_dict(), indent=2, ensure_ascii=False))
+        raise typer.Exit(0 if report.ok else 1)
+    if not report.verified:
+        console.print("[red]Aucun hôte activé[/red] : rien n'a été vérifié.")
+        raise typer.Exit(1)
+    for item in report.hosts:
+        state = "[green]appliqué[/green]" if item.ok else "[red]non conforme[/red]"
+        console.print(f"[bold]{item.display_name}[/bold] {state}")
+        for file in item.files:
+            if file.state == "user-owned":
+                console.print(f"  [dim]{file.path} — à l'utilisateur (hosts.preserve), non livré par le kit[/dim]")
+            elif not file.ok:
+                console.print(f"  [red][!][/red] {file.path} — {file.state}{f' ({file.cause})' if file.cause else ''}")
+        for probed in item.cells:
+            if not probed.ok:
+                why = probed.cell.reason or ("hooks coupés par `disableAllHooks` dans les réglages de l'hôte" if probed.disk == "disabled" else "")
+                console.print(f"  [red][!][/red] {probed.cell.subject} — {probed.cell.status}/{probed.disk} {why}".rstrip())
+    if not report.ok:
+        console.print("`grimoire host sync` régénère ce qui manque ou est périmé ; un fichier modifié à la main reste préservé.")
+        if report.conflicts:
+            console.print(conflict_exits(list(report.conflicts)))
+    raise typer.Exit(0 if report.ok else 1)
+
+
 @host_app.command("run")
 def host_run(
     slug: str = _RUN_SLUG_ARGUMENT,

{grimoire_kit-3.63.0 → grimoire_kit-3.64.0}/src/grimoire/cli/cmd_task.py

@@ -1091,24 +1091,31 @@ def task_verify(
     project_root: _PROJECT_ROOT = Path(),
     ledger_root: _LEDGER_ROOT = _DEFAULT_LEDGER,
     evidence_root: _EVIDENCE_ROOT = _DEFAULT_EVIDENCE,
+    evidence: Annotated[list[str] | None, typer.Option(
+        "--evidence", help="Tâche sans commande : fichier de preuve du projet (répétable) — pack déclaratif, verdict skipped.",
+    )] = None,
 ) -> None:
     """Lance les commandes déclarées de la tâche, écrit le pack et le verdict (#772).
 
     Code de sortie 0 si le verdict est `passed`, 1 s'il est `failed` (code de
     sortie inattendu, délai, commande inexécutable), 2 si la tâche ne déclare
-    aucune commande : jamais un vert à vide.
+    aucune commande : jamais un vert à vide. Avec `--evidence` (tâche sans
+    commande) : pack déclaratif des fichiers cités, haché, verdict `skipped`,
+    code 4 — la revue s'ouvre, la clôture reste à un humain.
     """
-    from grimoire.cli.cmd_task_approve import report_unapproved, verify_payload
+    from grimoire.cli.cmd_task_approve import report_declarative, report_unapproved, verify_payload
     from grimoire.missions.verify import NoDeclaredChecksError, UnapprovedChecksError, verify_task
 
     root = project_root.resolve()
     service = _service(project_root, ledger_root)
     task = _require_task(service, task_id)
     evidence_path = evidence_root if evidence_root.is_absolute() else root / evidence_root
+    if evidence:
+        raise typer.Exit(report_declarative(task, root, evidence_path, evidence, as_json=_fmt(ctx) == "json", console=console))
     try:
         outcome = verify_task(task, root, evidence_path)
     except NoDeclaredChecksError as exc:
-        console.print(f"[red]✗[/red] {exc}")
+        console.print(f"[red]✗[/red] {exc} — preuve faite de fichiers : `--evidence <fichier>` (pack déclaratif)")
         raise typer.Exit(2) from exc
     except UnapprovedChecksError as exc:
         report_unapproved(exc, task_id, as_json=_fmt(ctx) == "json", console=console)  # W3-03 : rien n'a été lancé.

{grimoire_kit-3.63.0 → grimoire_kit-3.64.0}/src/grimoire/cli/cmd_task_approve.py

@@ -106,3 +106,28 @@ def verify_payload(outcome: Any) -> dict[str, Any]:
         "verdict": outcome.verdict.to_dict(),
         "receipts": [{k: r[k] for k in ("command_sha256", "tree_fingerprint", "exit", "reused")} for r in outcome.receipts],
     }
+
+
+def report_declarative(task: Any, root: Path, evidence_root: Path, paths: list[str], *, as_json: bool, console: Any) -> int:
+    """``task verify --evidence`` (KAN-FRICTIONS) : écrit le pack déclaratif, le présente, rend le code de sortie.
+
+    4 quand le pack est écrit (jamais 0 : ce n'est pas un vert mécanique), 2 quand un fichier est refusé.
+    """
+    from grimoire.missions.declarative_evidence import DeclarativeEvidenceError, declare_evidence
+
+    try:
+        outcome = declare_evidence(task, root, evidence_root, paths)
+    except DeclarativeEvidenceError as exc:
+        console.print(f"[red]✗[/red] {escape(str(exc))}")
+        return 2
+    if as_json:
+        typer.echo(json.dumps(outcome.to_dict(), indent=2, ensure_ascii=False))
+        return 4
+    console.print(
+        f"[yellow]DÉCLARATIF[/yellow] {task.id} — pack {outcome.pack.id} : {len(outcome.files)} fichier(s) présents et hachés, "
+        f"aucune commande lancée ; verdict {outcome.verdict.verdict.value} ({outcome.verdict.id}), jamais un vert mécanique."
+    )
+    for rel, digest, size in outcome.files:
+        console.print(f"  - {escape(rel)}  [dim]sha256 {digest[:12]}, {size} octets[/dim]")
+    console.print("  La revue peut s'ouvrir (`task move --to needs_verification`) ; la clôture reste à un humain.")
+    return 4