@sylad/cadence 1.13.0 → 1.14.1

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "cadence",
       "description": "Session start and close rituals driven by a versioned plan (raf), and deliveries proven by their effect. Needs the cadence CLI (npm i -g @sylad/cadence).",
-      "version": "1.13.0",
+      "version": "1.14.1",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "description": "A repo-native working method: session start and close rituals driven by a versioned plan (raf), deliveries proven by their effect, and three reviewer agents (UX, code, QA).",
-  "version": "1.13.0",
+  "version": "1.14.1",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/README.md

@@ -7,6 +7,8 @@ cadence keeps both in plain files next to the code, and [Claude Code](https://cl
 
 ## Start
 
+Needs Node 22.18 or later (see [docs/stabilite.md](docs/stabilite.md)).
+
 ```sh
 npm install -g @sylad/cadence
 raf init
@@ -36,6 +38,7 @@ Details: [docs/skills.md](docs/skills.md) and [docs/cadence-hud.md](docs/cadence
 - [docs/orchestrate.md](docs/orchestrate.md): waves of sessions and their budgets.
 - [docs/deliver.md](docs/deliver.md): wait for the CI, deploy, verify the effect.
 - [docs/spec.md](docs/spec.md): screen and back-end sheets.
+- [docs/ref.md](docs/ref.md): reference documents (specs, norms, mock-ups) and the coverage of their elements by the lots.
 - [docs/lead.md](docs/lead.md): the lead workflow.
 - [docs/overview.md](docs/overview.md): the longer introduction and the map of every page.
 - [docs/fonctionnement.md](docs/fonctionnement.md): how it all works, in four figures.

package/agents/reference-planner.md

@@ -0,0 +1,26 @@
+---
+name: reference-planner
+description: Reference document coverage planner. Reads an inventory (`inventaire.json` of `ref analyse --double` or `ref diff --out`, or `lectures/a.json`, the reading `ref analyse` writes by default) and the project's plan, and PROPOSES lots that cover the elements nobody covers yet — each proposal cites the ids it covers, says whether it is feasible or blocked (naming the missing datum or service) and what it depends on. It only proposes, it creates no lot, edits no file and writes no exclusion, and the lead decides. Starts from `cadence ref coverage`, which lists the gaps. Used by the lead, not by hand.
+tools: Read, Grep, Glob, Bash
+---
+
+You plan the coverage of one reference document. You read; you never write. The lot is not yours to create, the plan is not yours to edit, and an element is not yours to exclude: you propose, the lead decides.
+
+Follow the brief you are given. It names the inventory (`inventaire.json`) and the plan. The method:
+
+1. **Run `cadence ref coverage <inventaire.json>` first.** Its `✗` lines are the work: elements no done lot covers and no written exclusion justifies. A lot (any status but `dropped`) that cites an id already covers it in the plan's eyes; only a **done** lot counts for the command. An element a todo or doing lot already cites is not a gap to plan again: say so, name the lot.
+2. **Read the inventory and the plan.** The inventory gives, per element, its type, page, zone, text and the elements it refers to (`composant.ecran`, `etat.cible`, `statut.couvre`). The plan (`.cadence/raf.yaml`, the legacy `docs/plan/raf.yaml`, or the file named by `plan:` in `cadence.yaml`) gives the lots that exist, their titles and what they depend on. Read the project's CLAUDE.md and the code of the screens or modules the elements belong to: a proposal that ignores what exists duplicates it.
+3. **Group the gaps into lots of one session each** (an estimate of 1 or less): one screen, one zone of a screen, one table, one message template. Never one lot per element, never one lot for the whole document. An element goes into exactly one proposed lot.
+4. **For each proposed lot, say:**
+   - `titre`: what the lot delivers, in the project's words;
+   - `ids`: the ids it covers, copied from the inventory, never retyped from memory (the lot will quote them, and `cadence ref coverage` finds them by that quotation);
+   - `faisable`: `true` when everything the lot needs exists today; `false` when it is **blocked**, and then `bloque_par` names precisely the missing datum or service (« the `GET /api/x` endpoint does not exist », « no data source for the wind barbs », « the licence of the font is unknown »), never « missing information »;
+   - `depend_de`: the lots it waits for, an existing id of the plan (`L12`) or the title of another proposal;
+   - `raison`: one sentence on why these elements belong together.
+5. **A `silence` of the inventory is a question for a human**, not a lot: list it under `questions` with its id. Never answer it.
+6. **An element that should not be built** (a decoration of the document, a text of the mock-up that is not the product) is not excluded by you: list it under `exclusions_proposees` with its id and the reason, the lead writes it in the `exclusions` key of the inventory if they agree.
+7. **Never invent an id.** An id that is not in the inventory is an error of your proposal. Before you report, check that every `✗` id of `cadence ref coverage` is in a proposal, in `exclusions_proposees`, in `questions`, or named in `deja_cites` as already cited by an existing lot.
+
+- You are read-only: no `raf add|start|done|note|review|ux`, no edit of the plan, of the inventory or of any file, no commit, no push, no deliver, no subagent. The only command you run is `cadence ref coverage` (and read-only commands such as `git log`, `grep`).
+- A proposal with no id, or an id twice, is not a proposal.
+- Give the report in the structured output the brief asks for: `lots` (each `titre`, `ids`, `faisable`, `bloque_par`, `depend_de`, `raison`), `exclusions_proposees` (`id`, `raison`), `deja_cites` (`id`, `lot`), `questions`, `nonVerifie`, `resume`.

package/dist/cli.js

@@ -9,12 +9,14 @@ import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
 import { deliver, parseDeliverConfig, realDeps, shellQuote } from './deliver.js';
 import { defaultTarget, effectLines, realCheckDeps, verifyCommand } from './verify.js';
+import { verifyGate } from './verify-gate.js';
 import { ganttData, renderGantt } from './gantt.js';
-import { gitRoot, isTracked, readCommits, matchesHead, resolveCommit, stage, stagedFiles, syncIndexWithHead } from './git.js';
+import { PLAN_ACTIONS, planCommitMessage } from './plan-commit.js';
+import { dirtyPaths, gitRoot, isTracked, readCommits, matchesHead, resolveCommit, stage, stagedFiles, syncIndexWithHead } from './git.js';
 import { installHook, pendingCommitMessage, REFUSED } from './hook.js';
 import { citedRefs, linkCommits } from './link.js';
 import { buildNews, loadEntries, newEntry, newsData, newsIssues, publicTitleTooLong, stampEntries } from './news.js';
-import { invalidResource, Plan, RafError, SCREENS, STATUSES } from './plan.js';
+import { invalidResource, Plan, RafError, SCREENS, STATUSES, setPlanNotice } from './plan.js';
 import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
@@ -27,8 +29,9 @@ import { cadenceHome, liveWaves, openLotsIn, openWavesIn, waveLotsIn } from './o
 import { blockingLots, LABEL, resumeCommand } from './orchestrate/table.js';
 import { classifyAll, measure, ollamaClassifier, readCache, readJournals, readRuns, renderReport, sampleKeys, serializeCache } from './corrections.js';
 import { computePerf, perfHeader, perfWindows, readPlans, readProjectDeliveries, readProjectFailedEntries, renderPerf } from './perf.js';
-import { findAcceptation, parseAcceptation, resealAcceptation } from './orchestrate/accept.js';
+import { findAcceptation, parseAcceptation, redAcceptations, resealAcceptation, resealForGreen, runAcceptation, setVert } from './orchestrate/accept.js';
 import { refCommand } from './ref/command.js';
+import { coverageCommand } from './ref/coverage.js';
 import { release } from './release.js';
 import { applyMigration, describeMigration, planMigration, unhandledError } from './migrate.js';
 import { checkFiche, deriveQa, readFiche, summary } from './spec.js';
@@ -75,10 +78,12 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   cadence ref diff <lecture-a.json> <lecture-b.json> [--out inventaire.json] [--seuil 30]   réconcilie deux lectures du même document (même slug et même empreinte) : concordant → un élément lu ou mesuré, divergent → incertain avec les deux versions, seul (une lecture) → incertain en attente du troisième regard ; silences réunis ; au-delà de 30 % d'éléments non appariés (--seuil, en pour cent) code 1 et rien d'écrit ; --out écrit l'inventaire
   cadence ref measure <slug> <page> <page | x,y | x,y,l,h> [--quoi couleurs|contraste|boites|texte] [--largeur 1440] [--json]   mesure une zone d'une page rendue (pixels de la page) : couleurs (point, moyenne, dominantes), contraste WCAG 2.2, boîtes, mots OCR tesseract et taille de police estimée ; valeurs ramenées à 1440 px de large, tolérance déclarée
   cadence ref check <inventaire.json | lecture.json>   valide un inventaire ou une lecture (schéma version 1, modèle templates/inventaire.json) : une ligne « ✗ chemin : raison » par écart puis « N écart(s) » sur la sortie standard (code 1), le résumé par type sinon (code 0) ; fichier absent, vide ou illisible : code 2 ; n'appelle aucun outil système
+  cadence ref coverage <inventaire.json>   couverture d'un document de référence, sans modèle : les éléments qu'aucun lot fait ne couvre (lot qui cite l'id) et qu'aucune exclusion écrite avec sa raison (clé « exclusions » de l'inventaire) ne justifie, une ligne ✗ chacun ; code 1 s'il en reste, 0 sinon, 2 pour un appel mal formé ou un fichier qui n'est pas un inventaire valide
   cadence ref eval <attendu.json | dossier> <lecture.json | dossier> [--json]   note une lecture contre l'inventaire attendu (vérité connue) : rappel et précision par type, faux lu (éléments sûrs et faux), pièges trouvés, tokens par page (usage.tokens de la lecture) ; lecture d'un autre document refusée (code 2) ; sur dossiers, un cas par sous-dossier (attendu.json / lecture.json)
   cadence ref corpus <dossier> [--sans-rendu]   écrit le corpus synthétique à vérité connue (7 pièges : texte ambigu levé par une figure, figure qui contredit, table en image, gabarit BUFR, contrôle translucide, page Proposal, scan bruité) : par cas document.html et attendu.json, puis document.pdf et page-<n>.png (1700×2200) rendus par Playwright (CADENCE_PLAYWRIGHT = dossier du paquet) ; dossier existant ou Playwright introuvable : code 2
   cadence release patch|minor|major [--dry-run]   prépare le commit de version (package.json, package-lock.json, plugin.json, marketplace.json, CHANGELOG.md) sans commiter ni publier ; imprime les étapes du lead et vérifie docs/whats-new.md : refus sur un arbre sale, un [Unreleased] vide ou une version déjà taguée
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
+  cadence verify --gate --sha rév [--project dossier]   rejoue la porte du projet (orchestrate.build puis orchestrate.test) au sha dans un worktree jetable aux dépendances reliées (orchestrate.worktreeDeps), puis le retire : 0 vert, 1 rouge avec les tests en échec, 2 rien à rejouer
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
 Un commit appartient à un lot quand son message cite l'identifiant : « feat(L3): … », « L3/t1 ».
@@ -113,6 +118,7 @@ function legacyPlanLine(root, legacy) {
     return `raf: ${PLAN_LEGACY} est l'ancien emplacement du plan ; le déplacer : cd ${shellQuote(root)} && mkdir -p ${dirname(PLAN_DEFAULT)} && ${gitRoot(root) && isTracked(root, PLAN_LEGACY) ? 'git mv' : 'mv'} ${PLAN_LEGACY} ${PLAN_DEFAULT}`;
 }
 export function run(argv, io) {
+    setPlanNotice(io.err);
     try {
         // orchestrate a ses propres options (--status et --resume prennent une valeur facultative, --answer en prend deux).
         if (argv[0] === 'orchestrate') {
@@ -172,6 +178,7 @@ function dispatch(argv, io) {
             'dry-run': { type: 'boolean' },
             sha: { type: 'string' },
             retry: { type: 'string' },
+            gate: { type: 'boolean' },
             clear: { type: 'boolean' },
             ignored: { type: 'boolean' },
             notes: { type: 'boolean' },
@@ -285,7 +292,7 @@ function dispatch(argv, io) {
         return corrections(rest, values, io);
     if (command === 'perf')
         return perf(rest, values, today, io);
-    if (command === 'ref')
+    if (command === 'ref' && rest[0] !== 'coverage')
         return refCommand(rest, values, root, io);
     // Prépare le commit de version : écrit les fichiers de version, ne commite ni ne publie rien (L341).
     if (command === 'release')
@@ -309,6 +316,7 @@ function dispatch(argv, io) {
     if (command === 'spec' && (rest[0] === 'check' || rest[0] === 'qa'))
         return spec(rest, io);
     const reseal = command === 'spec' && rest[0] === 'reseal';
+    const green = command === 'spec' && rest[0] === 'green';
     // --all balaie les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant.
     if (command === 'session' && (values.all || values.depth !== undefined))
         return sessionAll(rest, values, io);
@@ -325,6 +333,9 @@ function dispatch(argv, io) {
     if (fallback?.legacy && !installing)
         (io.notice ?? io.err)(legacyPlanLine(root, fallback.legacy));
     const loadPlan = () => Plan.load(planPath, { ...planConfig?.settings, config: configPath });
+    // `ref coverage` lit le plan (les lots faits qui citent les éléments) : il passe après le choix du plan, les autres `ref` n'y touchent pas (L367).
+    if (command === 'ref')
+        return coverageCommand(rest.slice(1), loadPlan, io, { repo: root, specDir: readOrchestrateConfig(configPath).spec.dir });
     const newsDir = resolve(io.cwd, values.dir ?? join(root, 'docs/nouveautes'));
     // Limite DÉCLARÉE (news.publicTitleMax) : sans clé, seul « raf check » avertit ; avec, la pose d'un titre public est refusée.
     const refuseLongTitle = (text, hint = '') => {
@@ -408,6 +419,24 @@ function dispatch(argv, io) {
                     refuseLongTitle(pub, lot?.public ? '' : ' — titre de la Nouveauté reprise par le site : corriger l\'entrée ou poser raf public');
             }
             // Le plan ne lit pas git : lui dire combien de commits du lot sa revue ne couvre pas quand elle est exigée.
+            // Un lot clos avec une acceptation à vert: false bloque les vagues suivantes du dépôt (verrou des tests d'acceptation, L366).
+            if (status === 'done' && !rest[0].includes('/')) {
+                const repo = gitRoot(root) ?? root;
+                let dir = null;
+                try {
+                    dir = readOrchestrateConfig(configPath).spec.dir;
+                }
+                catch {
+                    // un cadence.yaml illisible ne doit pas empêcher de clore un lot : `cadence check` en parle
+                }
+                const red = dir === null ? undefined : redAcceptations(repo, dir).find((a) => a.lot === rest[0]);
+                if (red) {
+                    const text = `${rest[0]} : ${red.path} est à vert: false — clos ainsi, le lot bloquerait les vagues suivantes du dépôt (verrou des tests d'acceptation) ; cadence spec green ${rest[0]} lance la commande d'acceptation et pose vert: true`;
+                    if (!values.force)
+                        throw new RafError(`${text} (--force pour passer outre)`);
+                    io.err(`avertissement : ${text}`);
+                }
+            }
             const unreviewed = status === 'done' && plan.reviewSince && !plan.readonly && !values.force ? unreviewedWork(plan, root, rest[0]) : 0;
             plan.setStatus(rest[0], status, today, { force: values.force, unreviewed });
             if (command === 'drop' && values.reason)
@@ -490,6 +519,8 @@ function dispatch(argv, io) {
             return 0;
         }
         case 'spec': {
+            if (green)
+                return specGreen(rest.slice(1), { root, loadPlan, configPath, today }, io);
             if (reseal)
                 return specReseal(rest.slice(1), values.reason, values.porteur, { root, loadPlan, configPath, today }, io);
             if (rest.length !== 2 || (rest[1] !== 'on' && rest[1] !== 'off'))
@@ -701,6 +732,8 @@ function dispatch(argv, io) {
             return deliver(ctx, realDeps(root));
         }
         case 'verify': {
+            if (values.gate)
+                return verifyGateCommand(values, io);
             if (!gitRoot(io.cwd))
                 throw new RafError('verify : à lancer dans un dépôt git');
             if (!existsSync(configPath))
@@ -870,12 +903,23 @@ function preCommit(load, mode, root, today, io) {
             io.err(`raf: plan modifié non commité : démarrage automatique sauté (hook.autostart: start), raf start ${todo.join(' ')} à la main`);
             return 0;
         }
-        for (const id of todo) {
+        for (const id of todo)
             plan.setStatus(id, 'doing', today, {});
-            io.err(`raf: ${id} était todo — raf start ${id} fait par le hook, plan inclus dans ce commit`);
+        try {
+            plan.save();
         }
-        plan.save();
+        catch (e) {
+            if (!(e instanceof RafError))
+                throw e;
+            // plan.onWrite en échec (L346) : le plan est resté tel quel, le commit part sans lui et le dit.
+            io.err(`raf: démarrage automatique refusé : ${e.message} ; raf start ${todo.join(' ')} à la main`);
+            return 0;
+        }
+        for (const id of todo)
+            io.err(`raf: ${id} était todo — raf start ${id} fait par le hook, plan inclus dans ce commit`);
         stage(root, file);
+        for (const f of plan.produced)
+            stage(root, f);
     }
     catch {
         // Un hook ne doit jamais gêner un commit, hors refus.
@@ -1012,7 +1056,7 @@ const git = (cwd, args) => execFileSync('git', args, { cwd, encoding: 'utf8', st
 /** Chemin à coller dans un shell : entre apostrophes dès qu'il contient autre chose que des caractères sûrs. */
 const shellPath = (p) => (/^[\w@%+=:,./-]+$/.test(p) ? p : `'${p.replace(/'/g, "'\\''")}'`);
 /** Le refus de `spec reseal` devant des vagues non terminées (L238) : chaque vague (vivante ou arrêtée), son dossier de lancement, ses lots, et pour chaque vague arrêtée UNE commande à lancer telle quelle (un `--drop` par lot ouvert du dépôt, y compris ceux en file qui ne sont pas en cours au plan : `--resume` relance toute la vague avec les lots non retirés, et un lot en file reprendrait le verrou, L239). */
-function openWavesRefusal(open) {
+function openWavesRefusal(open, command) {
     const lines = open.map((w) => {
         const where = [w.live ? 'vivante' : 'arrêtée', ...(w.live && w.pid !== undefined ? [`pid ${w.pid}`] : []), ...(w.launchDir ? [`lancée depuis ${w.launchDir}`] : [])].join(', ');
         return `  - vague ${w.wave} (${where}) : ${w.lots.length ? [...w.lots.map((l) => `${l.key} (${l.status})`), ...w.others.map((l) => `${l.key} (${l.status}, pas en cours au plan)`)].join(', ') : 'lots illisibles'}`;
@@ -1021,9 +1065,9 @@ function openWavesRefusal(open) {
         ? `  vague ${w.wave} : orchestration en cours, à attendre (le verrou du dépôt tombe dès que tous ses lots y sont prêts ou rendus)`
         : `  cd ${shellPath(w.launchDir)} && ${resumeCommand(w.wave, ...[...w.lots, ...w.others].flatMap((l) => ['--drop', l.key]))}`);
     return [
-        `spec reseal : refusé — ${open.length > 1 ? `${open.length} vagues non terminées gardent` : 'une vague non terminée garde'} ouvert au moins un lot en cours de ce dépôt (un rescellé commité maintenant lui serait rendu comme « premier commit fautif » à la reprise de la vague) :`,
+        `${command} : refusé — ${open.length > 1 ? `${open.length} vagues non terminées gardent` : 'une vague non terminée garde'} ouvert au moins un lot en cours de ce dépôt (${command === 'spec green' ? 'le commit de spec green posé' : 'un rescellé commité'} maintenant lui serait rendu comme « premier commit fautif » à la reprise de la vague) :`,
         ...lines,
-        'Marche à suivre : clore chacun de ces lots dans sa vague (attendre les vivantes, retirer les lots des arrêtées), puis relancer le rescellé :',
+        `Marche à suivre : clore chacun de ces lots dans sa vague (attendre les vivantes, retirer les lots des arrêtées), puis relancer ${command === 'spec green' ? 'spec green' : 'le rescellé'} :`,
         ...how,
     ].join('\n');
 }
@@ -1049,12 +1093,86 @@ function withHolder(open, holder, repo) {
     const keys = openLotsIn(cadenceHome(), holder.pid, repo) ?? [];
     return [{ wave: holder.wave, launchDir: reg?.cwd ?? '', live: true, pid: holder.pid, lots: keys.map((key) => ({ key, status: 'ouvert' })), others: [] }, ...open];
 }
-function specReseal(args, reason, porteur, ctx, io) {
-    if (args.length !== 2 || !reason?.trim())
-        throw new RafError('usage : cadence spec reseal <lot> <test> --reason "pourquoi le test contredit la fiche" [--porteur <lot en cours>, pour un lot livré]');
+/**
+ * `cadence spec green <lot>` (L366) : un lot mené ou clos à la main (raf done) dont l'acceptation est restée à `vert: false` bloque toutes les vagues suivantes du dépôt.
+ * Lance la commande dédiée (`orchestrate.accept`) comme le cycle ; verte, rescelle les tests mis au point depuis le commit rouge (`resealForGreen`), pose `vert: true` et commite le seul fichier, en citant le lot. Rouge : rien n'est changé, code 1.
+ */
+function specGreen(args, ctx, io) {
+    if (args.length !== 1)
+        throw new RafError('usage : cadence spec green <lot>');
     if (io.env.CADENCE_ORCHESTRATED)
-        throw new RafError(`spec reseal refusé pendant une vague orchestrée (${io.env.CADENCE_ORCHESTRATED}) : c'est le travail du lead, hors session`);
-    // Comme `deliver` : la vague tient le verrou du dépôt tant qu'un de ses lots y travaille (état illisible : on refuse) ; un commit du lead en pleine passe ferait signaler au lot suivant un écart qui n'est pas le sien.
+        throw new RafError(`spec green refusé pendant une vague orchestrée (${io.env.CADENCE_ORCHESTRATED}) : c'est le travail du lead, hors session`);
+    refuseWhileWaveHolds(ctx, 'spec green');
+    const lotId = args[0];
+    const plan = ctx.loadPlan();
+    const lot = plan.lot(lotId);
+    if (lot.status === 'todo')
+        throw new RafError(`${lotId} n'est pas commencé (todo) : il n'a rien livré dont l'acceptation puisse passer au vert`);
+    const repo = gitRoot(ctx.root) ?? ctx.root;
+    const config = readOrchestrateConfig(ctx.configPath);
+    if (!config.accept)
+        throw new RafError(`orchestrate.accept absent de ${ctx.configPath} : sans la commande dédiée, il n'y a rien à lancer pour ${lotId}`);
+    const json = findAcceptation(repo, config.spec.dir, lotId);
+    if (!json)
+        throw new RafError(`${lotId} : aucune acceptation sous ${config.spec.dir} (le lot n'a pas passé l'étape accept)`);
+    const doc = parseAcceptation(readFileSync(join(repo, json), 'utf8'));
+    if (typeof doc === 'string')
+        throw new RafError(`${json} : ${doc}`);
+    if (doc.vert) {
+        io.out(`${lotId} : ${json} est déjà vert, rien à faire`);
+        return 0;
+    }
+    const open = unfinishedWaves(ctx.root, repo, plan);
+    if (open.length)
+        throw new RafError(openWavesRefusal(open, 'spec green'));
+    const dirty = git(repo, ['status', '--porcelain', '-z', '--', ...doc.fichiers]).split('\0').filter(Boolean).map((l) => l.slice(3));
+    if (dirty.length)
+        throw new RafError(`${lotId} : test(s) listé(s) modifié(s) sans être commités : ${dirty.join(', ')} — les commiter (en citant ${lotId}) avant de poser vert: true`);
+    const { runs, orphans } = runAcceptation(repo, json, config.accept);
+    if (orphans.length)
+        throw new RafError(`fichiers listés dans ${json} sous la racine d'aucune commande de orchestrate.accept : ${orphans.join(', ')}`);
+    const failed = runs.filter((r) => r.code !== 0);
+    if (failed.length) {
+        io.err(`${lotId} : tests d'acceptation encore rouges (${failed.map((r) => `${r.command}, code ${r.code}`).join(' ; ')}), ${json} reste à vert: false`);
+        for (const r of failed)
+            io.err(r.output.trim().split('\n').slice(-40).join('\n'));
+        return 1;
+    }
+    const before = readFileSync(join(repo, json), 'utf8');
+    let resceles;
+    try {
+        resceles = resealForGreen(repo, json, ctx.today);
+    }
+    catch (e) {
+        throw new RafError(`${lotId} : ${e.message}`);
+    }
+    setVert(repo, json);
+    try {
+        git(repo, ['add', '--', json]);
+        // Le sujet reste court et fixe (le gabarit `plan.commit` du projet s'il y en a un, comme tout commit écrit par cadence, L343) ; les tests rescellés, sans borne, vont dans le corps, une ligne chacun.
+        const template = readPlanConfig(join(repo, 'cadence.yaml'), repo)?.commit;
+        const subject = template ? planCommitMessage(template, { lot: lotId, action: PLAN_ACTIONS.specGreen }) : `chore(${lotId}): ${PLAN_ACTIONS.specGreen}`;
+        const body = resceles.length ? ['empreintes rescellées (tests mis au point depuis le commit rouge) :', ...resceles.map((f) => `- ${f}`)].join('\n') : null;
+        git(repo, ['commit', '-q', '-m', subject, ...(body ? ['-m', body] : []), '--', json]);
+    }
+    catch (e) {
+        // Atomique, comme le rescellé : un commit refusé (hook pre-commit, ...) laisse le fichier tel qu'avant.
+        writeFileSync(join(repo, json), before);
+        try {
+            git(repo, ['reset', '-q', '--', json]);
+        }
+        catch {
+            // rien d'indexé : rien à défaire
+        }
+        const out = e;
+        throw new RafError(`spec green : le commit a échoué, ${json} est revenu tel qu'avant la commande — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
+    }
+    io.out(`${lotId} : ${json} → vert: true, commit ${git(repo, ['rev-parse', '--short', 'HEAD']).trim()}${resceles.length ? ` ; empreintes rescellées (tests mis au point depuis le commit rouge) : ${resceles.join(', ')}` : ''}`);
+    return 0;
+}
+/** Un commit du lead en pleine passe ferait signaler au lot suivant un écart qui n'est pas le sien : tant qu'une vague tient le verrou du dépôt, `spec reseal` et `spec green` refusent. */
+function refuseWhileWaveHolds(ctx, command) {
+    // Comme `deliver` : la vague tient le verrou du dépôt tant qu'un de ses lots y travaille (état illisible : on refuse).
     // Le refus est UN message : la vague vivante qui tient le verrou (à attendre) et les vagues arrêtées du dépôt, avec leurs dossiers et leurs commandes (L238).
     const orchestrating = waveHolding(ctx.root);
     if (orchestrating) {
@@ -1066,8 +1184,15 @@ function specReseal(args, reason, porteur, ctx, io) {
         catch {
             // plan illisible : le verrou seul motive le refus, la vague qui le tient est nommée
         }
-        throw new RafError(openWavesRefusal(withHolder(open, orchestrating, repo)));
+        throw new RafError(openWavesRefusal(withHolder(open, orchestrating, repo), command));
     }
+}
+function specReseal(args, reason, porteur, ctx, io) {
+    if (args.length !== 2 || !reason?.trim())
+        throw new RafError('usage : cadence spec reseal <lot> <test> --reason "pourquoi le test contredit la fiche" [--porteur <lot en cours>, pour un lot livré]');
+    if (io.env.CADENCE_ORCHESTRATED)
+        throw new RafError(`spec reseal refusé pendant une vague orchestrée (${io.env.CADENCE_ORCHESTRATED}) : c'est le travail du lead, hors session`);
+    refuseWhileWaveHolds(ctx, 'spec reseal');
     const [lotId, test] = args;
     const plan = ctx.loadPlan();
     const lot = plan.lot(lotId);
@@ -1096,7 +1221,7 @@ function specReseal(args, reason, porteur, ctx, io) {
     // Le verrou du rescellé couvre tous les lots ouverts du dépôt, pas seulement le porteur : on refuse dès qu'un lot DE CE DÉPÔT, encore en cours au plan, reste ouvert dans une vague non terminée.
     const open = unfinishedWaves(ctx.root, repo, plan);
     if (open.length)
-        throw new RafError(openWavesRefusal(open));
+        throw new RafError(openWavesRefusal(open, 'spec reseal'));
     const before = { json: readFileSync(join(repo, json), 'utf8'), test: existsSync(join(repo, test)) ? readFileSync(join(repo, test), 'utf8') : '' };
     let r;
     try {
@@ -1130,14 +1255,23 @@ function specReseal(args, reason, porteur, ctx, io) {
         return 0;
     }
     plan.note(cite, `test d'acceptation rescellé${livre ? ` (lot livré ${lotId}, ` : ' ('}${norm}, ${r.ficheAmendee ? `fiche amendée en ${r.ficheAmendee}` : 'fiche inchangée'}) : ${reason.trim()}`, ctx.today);
-    plan.save();
+    try {
+        plan.save();
+    }
+    catch (e) {
+        // Le rescellé est commité (sha) : seul le plan est refusé (plan.onWrite en échec), il reste inchangé et la note n'est pas écrite ; dire « écriture refusée » seul laisserait croire que rien n'a été fait.
+        throw new RafError(`spec reseal : le rescellé a eu lieu (commit ${sha}) mais la note du lot n’a pas été écrite, le plan est inchangé — ${e.message} — relancer la commande dit « rien à resceller » : ajouter la note à la main (raf note ${cite}) une fois le plan réparé`);
+    }
     // La note du lot rejoint le dépôt dans la foulée (un dépôt sale arrêterait la vague suivante) ; un plan hors du dépôt ou non suivi reste à la main du lead.
     const planRel = relative(repo, plan.path);
+    const produced = plan.produced;
     const tracked = !planRel.startsWith('..') && git(repo, ['ls-files', '--', planRel]).trim() !== '';
     if (tracked) {
         try {
-            git(repo, ['add', '--', planRel]);
-            git(repo, ['commit', '-q', '-m', `plan: ${cite} test d'acceptation rescellé (${norm})`, '--', planRel]);
+            // Les fichiers de plan.onWrite (L346) partent avec la note : la commande a tourné à l'écriture du plan.
+            const withPlan = [planRel, ...(produced.length ? dirtyPaths(repo, produced) : [])];
+            git(repo, ['add', '--', ...withPlan]);
+            git(repo, ['commit', '-q', '-m', planCommitMessage(readPlanConfig(join(repo, 'cadence.yaml'), repo)?.commit, { lot: cite, action: PLAN_ACTIONS.resealed(norm) }), '--', ...withPlan]);
         }
         catch (e) {
             // Le rescellé est fait (commit ${sha}) : on ne le défait pas, on dit où en est la note, au lieu d'une pile d'appels.
@@ -1294,6 +1428,26 @@ function perf(rest, values, today, io) {
         return 1;
     }
 }
+/** `verify --gate --sha rév [--project dossier]` (L348) : la porte du projet rejouée au sha ; `--project` est un sous-dossier du dossier courant qui a son propre dépôt. */
+async function verifyGateCommand(values, io) {
+    if (values.sha === undefined)
+        throw new RafError('verify --gate : --sha obligatoire (le sha à re-vérifier, jamais la tête mouvante d\'une vague)');
+    if (values.retry !== undefined)
+        throw new RafError('verify --gate : --retry ne va qu\'à verify seul (deliver.verify)');
+    const dir = values.project === undefined ? io.cwd : resolve(io.cwd, values.project);
+    if (values.project !== undefined && !existsSync(dir))
+        throw new RafError(`verify --gate : --project ${values.project} : dossier introuvable sous ${io.cwd}`);
+    const top = gitRoot(dir);
+    if (!top)
+        throw new RafError('verify --gate : à lancer dans un dépôt git (ou --project vers le dossier d\'un projet)');
+    if (values.project !== undefined && realpathSync(top) !== realpathSync(dir))
+        throw new RafError(`verify --gate : ${values.project} n'a pas son propre dépôt git (dépôt parent : ${top})`);
+    const configPath = resolve(io.cwd, values.config ?? join(top, 'cadence.yaml'));
+    const sha = resolveCommit(top, values.sha);
+    if (!sha)
+        throw new RafError(`verify --gate : --sha ${values.sha} : commit introuvable dans ${top}`);
+    return verifyGate({ repo: top, sha, config: readOrchestrateConfig(configPath), out: io.out });
+}
 /** `session start|close --all [--depth n]` : la commande jouée dans chaque projet sous le dossier courant, une section par projet. */
 async function sessionAll(rest, values, io) {
     const sub = rest[0];

package/dist/config-set.js

@@ -5,7 +5,7 @@ import { basename, dirname, join, relative, resolve } from 'node:path';
 import { isNode, isScalar, parse, parseDocument } from 'yaml';
 import { defaultPlan, readDocsConfig, readHookConfig, readMigrateConfig, readNewsConfig, readOrchestrateConfig, readPerfConfig, readPlanConfig, readReferencesConfig, readSessionConfig } from './config.js';
 import { parseDeliverConfig } from './deliver.js';
-import { commitPaths, dirtyPaths, gitRoot } from './git.js';
+import { commitPaths, dirtyPaths, gitRoot, restorePaths } from './git.js';
 import { findProjects, isProject, readDepth, readLeadUx } from './lead.js';
 import { readPriority } from './orchestrate/continue.js';
 import { Plan, RafError } from './plan.js';
@@ -194,7 +194,8 @@ export function configSet(parent, key, valueText, opts, today) {
             skip(`pas de plan à ${planRel}`);
             continue;
         }
-        const dirty = dirtyPaths(dir, ['cadence.yaml', planRel]);
+        const produced = found.settings.onWrite?.files ?? [];
+        const dirty = dirtyPaths(dir, ['cadence.yaml', planRel, ...produced]);
         if (dirty.length) {
             skip(`${dirty.join(', ')} non commité : le commit à chemin explicite l'emporterait`);
             continue;
@@ -205,7 +206,9 @@ export function configSet(parent, key, valueText, opts, today) {
             continue;
         }
         const planBefore = readFileSync(planPath, 'utf8');
+        // Ce que plan.onWrite produit est propre ici (vérifié plus haut) : le défaire, c'est le remettre à HEAD.
         const restore = () => {
+            restorePaths(dir, produced);
             if (before === null) {
                 if (existsSync(configFile))
                     unlinkSync(configFile);
@@ -229,7 +232,7 @@ export function configSet(parent, key, valueText, opts, today) {
                 plan.setStatus(id, 'doing', today);
                 plan.save();
             }
-            const sha = commitPaths(dir, ['cadence.yaml', planRel], `chore${id ? `(${id})` : ''}: cadence.yaml — ${key} = ${shown}`);
+            const sha = commitPaths(dir, ['cadence.yaml', planRel, ...(produced.length ? dirtyPaths(dir, produced) : [])], `chore${id ? `(${id})` : ''}: cadence.yaml — ${key} = ${shown}`);
             done++;
             lines.push(`✓ ${name} · ${id || 'lot de config'} · ${key} = ${shown} · commit ${sha}`);
         }

package/dist/config.js

@@ -1,11 +1,14 @@
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
 import { parse } from 'yaml';
 import { isDay } from './dates.js';
 import { DEFAULT_TEST_PATTERNS } from './testgate.js';
 import { gitRoot } from './git.js';
+import { planCommitProblem } from './plan-commit.js';
+import { isComposedGate } from './orchestrate/workers.js';
 import { FIELDS, Plan, RafError, STATUSES } from './plan.js';
-const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add'];
+const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit'];
+const ON_WRITE_KEYS = ['command', 'files'];
 const FORMAT_KEYS = ['lots', 'fields', 'statuses', 'estimates'];
 const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const list = (v) => (v == null ? [] : Array.isArray(v) ? v.map(String) : [String(v)]);
@@ -42,6 +45,25 @@ function readQa(qa, file, workRoot) {
         throw new RafError(`${file} : qa.expectations « ${v.trim()} » est hors du dépôt`);
     return rel;
 }
+/** Clé `plan.onWrite` (L346) : la commande qui republie le plan après chaque écriture, lancée dans `cwd` (la racine du dépôt), et les fichiers qu'elle produit (relatifs au dépôt, jamais hors de lui). */
+function readOnWrite(v, cwd, bad) {
+    if (!isObject(v))
+        throw bad('onWrite doit être un objet { command, files }');
+    for (const k of Object.keys(v))
+        if (!ON_WRITE_KEYS.includes(k))
+            throw bad(`onWrite.${k} inconnu (attendu : ${ON_WRITE_KEYS.join(', ')})`);
+    if (typeof v.command !== 'string' || v.command.trim() === '')
+        throw bad('onWrite.command doit être une commande');
+    const files = list(v.files).map((f) => {
+        const rel = posix.normalize(f.trim().replace(/\\/g, '/'));
+        if (rel === '.' || rel === '..' || rel.startsWith('../') || isAbsolute(rel))
+            throw bad(`onWrite.files « ${f} » est hors du dépôt`);
+        if (existsSync(resolve(cwd, rel)) && statSync(resolve(cwd, rel)).isDirectory())
+            throw bad(`onWrite.files « ${f} » est un dossier (déclarer les fichiers produits, pas leur dossier)`);
+        return rel;
+    });
+    return { command: v.command, files, cwd };
+}
 /**
  * Clé `plan:` de cadence.yaml : où est le plan et, s'il est tenu par un autre outil, comment le lire.
  * `root` : la racine du dépôt de travail (celle du CLI), d'où se résout un chemin absolu de `qa.expectations`.
@@ -84,13 +106,20 @@ export function readPlanConfig(file, root) {
         settings.ignore = list(p.ignore);
     if (p.files != null)
         settings.files = list(p.files);
+    if (p.onWrite != null)
+        settings.onWrite = readOnWrite(p.onWrite, root ?? dirname(resolve(file)), bad);
     if (FORMAT_KEYS.some((k) => p[k] != null))
         settings.format = parseFormat(p, bad);
     if (p.path != null && String(p.path).trim() === '')
         throw bad('path est vide');
     if (p.add != null && (typeof p.add !== 'string' || !p.add.includes('{title}')))
         throw bad('add doit être une commande qui contient {title}');
-    return { ...(p.path != null ? { path: String(p.path) } : {}), ...(p.add != null ? { add: String(p.add) } : {}), settings };
+    if (p.commit != null) {
+        const problem = typeof p.commit === 'string' ? planCommitProblem(p.commit) : 'doit être un gabarit de message';
+        if (problem)
+            throw bad(`commit ${problem}`);
+    }
+    return { ...(p.path != null ? { path: String(p.path) } : {}), ...(p.add != null ? { add: String(p.add) } : {}), ...(p.commit != null ? { commit: String(p.commit) } : {}), settings };
 }
 export const PLAN_DEFAULT = '.cadence/raf.yaml';
 export const PLAN_LEGACY = 'docs/plan/raf.yaml';
@@ -283,9 +312,8 @@ export function readSessionConfig(file) {
 }
 const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
 export const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'fix', 'review', 'ux'];
-const MODELS = ['haiku', 'sonnet', 'opus'];
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeDeps', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
     const config = { precheck: true, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, worktrees: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
@@ -320,7 +348,7 @@ export function readOrchestrateConfig(file) {
             throw bad('accept : commande non vide attendue (chaîne ou liste de commandes non vides)');
         config.accept = o.accept.map((x) => x.trim());
     }
-    for (const k of ['start', 'verdict', 'test', 'build', 'accept']) {
+    for (const k of ['start', 'verdict', 'test', 'testReplay', 'build', 'accept']) {
         if (k === 'accept' && Array.isArray(o.accept))
             continue;
         if (o[k] == null)
@@ -329,6 +357,16 @@ export function readOrchestrateConfig(file) {
             throw bad(`${k} : commande non vide attendue`);
         config[k] = o[k].trim();
     }
+    if (config.testReplay && !config.testReplay.includes('{files}'))
+        throw bad('testReplay : la commande doit contenir {files} (remplacé par les fichiers des tests rouges)');
+    if (config.testReplay && config.test && isComposedGate(config.test))
+        throw bad('testReplay : refusé quand orchestrate.test est une porte composée (&&, ||, sous-shell) : le rejeu seul ne vaut que pour un lanceur unique');
+    if (o.worktreeDeps != null) {
+        const deps = o.worktreeDeps;
+        if (!Array.isArray(deps) || !deps.length || deps.some((x) => typeof x !== 'string' || !x.trim() || isAbsolute(x) || x.split(/[\\/]/).includes('..')))
+            throw bad('worktreeDeps : liste de chemins relatifs au dépôt, sans « .. » (node_modules, .venv…)');
+        config.worktreeDeps = deps.map((x) => x.trim().replace(/\/$/, ''));
+    }
     if (o.maquette != null) {
         if (typeof o.maquette !== 'boolean')
             throw bad('maquette : true ou false attendu');
@@ -418,9 +456,9 @@ export function readOrchestrateConfig(file) {
             const m = o.review[k];
             if (m == null)
                 continue;
-            if (!MODELS.includes(m))
-                throw bad(`review.${k} : ${MODELS.join(', ')} attendu`);
-            config.review[k] = m;
+            if (typeof m !== 'string' || !m.trim())
+                throw bad(`review.${k} : nom de modèle non vide attendu (haiku, sonnet, opus ou un nom passé tel quel à claude --model)`);
+            config.review[k] = m.trim();
         }
     }
     if (o.escalation != null) {

package/dist/corrections.js

@@ -121,6 +121,7 @@ export function readJournals(runsDir, until, since) {
                 ...(typeof rec.escalationReserve === 'number' ? { escalationReserve: rec.escalationReserve } : {}),
                 ...(precheck ? { precheck } : {}),
                 ...(escalation ? { escalation } : {}),
+                ...(Array.isArray(rec.instables) && rec.instables.some((t) => typeof t === 'string') ? { instables: rec.instables.filter((t) => typeof t === 'string') } : {}),
                 ...(Array.isArray(rec.warnings) && rec.warnings.some((w) => typeof w === 'string' && w.startsWith(LOCAL_PRECHECK_UNREADABLE)) ? { localUnreadable: true } : {}),
                 steps: steps.map((s) => {
                     const usage = usageOf(s.tokens);

package/dist/git.js

@@ -1,4 +1,5 @@
 import { execFileSync } from 'node:child_process';
+import { rmSync } from 'node:fs';
 import { basename, dirname, resolve } from 'node:path';
 function git(cwd, args) {
     // Le journal complet d'un gros dépôt dépasse le Mo par défaut : sans marge, il serait lu comme vide.
@@ -110,7 +111,7 @@ export function fileAt(cwd, rev, file) {
         return null;
     }
 }
-function tryGit(cwd, args) {
+export function tryGit(cwd, args) {
     try {
         return git(cwd, args).trim();
     }
@@ -230,6 +231,15 @@ export function commitPaths(root, paths, message) {
     }
     return tryGit(root, ['rev-parse', '--short', 'HEAD']) ?? '';
 }
+/** Remet `paths` comme à HEAD : un fichier suivi retrouve sa version commitée, un fichier que HEAD ne connaît pas est supprimé. */
+export function restorePaths(root, paths) {
+    for (const f of paths) {
+        if (tryGit(root, ['cat-file', '-e', `HEAD:${f}`]) !== null)
+            git(root, ['checkout', '-q', 'HEAD', '--', f]);
+        else
+            rmSync(resolve(root, f), { force: true });
+    }
+}
 /** Un fichier SUIVI est-il modifié (indexé ou non) ? Les fichiers non suivis ne comptent pas : un commit à chemins explicites ne les embarque pas. `except` : chemins qu'on ne compte pas. */
 export function hasTrackedChanges(cwd, except = []) {
     return git(cwd, ['status', '--porcelain', '--untracked-files=no', '--', '.', ...except.map((f) => `:(exclude)${f}`)]).trim() !== '';