@sylad/cadence 1.0.0 → 1.2.0

package/dist/orchestrate/cycle.js

@@ -1,21 +1,27 @@
 import { execFileSync, spawn } from 'node:child_process';
+import { parse } from 'yaml';
 import { toolBinOf, withoutLaunchVars } from './snapshot.js';
 import { randomUUID } from 'node:crypto';
-import { dirname, join, relative } from 'node:path';
-import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { coveredTasks, lotCommits, lotWork } from '../audit.js';
 import { readDocsConfig } from '../config.js';
 import { docSyncBrief, docSyncGaps, filesOf } from '../docsync.js';
-import { readCommits, resolveCommit } from '../git.js';
+import { changedFiles, readCommits, resolveCommit } from '../git.js';
 import { citedRefs } from '../link.js';
 import { repoShas, repoWork } from '../repos.js';
 import { isOpen } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
-import { capturesText, newsText, objective, renderBrief, reposText } from './briefs.js';
+import { capturesText, newsText, objective, renderBrief, reposText, TEMPLATES_DIR } from './briefs.js';
 import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig } from './launch.js';
 import { cleanPlaywrightOutput, pushed, snapshot } from './guard.js';
-import { checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, WORK_SCHEMA } from './schemas.js';
+import { ACCEPT_SCHEMA, checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, WORK_SCHEMA } from './schemas.js';
+import { acceptationFile, acceptCommands, isAcceptList, acceptText, checkAcceptation, findAcceptation, isAcceptationFile, lockViolations, lotStartHead, parseAcceptation, planAcceptRuns, redSha, resealedRouge, sealAcceptation, setVert } from './accept.js';
+import { avalFicheText, ficheContracts, ficheRules, hasScreenPart } from './aval.js';
+import { ficheReviewText, reviewedSheetText } from './fiche.js';
+import { bulletLines, maquetteText, reviewedText } from './maquette.js';
+import { answeredText, checkSpec, costlyHypotheses, ficheHasBack, ficheReady, findFiche, hypothesisLines, hypothesisNote, specText } from './spec.js';
 import { lotKey, lotRepoPaths, neighbourDirs } from './state.js';
 /** Passes de correction au plus, puis la main est rendue au lead. */
 export const MAX_PASSES = 2;
@@ -78,10 +84,13 @@ async function commitPlan(c, message) {
     const repo = c.lot.repo;
     const plan = c.loadPlan();
     const own = new Set([relative(repo, plan.path), ...plan.maintained]);
+    // Les acceptation.json (L173) rejoignent les fichiers que le cycle a le droit de commiter : il y pose le scellé et `vert: true`.
+    const specDir = `${c.config.spec.dir.replace(/\/+$/, '')}/`;
+    const ownFile = (f) => own.has(f) || (f.startsWith(specDir) && isAcceptationFile(f));
     const dirty = trackedPaths(await snapshot(repo, { remote: false }));
     if (dirty.length === 0)
         return null;
-    const foreign = dirty.filter((f) => !own.has(f));
+    const foreign = dirty.filter((f) => !ownFile(f));
     if (foreign.length)
         return `arbre sale (fichiers hors plan) : ${foreign.join(', ')}`;
     git(repo, 'add', '--', ...dirty);
@@ -90,9 +99,9 @@ async function commitPlan(c, message) {
 }
 const shEscape = (s) => s.replace(/\s+/g, ' ').replace(/[\\"$`]/g, '\\$&');
 /** Commande du projet, asynchrone : la boucle d'événements reste libre (délai de l'autre créneau, signaux). Son groupe est tué au délai et au signal. */
-function sh(c, command, timeoutMs = 30 * 60_000) {
+function sh(c, command, timeoutMs = 30 * 60_000, env = {}) {
     return new Promise((resolve) => {
-        const child = spawn('sh', ['-c', command], { cwd: c.lot.repo, env: withoutLaunchVars(process.env), stdio: ['ignore', 'pipe', 'pipe'], detached: true });
+        const child = spawn('sh', ['-c', command], { cwd: c.lot.repo, env: { ...withoutLaunchVars(process.env), ...env }, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
         const pid = child.pid;
         if (pid === undefined) {
             child.once('error', (e) => resolve({ code: 127, output: String(e.message) }));
@@ -209,23 +218,132 @@ function docsText(c) {
     return docSyncBrief(sync, docSyncGaps(sync, filesOf(c.lot.repo, lotWork(plan, c.lot.repo, c.lot.lot))));
 }
 /** Gabarit d'une étape : la passe des mineurs et la revue courte qui la suit ont chacune le leur. */
-function briefName(l, kind) {
+export function briefName(l, kind) {
+    if (l.specLot && !l.screen && (kind === 'spec' || kind === 'accept'))
+        return `${kind}-back`;
     if (kind === 'fix' && l.minorFix)
         return 'fix-minors';
     if (kind === 'review-small' && l.minorPass && !(l.small && l.visible))
         return 'review-recheck';
     return kind;
 }
+/** Gabarit de fiche livré avec le paquet, joint au brief de la spec (la session ne lit pas le dossier du paquet). */
+function ficheTemplate() {
+    try {
+        return readFileSync(join(TEMPLATES_DIR, '..', 'fiche.yaml'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Gabarit de la partie back de la fiche (L187), joint au brief de la spec d'un lot `spec: true`. */
+function ficheBackTemplate() {
+    try {
+        return readFileSync(join(TEMPLATES_DIR, '..', 'fiche-back.yaml'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Le lot passe par l'étape spec : il déclare `screen:` (écran) ou `spec: true` (comportement sans écran, L188). */
+const hasSpecStage = (l) => !!(l.screen || l.specLot);
+/**
+ * Les parties que la fiche du lot doit avoir : l'écran d'un lot à `screen:`, le sujet d'un lot à `spec: true` (sans écran). Un lot mixte est un lot
+ * `screen:` dont la FICHE a une partie back (bloc `sujet`, décision du lead) : la fiche écrite le dit, pas un champ du plan.
+ */
+const partsOf = (l, fiche) => ({ screen: !!l.screen, back: !!l.specLot || (!!l.screen && !!fiche && ficheHasBack(l.repo, fiche)) });
+/** Gabarit du lanceur de tests livré avec le paquet, joint au brief de l'étape accept. */
+function acceptRunner() {
+    try {
+        return readFileSync(join(TEMPLATES_DIR, '..', 'acceptation-runner.mjs'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Fiche du lot : celle de l'étape spec, ou la fiche retrouvée dans le dépôt (reprise). */
+function ficheOf(c) {
+    const l = c.lot;
+    return l.spec && 'fiche' in l.spec ? l.spec.fiche : findFiche(l.repo, c.config.spec.dir, l.lot);
+}
+/**
+ * Consigne de la fiche pour les étapes en aval d'un lot qui en a une (L174) : implement, fix, revue de code, UX de conformité.
+ * Vide quand le lot n'a pas de fiche (sous le seuil, ou pas encore écrite) ou qu'elle est illisible.
+ */
+function avalOf(c, kind) {
+    const l = c.lot;
+    const step = kind === 'implement' || kind === 'fix' || kind === 'ux' ? kind : kind === 'review' || kind === 'review-small' ? 'review' : null;
+    const fiche = step ? ficheOf(c) : null;
+    if (!step || !fiche)
+        return '';
+    let rules;
+    let contracts;
+    let screen;
+    try {
+        const doc = parse(readFileSync(join(l.repo, fiche), 'utf8'));
+        rules = ficheRules(doc);
+        contracts = ficheContracts(doc);
+        screen = hasScreenPart(doc);
+    }
+    catch {
+        return '';
+    }
+    if (!rules.length || (step === 'ux' && !screen))
+        return '';
+    const acceptation = l.accept?.acceptation ?? findAcceptation(l.repo, c.config.spec.dir, l.lot) ?? undefined;
+    const o = { fiche, rules, acceptation, rouge: l.accept?.rouge, contracts, screen };
+    const text = avalFicheText(step, o);
+    // la revue courte d'un petit lot visible est sa seule passe : elle porte aussi la conformité à la maquette
+    return kind === 'review-small' && l.small && l.visible && screen ? `${text}\n${avalFicheText('ux', o)}` : text;
+}
 function briefFor(c, kind) {
     const plan = c.loadPlan();
     const l = c.lot;
     const lot = plan.lot(l.lot);
-    const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []) };
+    const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []) };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
         vars.news = newsText(l.lot, pwDir);
         vars.captures = capturesText(pwDir);
     }
+    vars.fiche = hasSpecStage(l) ? avalOf(c, kind) : '';
+    if (kind === 'spec') {
+        const reviewed = [...(l.ficheConstats ?? []), ...(l.maquetteConstats ?? [])];
+        const written = ficheOf(c);
+        const back = partsOf(l, written).back;
+        vars.spec = specText({
+            dir: c.config.spec.dir,
+            render: c.config.spec.render,
+            screen: l.screen,
+            back,
+            problems: l.specProblems,
+            review: !reviewed.length ? undefined : back ? reviewedSheetText(reviewed, !!l.screen) : reviewedText(reviewed),
+            template: l.screen ? ficheTemplate() : undefined,
+            templateBack: back || l.screen ? ficheBackTemplate() : undefined,
+        });
+        const mine = lotCommitLines(c);
+        if (mine)
+            vars.commits = `Commits of the lot already present (do not redo them; fix or complete the spec from them):\n${mine}`;
+        if (l.pendingAnswer)
+            vars.reponse = l.specAsked?.length ? answeredText(l.specAsked, l.pendingAnswer) : `Answer from the human to your earlier question: ${l.pendingAnswer}`;
+    }
+    if (kind === 'fiche') {
+        vars.fiche = ficheReviewText({ fiche: ficheOf(c) ?? '', passes: l.fiche?.passes ?? 0, previous: l.ficheConstats });
+        vars.reponse = '';
+    }
+    if (kind === 'maquette') {
+        vars.maquette = maquetteText({ fiche: ficheOf(c) ?? '', passes: l.maquette?.passes ?? 0, previous: l.maquetteConstats });
+        vars.reponse = '';
+    }
+    if (kind === 'accept') {
+        const fiche = ficheOf(c) ?? '';
+        const folder = posix.dirname(fiche);
+        vars.accept = acceptText({ fiche, maquette: `${folder}/maquette.html`, screen: !!l.screen, back: !!l.screen && partsOf(l, fiche).back, acceptation: acceptationFile(fiche, l.lot), command: c.config.accept ?? '', test: c.config.test, runner: acceptRunner(), problems: l.acceptProblems });
+        vars.objectif = ''; // l'oracle est écrit depuis la fiche et la maquette seules, pas depuis le texte du lot
+        vars.commits = '';
+        if (l.pendingAnswer)
+            vars.reponse = `Answer from the human to your earlier question: ${l.pendingAnswer}`;
+    }
     if (kind === 'implement' || kind === 'fix') {
         const interrupted = [...l.steps].reverse().find((s) => s.kind === kind && s.status === 'interrupted');
         if (kind === 'fix') {
@@ -303,11 +421,11 @@ async function session(c, kind, local = false) {
     const halt = halted(w, l);
     if (halt)
         return suspend(c, halt);
-    const write = kind === 'implement' || kind === 'fix';
+    const write = kind === 'implement' || kind === 'fix' || kind === 'spec' || kind === 'accept';
     // Le budget du lot borne l'écriture, jamais la revue (L145) : une revue est jouée dès que le code est à relire (sauf tests rouges après une écriture, cf. REVIEW_RESERVE), la passe fix réserve son coût.
     if (write && (lotOver(l) || (kind === 'fix' && !fixAffordable(l))))
         return overBudget(c, kind === 'fix' && !lotOver(l));
-    const model = write ? l.model : local ? 'local' : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
+    const model = kind === 'spec' || kind === 'accept' || kind === 'fiche' ? 'sonnet' : write ? l.model : local ? 'local' : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
     const effort = c.config.effort[kind === 'review-small' ? 'review' : kind];
     const before = await snapshot(l.repo);
     const neighbours = l.repos ?? [];
@@ -316,7 +434,7 @@ async function session(c, kind, local = false) {
     const sessionId = randomUUID();
     const step = { n, kind, model, ...(effort !== 'default' ? { effort } : {}), status: 'running', sessionId, started: new Date().toISOString(), headBefore: before.head ?? undefined };
     l.steps.push(step);
-    const label = { implement: 'implementing', fix: 'fixing', review: 'reviewing', ux: 'reviewing', 'review-small': 'reviewing', precheck: 'implementing' };
+    const label = { implement: 'implementing', fix: 'fixing', review: 'reviewing', ux: 'reviewing', 'review-small': 'reviewing', precheck: 'implementing', spec: 'implementing', accept: 'implementing', maquette: 'reviewing', fiche: 'reviewing' };
     transition(c, label[kind]);
     w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} (${model})`);
     let brief;
@@ -328,8 +446,8 @@ async function session(c, kind, local = false) {
         step.cause = e.message;
         return stop(c, 'failed', `brief de ${kind} : ${e.message}`);
     }
-    const mcpConfig = writeMcpConfig(w.store.lotDir(l.project, l.lot), kind, l.visible, l.small);
-    const playwright = !!mcpServersFor(kind, l.visible, '', l.small).playwright;
+    const mcpConfig = writeMcpConfig(w.store.lotDir(l.project, l.lot), kind, l.visible, l.small, !!l.screen);
+    const playwright = !!mcpServersFor(kind, l.visible, '', l.small, !!l.screen).playwright;
     if (playwright)
         l.uxCaptures = join(dirname(mcpConfig), 'playwright');
     l.pendingAnswer = null; // la réponse est dans le brief : elle ne repart pas avec la session suivante
@@ -341,10 +459,11 @@ async function session(c, kind, local = false) {
         effort,
         local,
         schema: schemaFor(kind),
-        agent: kind === 'ux' ? 'ux-reviewer' : kind === 'precheck' ? 'precheck-reader' : write ? undefined : 'code-reviewer',
+        agent: kind === 'spec' ? 'spec-writer' : kind === 'accept' ? 'acceptance-writer' : kind === 'ux' || kind === 'maquette' ? 'ux-reviewer' : kind === 'precheck' ? 'precheck-reader' : write ? undefined : 'code-reviewer',
         cwd: l.repo,
         wave: w.id,
         permissionMode: c.config.permissionMode,
+        prodAccess: c.config.prodAccess,
         addDirs: [...c.config.addDirs, ...(playwright && write ? [playwrightDir(dirname(mcpConfig))] : []), ...neighbourDirs(l)],
         nodeBin: l.node?.link,
         toolBin: toolBinOf(w.store.dir),
@@ -556,7 +675,8 @@ function overBudget(c, reserve = false) {
     const l = c.lot;
     // Une réponse du lead encore en attente n'a pas été consommée : elle ne doit pas se perdre sans qu'on le dise.
     const answer = l.pendingAnswer ? ` ; la réponse du lead (« ${l.pendingAnswer} ») n'a pas été jouée` : '';
-    const why = reserve ? `budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés (dérivé de l'estimate), il ne reste pas de quoi payer la revue qui suivrait la correction (${REVIEW_RESERVE} réservés)` : `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, dérivé de l'estimate)`;
+    const basis = hasSpecStage(l) ? 'estimate et étape spec' : "dérivé de l'estimate";
+    const why = reserve ? `budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés (${basis}), il ne reste pas de quoi payer la revue qui suivrait la correction (${REVIEW_RESERVE} réservés)` : `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, ${basis})`;
     // Tests rouges après une écriture : la passe fix refusée aurait suivi, le lot revient sans revue (L145) — la cause le dit.
     const red = l.next === 'fix' && l.constats.some((k) => k.source === 'tests');
     // Passe d'écriture qui vient d'être jouée, nommée d'après le compteur : l.pass - 1 passes de correction l'ont précédée (minorPass reste vrai après la passe des mineurs).
@@ -641,7 +761,7 @@ async function precheck(c) {
         }
         catch (e) {
             l.warnings.push(`contrôle préalable illisible, implémentation lancée : ${e.message}`);
-            l.next = 'implement';
+            l.next = firstWrite(c);
             save(c);
             return;
         }
@@ -664,9 +784,480 @@ async function precheck(c) {
         l.precheck = `A pre-check found part of the deliverable already in the repository (do not redo it): ${rep.resume.trim()}${proofs}`;
         l.warnings.push(`contrôle préalable : livrable en partie présent — ${rep.resume.trim()}${proofs}`);
     }
+    l.next = firstWrite(c);
+    save(c);
+}
+/** Première session d'écriture d'un lot : la spec quand il déclare `screen:` ou `spec: true` et qu'aucune fiche n'est écrite, sinon l'implémentation. */
+function firstWrite(c) {
+    const l = c.lot;
+    if (!hasSpecStage(l) || l.spec)
+        return 'implement';
+    const fiche = findFiche(l.repo, c.config.spec.dir, l.lot);
+    return fiche && ficheReady(l.repo, fiche, l.lot, partsOf(l, fiche)) ? afterSpec(c, fiche) : 'spec';
+}
+const NO_TEST_ACCEPT = 'étape accept : orchestrate.test absent, rien ne prouve que les tests rouges sont exclus du lanceur de tests et de la CI (vérifier à la main la config du lanceur avant de livrer)';
+const NO_ACCEPT = 'étape accept ignorée : orchestrate.accept absent (commande dédiée aux tests d\'acceptation), le lot passe de spec à implement sans tests rouges';
+/**
+ * Étape qui suit une spec écrite : la revue UX de la maquette (S4) tant qu'elle n'est pas conforme (`orchestrate.maquette`), sauf si une
+ * acceptation conforme est déjà commitée (elle n'a pu être écrite qu'après la revue) ; puis les tests d'acceptation rouges (S5).
+ */
+function afterSpec(c, fiche) {
+    const l = c.lot;
+    // Revue de la fiche back (L188) d'abord, puis celle de la maquette d'un lot mixte ; la même preuve (acceptation scellée, code déjà commité) dispense des deux.
+    if (c.config.fiche && partsOf(l, fiche).back && !l.fiche?.conforme && !acceptationProof(c, fiche) && !codeAfterFiche(c, fiche))
+        return 'fiche';
+    return afterFiche(c, fiche);
+}
+/** Étape qui suit une fiche relue : la revue UX de la maquette d'un lot à écran (S4), sinon `afterMaquette`. */
+function afterFiche(c, fiche) {
+    const l = c.lot;
+    if (l.screen && c.config.maquette && !l.maquette?.conforme && !acceptationProof(c, fiche) && !codeAfterFiche(c, fiche))
+        return 'maquette';
+    return afterMaquette(c, fiche);
+}
+/** Étape qui suit une maquette relue (ou une fiche, pour un lot sans écran) : les tests d'acceptation rouges (S5) quand le projet déclare sa commande dédiée et qu'aucune acceptation conforme n'est déjà commitée, sinon l'implémentation. */
+function afterMaquette(c, fiche) {
+    const l = c.lot;
+    // Des constats de la revue de fiche attendent la revue de la maquette (lot mixte) : les deux partent ensemble à la seconde passe `spec`.
+    if (l.ficheConstats?.length)
+        return 'spec';
+    if (!c.config.accept) {
+        if (!l.warnings.includes(NO_ACCEPT))
+            l.warnings.push(NO_ACCEPT);
+        return 'implement';
+    }
+    const json = lotAcceptation(c, fiche);
+    if (acceptationProof(c, fiche)) {
+        l.accept = { acceptation: json, rouge: redSha(l.repo, json) ?? '' };
+        return 'implement';
+    }
+    return 'accept';
+}
+/** Le lot a déjà du code commité après sa fiche : l'implémentation n'a pu partir qu'une fois la maquette relue, la revue n'est pas rejouée (même sans `orchestrate.accept`). */
+function codeAfterFiche(c, fiche) {
+    const l = c.lot;
+    let sha;
+    try {
+        // Le point de départ est le commit qui a créé la fiche : un commit plus récent du dossier (capture corrigée) ne doit pas masquer le code commité avant lui.
+        sha = git(l.repo, 'log', '--diff-filter=A', '--format=%H', '--', fiche).split('\n').filter(Boolean).pop() ?? git(l.repo, 'log', '-1', '--format=%H', '--', posix.dirname(fiche));
+    }
+    catch {
+        return false;
+    }
+    if (!sha)
+        return false;
+    const dir = `${posix.dirname(fiche)}/`;
+    const after = new Set(readCommits(l.repo, { range: `${sha}..HEAD` }).map((k) => k.sha));
+    // Un commit de la session spec elle-même (fiche, maquette, captures) ou de la session accept (tests listés) n'est pas du code.
+    const tests = new Set();
+    const json = lotAcceptation(c, fiche);
+    if (listed(c, json)) {
+        const doc = parseAcceptation(readFileSync(join(l.repo, json), 'utf8'));
+        if (typeof doc !== 'string')
+            for (const f of doc.fichiers)
+                tests.add(posix.normalize(f));
+    }
+    return lotWork(c.loadPlan(), l.repo, l.lot).some((k) => after.has(k.sha) && changedFiles(l.repo, k.sha).some((f) => !f.startsWith(dir) && !tests.has(f)));
+}
+/** L'acceptation du lot : celle que git suit déjà pour lui (même un ancien `acceptation.json`), sinon `acceptation-<lot>.json` à côté de la fiche. */
+const lotAcceptation = (c, fiche) => findAcceptation(c.lot.repo, c.config.spec.dir, c.lot.lot) ?? acceptationFile(fiche, c.lot.lot);
+const listed = (c, json) => existsSync(join(c.lot.repo, json));
+/**
+ * Une acceptation conforme et SCELLÉE par le programme (empreintes posées), rouge ou verte (`vert: true`, lot relancé dans une nouvelle vague) :
+ * elle n'a pu être écrite qu'après la revue de la maquette et les tests rouges, qui ne sont donc pas rejoués. Sans `orchestrate.accept`, aucune preuve.
+ */
+function acceptationProof(c, fiche) {
+    const l = c.lot;
+    const json = lotAcceptation(c, fiche);
+    if (!c.config.accept || !listed(c, json))
+        return false;
+    const doc = parseAcceptation(readFileSync(join(l.repo, json), 'utf8'));
+    if (typeof doc === 'string' || !doc.empreintes)
+        return false;
+    // Le scellé n'est posé que par le programme : chaque fichier listé doit porter l'empreinte git de son contenu actuel (une clé `empreintes` vide ou copiée d'un autre lot ne prouve rien).
+    const emp = doc.empreintes;
+    const sealed = doc.fichiers.every((f) => {
+        const norm = posix.normalize(f);
+        return existsSync(join(l.repo, norm)) && emp[norm] === git(l.repo, 'hash-object', '--', norm).trim();
+    });
+    if (!sealed)
+        return false;
+    const vertMsg = checkAcceptation(l.repo, json, l.lot, fiche).filter((p) => !(doc.vert && p.includes('vert: true à l\'écriture')));
+    return vertMsg.length === 0;
+}
+/** Chemins salis par une session : suivis modifiés, nouveaux fichiers non suivis, et ceux des dépôts voisins. */
+function dirtAfter(done) {
+    return [
+        ...trackedPaths(done.after),
+        ...done.after.untracked.filter((f) => !done.before.untracked.includes(f)),
+        ...done.others.flatMap((o) => [...trackedPaths(o.after), ...o.after.untracked.filter((f) => !o.before.untracked.includes(f))].map((f) => `${o.repo.rel}: ${f}`)),
+    ];
+}
+/** Suite commune des étapes spec et accept : commits de la session (avertis s'ils ne citent pas le lot), choix reportés, vraies questions (les non-questions deviennent un avertissement). */
+function takeReport(c, done, rep) {
+    const l = c.lot;
+    const commits = readCommits(l.repo, { range: done.step.headBefore ? `${done.step.headBefore}..HEAD` : undefined });
+    done.step.commits = commits.map(short).reverse();
+    for (const k of commits)
+        if (!citedRefs(k, c.loadPlan().refs).some((r) => r.lot === l.lot))
+            l.warnings.push(`commit qui ne cite pas ${l.lot} : ${short(k)}`);
+    for (const x of rep.choix ?? [])
+        if (!(l.choix ??= []).includes(x))
+            l.choix.push(x);
+    save(c);
+    for (const q of rep.questions)
+        if (q.trim() && isNonQuestion(q))
+            l.warnings.push(`question ignorée (non-question) : « ${q.trim()} »`);
+    return rep.questions.filter((q) => !isNonQuestion(q));
+}
+/**
+ * Étape spec (L171, spec etape-spec S3) : la session écrit maquette, captures et fiche dans `<spec.dir>/<écran>/`, le programme
+ * en relève les écarts (une seconde passe, puis le lot est rendu), une hypothèse coûteuse à défaire devient une question au lead,
+ * et une sortie sous le seuil (le lot ne change aucun écran) rend le lot au chemin actuel.
+ */
+async function specStep(c) {
+    const l = c.lot;
+    const done = await session(c, 'spec');
+    if (!done)
+        return;
+    l.specRuns = (l.specRuns ?? 0) + 1;
+    let rep;
+    try {
+        rep = checkShape(done.report, SPEC_SCHEMA);
+    }
+    catch (e) {
+        badReport(c, done.step, e);
+        return;
+    }
+    const questions = takeReport(c, done, rep);
+    if (questions.length) {
+        l.questions = questions;
+        l.specRuns = undefined; // la réponse ouvre un nouveau budget de deux sessions
+        l.specAsked = undefined; // la prochaine réponse porte sur la question de la session, pas sur d'anciennes hypothèses coûteuses
+        l.next = 'spec';
+        transition(c, 'question', questions[0]);
+        return;
+    }
+    const dirt = dirtAfter(done);
+    if (dirt.length) {
+        stop(c, 'handed-back', `dépôt sale après spec : ${dirt.join(', ')}`);
+        return;
+    }
+    const reason = rep.sousSeuil.trim();
+    if (reason) {
+        l.spec = { sousSeuil: reason };
+        l.specProblems = undefined;
+        l.warnings.push(`étape spec : sous le seuil, ${l.screen ? 'aucune maquette' : 'aucune fiche'} — ${reason}`);
+        l.next = 'implement';
+        save(c);
+        return;
+    }
+    // Le chemin du rapport est ramené relatif au dépôt (absolu, `./…` ou `a/../b` donneraient de faux écarts) ; hors du dépôt, c'est un écart.
+    const reported = rep.fiche.trim();
+    const asked = reported ? relative(l.repo, resolve(l.repo, reported)) : '';
+    const outside = asked === '..' || asked.startsWith('../') || isAbsolute(asked);
+    const fiche = outside ? '' : asked || findFiche(l.repo, c.config.spec.dir, l.lot) || '';
+    const what = l.screen ? '<écran>' : '<sujet>';
+    const inDir = fiche === '' || fiche.startsWith(`${c.config.spec.dir.replace(/\/+$/, '')}/`);
+    const problems = !outside && fiche && !inDir ? [`${fiche} : fiche hors de ${c.config.spec.dir} (la spec vit dans ${c.config.spec.dir}/${what}/fiche.yaml, où l'étape la retrouve)`] : outside ? [`${reported} : fiche hors du dépôt (le chemin de « fiche » est relatif au dépôt : ${c.config.spec.dir}/${what}/fiche.yaml)`] : fiche ? checkSpec(l.repo, fiche, l.lot, partsOf(l, fiche)) : [`aucune fiche écrite : ${c.config.spec.dir}/${what}/fiche.yaml est attendue (ou une raison dans « sousSeuil » si le lot ne change ${l.screen ? 'aucun écran' : 'aucun comportement'})`];
+    if (problems.length) {
+        if ((l.specRuns ?? 0) >= 2) {
+            stop(c, 'handed-back', `spec non conforme après 2 passes : ${problems.join(' ; ')}`);
+            return;
+        }
+        l.specProblems = problems;
+        l.next = 'spec';
+        save(c);
+        return;
+    }
+    l.specProblems = undefined; // les contrôles passent : les écarts de la passe précédente sont corrigés
+    const doc = parse(readFileSync(join(l.repo, fiche), 'utf8'));
+    // Un choix coûteux à défaire n'est pas une hypothèse : la question remonte au lead, la session reprend avec sa réponse.
+    const costly = costlyHypotheses(doc);
+    if (costly.length) {
+        l.questions = costly.map((x) => `${x.id} est posée comme hypothèse mais touche un choix coûteux à défaire (${x.categorie}) : « ${x.siFaux} » — la confirmer, ou la corriger, avant que la fiche serve de référence.`);
+        l.specAsked = [...l.questions];
+        l.specRuns = undefined; // la réponse du lead ouvre un nouveau budget de deux sessions, comme celle d'une question de la session
+        l.next = 'spec';
+        transition(c, 'question', l.questions[0]);
+        return;
+    }
+    l.specAsked = undefined;
+    l.spec = { fiche, hypotheses: (doc.regles ?? []).filter((r) => r.statut === 'hypothese').length };
+    l.specProblems = undefined;
+    l.hypotheses = undefined; // la fiche vient d'être (ré)écrite : ses hypothèses se posent une fois la fiche relue, pas avant (settleHypotheses)
+    // Les constats de la revue de fiche ont servi à cette passe : sans nouvelle revue de fiche derrière (partie back retirée, preuve d'acceptation), ils ne renvoient pas encore à la spec.
+    const kept = l.ficheConstats;
+    l.ficheConstats = undefined;
+    l.next = afterSpec(c, fiche);
+    if (l.next === 'fiche')
+        l.ficheConstats = kept; // la seconde revue de fiche les relit
+    save(c);
+}
+/**
+ * Un lot sans écran n'a pas de Nouveauté : les hypothèses de sa fiche vont en notes du lot (une par règle) et au tableau de fin de vague (spec
+ * etape-spec-back § 7). Elles se lisent sur la fiche FINALE, juste avant `accept` ou `implement` : après la revue de la fiche et sa seconde passe
+ * (une hypothèse changée ou retirée en passe 2 ne laisse pas la note de la passe 1), et aussi pour une fiche déjà présente à la reprise.
+ * Rend vrai quand le lot est rendu.
+ */
+async function settleHypotheses(c) {
+    const l = c.lot;
+    if (l.screen || !l.specLot || l.hypotheses !== undefined || (l.spec && !('fiche' in l.spec)))
+        return false;
+    const fiche = ficheOf(c);
+    if (!fiche)
+        return false;
+    let doc;
+    try {
+        doc = parse(readFileSync(join(l.repo, fiche), 'utf8'));
+    }
+    catch {
+        return false;
+    }
+    return noteHypotheses(c, hypothesisLines(doc), typeof doc.sujet?.id === 'string' ? doc.sujet.id : posix.basename(posix.dirname(fiche)));
+}
+/**
+ * Pose en note du lot une ligne par hypothèse de la fiche (rien de plus que ce que la note dit déjà : une reprise ne duplique pas) et la commite avec le
+ * plan. Un plan tenu par un autre outil (lecture seule) ne reçoit rien : la ligne devient une proposition rendue au lead. Rend vrai quand le lot est rendu.
+ */
+async function noteHypotheses(c, lines, sujet) {
+    const l = c.lot;
+    l.hypotheses = lines;
+    if (!lines.length)
+        return false;
+    const plan = c.loadPlan();
+    const texts = lines.map((x) => hypothesisNote(sujet, x));
+    if (plan.readonly) {
+        for (const t of texts)
+            propose(c, `[note à poser] ${t}`);
+        return false;
+    }
+    const have = new Set(plan.lot(l.lot).notes.map((n) => n.text));
+    const fresh = texts.filter((t) => !have.has(t));
+    if (!fresh.length)
+        return false;
+    for (const t of fresh)
+        plan.note(l.lot, t, c.wave.today);
+    plan.save();
+    const dirty = await commitPlan(c, `plan: ${l.lot} hypothèses de la fiche ${sujet} notées (orchestrate ${c.wave.id})`);
+    if (dirty) {
+        stop(c, 'handed-back', `notes des hypothèses de la fiche : ${dirty}`);
+        return true;
+    }
+    return false;
+}
+/**
+ * Les mineurs de la revue de la fiche vont en notes du lot (spec etape-spec-back § 4), pas au tableau de fin de vague : une note par constat, sans doublon
+ * à la reprise, commitée avec le plan. Un plan en lecture seule ne reçoit rien : la ligne devient une proposition `[note à poser]` rendue au lead.
+ * Rend vrai quand le lot est rendu (arbre sale).
+ */
+async function noteMinors(c, rep, label) {
+    const texts = rep.constats.filter((k) => k.gravite === 'mineur').map((k) => `Revue de ${label} — mineur : ${k.fichier ? `${k.fichier}${k.ligne ? `:${k.ligne}` : ''} — ` : ''}${k.texte}`);
+    if (!texts.length)
+        return false;
+    const plan = c.loadPlan();
+    if (plan.readonly) {
+        for (const t of texts)
+            propose(c, `[note à poser] ${t}`);
+        return false;
+    }
+    const have = new Set(plan.lot(c.lot.lot).notes.map((n) => n.text));
+    const fresh = [...new Set(texts)].filter((t) => !have.has(t));
+    if (!fresh.length)
+        return false;
+    for (const t of fresh)
+        plan.note(c.lot.lot, t, c.wave.today);
+    plan.save();
+    const dirty = await commitPlan(c, `plan: ${c.lot.lot} mineurs de la revue de ${label} notés (orchestrate ${c.wave.id})`);
+    if (dirty) {
+        stop(c, 'handed-back', `notes des mineurs de la revue de ${label} : ${dirty}`);
+        return true;
+    }
+    return false;
+}
+const FICHE_REVIEW = { kind: 'fiche', label: 'fiche', source: 'code', after: afterFiche, retry: afterFiche };
+const MAQUETTE_REVIEW = { kind: 'maquette', label: 'maquette', source: 'ux', after: afterMaquette, retry: () => 'spec' };
+/**
+ * Revue de la spec (fiche ou maquette) : une session de lecture seule. Un bloquant ou un majeur renvoie à la spec (une seule seconde passe, avec
+ * les constats ; pour un lot mixte, ceux des deux revues ensemble), puis la spec est relue ; ce qui reste après la seconde revue est rendu au lead.
+ * Les mineurs de la fiche vont en notes du lot (ceux de la maquette restent des propositions). Ce verdict n'est pas `raf review` ni `raf ux` : la revue après code garde ce rôle.
+ */
+async function reviewSpecStep(c, r) {
+    const l = c.lot;
+    const fiche = ficheOf(c);
+    if (!fiche) {
+        l.warnings.push(`revue de la ${r.label} ignorée : aucune fiche trouvée pour ce lot`);
+        l.next = 'implement';
+        save(c);
+        return;
+    }
+    const done = await session(c, r.kind);
+    if (!done)
+        return;
+    let rep;
+    try {
+        rep = checkShape(done.report, REVIEW_SCHEMA);
+    }
+    catch (e) {
+        badReport(c, done.step, e);
+        return;
+    }
+    const summary = summarize(rep, done.after.head ?? '');
+    const passes = (l[r.kind]?.passes ?? 0) + 1;
+    l[r.kind] = { passes, conforme: summary.conforme, verdict: summary.verdict };
+    // Fiche : les mineurs sont des notes du lot (design § 4). Maquette : inchangé (propositions du tableau final).
+    addProposals(c, rep, r.kind, r.kind !== 'fiche');
+    if (r.kind === 'fiche' && (await noteMinors(c, rep, `la ${r.label}`)))
+        return;
+    const constats = blockingConstats(rep, r.source);
+    const key = r.kind === 'fiche' ? 'ficheConstats' : 'maquetteConstats';
+    if (summary.conforme) {
+        l[key] = undefined;
+        l.next = r.after(c, fiche);
+        save(c);
+        return;
+    }
+    if (passes >= 2) {
+        stop(c, 'handed-back', `${r.label} non conforme après 2 revues : ${summary.verdict}\n${bulletLines(constats).join('\n')}`);
+        return;
+    }
+    // Le budget de deux sessions spec est épuisé (écarts du programme compris) : un renvoi à la spec serait une 3ᵉ session.
+    if ((l.specRuns ?? 0) >= 2) {
+        stop(c, 'handed-back', `${r.label} non conforme et la spec a déjà joué 2 sessions : ${summary.verdict}\n${bulletLines(constats).join('\n')}`);
+        return;
+    }
+    l[key] = constats.length ? constats : [{ source: r.source, gravite: 'majeur', texte: summary.verdict }];
+    l.next = r.retry(c, fiche);
+    save(c);
+}
+const ficheStep = (c) => reviewSpecStep(c, FICHE_REVIEW);
+const maquetteStep = (c) => reviewSpecStep(c, MAQUETTE_REVIEW);
+/**
+ * Commandes dédiées aux tests d'acceptation du lot (une chaîne ou une liste, L189) : `{acceptation}` y est remplacé, `CADENCE_ACCEPTATION` (chemin absolu
+ * dans les deux cas) et `CADENCE_ACCEPTATION_ROOT` (sa racine) posés. Une commande sans fichier listé sous sa racine n'est pas lancée ; les fichiers
+ * listés sous aucune racine sont rendus (`orphans`) sans rien lancer.
+ */
+async function runAccept(c, json) {
+    const abs = join(c.lot.repo, json);
+    const doc = parseAcceptation(readFileSync(abs, 'utf8'));
+    const plan = planAcceptRuns(acceptCommands(c.config.accept), typeof doc === 'string' ? [] : doc.fichiers, !isAcceptList(c.config.accept));
+    if (plan.orphans.length)
+        return { runs: [], orphans: plan.orphans };
+    const runs = [];
+    for (const r of plan.runs)
+        runs.push({ command: r.command, ...(await sh(c, r.command.replaceAll('{acceptation}', abs), 30 * 60_000, { CADENCE_ACCEPTATION: abs, CADENCE_ACCEPTATION_ROOT: r.root || '.' })) });
+    return { runs, orphans: [] };
+}
+const tail = (output, n = 40) => output.trim().split('\n').slice(-n).join('\n');
+/** Écarts des tests d'acceptation écrits par la session (vide = acceptés) : autres lots intacts, acceptation.json conforme, tests rouges, config.test toujours verte. */
+async function acceptProblems(c, fiche, json, headBefore) {
+    const l = c.lot;
+    const out = headBefore ? lockViolations(l.repo, c.config.spec.dir, headBefore, { skip: json }) : [];
+    out.push(...checkAcceptation(l.repo, json, l.lot, fiche, l.steps.find((s) => s.kind === 'accept')?.headBefore));
+    if (out.length)
+        return out;
+    const red = await runAccept(c, json);
+    if (red.orphans.length)
+        out.push(`fichiers listés dans ${json} sous la racine d'aucune commande de orchestrate.accept (le dossier de son « cd <dossier> && » initial, sinon le dépôt) : ${red.orphans.join(', ')} — aucun lanceur ne les prendrait`);
+    for (const r of red.runs)
+        if (r.code === 0)
+            out.push(`la commande dédiée « ${r.command} » (orchestrate.accept) passe alors que le code n'existe pas : des tests verts avant le code ne prouvent rien — chaque test doit échouer parce que la fonctionnalité manque\n${tail(r.output, 15)}`);
+    if (!c.config.test) {
+        if (!l.warnings.includes(NO_TEST_ACCEPT))
+            l.warnings.push(NO_TEST_ACCEPT);
+    }
+    else {
+        const ordinary = await sh(c, c.config.test);
+        if (ordinary.code !== 0)
+            out.push(`orchestrate.test échoue (code ${ordinary.code}) avec les tests rouges commités : les fichiers listés dans ${json} ne sont pas exclus de la config du lanceur (partagée avec la CI) tant que vert est false\n${tail(ordinary.output, 15)}`);
+    }
+    return out;
+}
+/**
+ * Étape accept (L173, spec etape-spec S5) : une session distincte de l'implémenteur écrit, depuis la fiche et la maquette seules, les tests
+ * d'acceptation rouges. Le programme vérifie (acceptation.json conforme, autres lots intacts, commande dédiée rouge, config.test verte),
+ * accorde une seconde passe, puis SCELLE le fichier (empreintes) dans un commit du cycle : c'est le commit rouge du verrou.
+ */
+async function acceptStep(c) {
+    const l = c.lot;
+    const fiche = ficheOf(c);
+    if (!fiche || !c.config.accept) {
+        l.next = 'implement';
+        save(c);
+        return;
+    }
+    const json = lotAcceptation(c, fiche);
+    const done = await session(c, 'accept');
+    if (!done)
+        return;
+    let rep;
+    try {
+        rep = checkShape(done.report, ACCEPT_SCHEMA);
+    }
+    catch (e) {
+        badReport(c, done.step, e);
+        return;
+    }
+    const questions = takeReport(c, done, rep);
+    if (questions.length) {
+        l.questions = questions;
+        l.next = 'accept';
+        transition(c, 'question', questions[0]);
+        return;
+    }
+    const dirt = dirtAfter(done);
+    if (dirt.length) {
+        stop(c, 'handed-back', `dépôt sale après accept : ${dirt.join(', ')}`);
+        return;
+    }
+    const problems = await acceptProblems(c, fiche, json, done.step.headBefore);
+    if (problems.length) {
+        if (l.acceptProblems) {
+            stop(c, 'handed-back', `accept non conforme après 2 passes : ${problems.join(' ; ')}`);
+            return;
+        }
+        l.acceptProblems = problems;
+        l.next = 'accept';
+        save(c);
+        return;
+    }
+    l.acceptProblems = undefined;
+    sealAcceptation(l.repo, json);
+    const dirty = await commitPlan(c, `test(${l.lot}): acceptation scellée, empreintes des tests rouges (orchestrate ${c.wave.id})`);
+    if (dirty) {
+        stop(c, 'handed-back', `scellé de ${json} : ${dirty}`);
+        return;
+    }
+    l.accept = { acceptation: json, rouge: git(l.repo, 'rev-parse', 'HEAD') };
     l.next = 'implement';
     save(c);
 }
+/**
+ * Retour au vert (S5) : à la fin de chaque implement/fix, quand la commande dédiée passe, le CYCLE (jamais une session) pose `vert: true`
+ * dans l'acceptation.json du lot et le commite ; les fichiers rejoignent alors config.test et la CI. Rend un constat quand elle échoue.
+ */
+async function acceptGreen(c) {
+    const l = c.lot;
+    if (!c.config.accept)
+        return null;
+    const json = l.accept?.acceptation ?? findAcceptation(l.repo, c.config.spec.dir, l.lot);
+    if (!json || !existsSync(join(l.repo, json)))
+        return null;
+    const a = parseAcceptation(readFileSync(join(l.repo, json), 'utf8'));
+    if (typeof a === 'string' || a.vert)
+        return null;
+    const { runs, orphans } = await runAccept(c, json);
+    if (orphans.length)
+        return { source: 'tests', gravite: 'bloquant', texte: `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)
+        return { source: 'tests', gravite: 'bloquant', texte: `tests d'acceptation encore rouges (${failed.map((r) => `${r.command}, code ${r.code}`).join(' ; ')}) : à rendre verts sans modifier les fichiers listés dans ${json} :\n${failed.map((r) => (failed.length > 1 ? `$ ${r.command}\n` : '') + tail(r.output)).join('\n')}` };
+    setVert(l.repo, json);
+    const dirty = await commitPlan(c, `chore(${l.lot}): acceptation verte, vert: true posé par le cycle (orchestrate ${c.wave.id})`);
+    if (dirty)
+        return { source: 'tests', gravite: 'bloquant', texte: `vert: true de ${json} : ${dirty}` };
+    return null;
+}
 /** Étape d'écriture (implémentation, correction) : contrôles, puis étape suivante décidée. */
 async function work(c, kind) {
     const l = c.lot;
@@ -717,6 +1308,13 @@ async function work(c, kind) {
         if (!(l.choix ??= []).includes(x))
             l.choix.push(x);
     save(c);
+    // Verrou des tests d'acceptation (L173) : ceux de TOUS les lots du dépôt, pas seulement du lot courant ; une modification est une question au lead. Contrôlé à CHAQUE fin de session, une question comprise (L200) :
+    // une session qui remplace un test scellé puis pose une question ne passe pas par la reprise du lead pour se faire adopter.
+    const locked = done.step.headBefore ? lockViolations(l.repo, c.config.spec.dir, done.step.headBefore, { rouge: l.accept?.rouge ? { [l.accept.acceptation]: l.accept.rouge } : {}, lot: l.lot, lotBase: l.steps.find((s) => s.headBefore)?.headBefore, lotStart: lotStartHead(l.repo, lotWork(c.loadPlan(), l.repo, l.lot).map((k) => k.sha)), lotCommits: lotCommits(c.loadPlan(), l.repo, l.lot).map((k) => k.sha) }) : [];
+    if (locked.length) {
+        stop(c, 'handed-back', `verrou des tests d'acceptation : ${locked.join(' ; ')}`);
+        return;
+    }
     // La passe des mineurs ne bloque jamais le lot (revue conforme déjà acquise) : une question est rendue en proposition.
     const questions = rep.questions.filter((q) => !isNonQuestion(q));
     // Une entrée filtrée reste visible (avertissement du lot, donc tableau de fin de vague) ; l'entrée vide n'a rien à montrer.
@@ -732,11 +1330,7 @@ async function work(c, kind) {
         transition(c, 'question', questions[0]);
         return;
     }
-    const dirt = [
-        ...trackedPaths(done.after),
-        ...done.after.untracked.filter((f) => !done.before.untracked.includes(f)),
-        ...done.others.flatMap((o) => [...trackedPaths(o.after), ...o.after.untracked.filter((f) => !o.before.untracked.includes(f))].map((f) => `${o.repo.rel}: ${f}`)),
-    ];
+    const dirt = dirtAfter(done);
     if (dirt.length) {
         stop(c, 'handed-back', `dépôt sale après ${kind} : ${dirt.join(', ')}`);
         return;
@@ -779,6 +1373,11 @@ async function work(c, kind) {
     if (!rep.build.vert)
         red.push({ source: 'tests', gravite: 'bloquant', texte: `build annoncé rouge par la session : ${rep.build.commande} — ${rep.build.resultat}` });
     const runs = [];
+    if (red.length === 0) {
+        const green = await acceptGreen(c);
+        if (green)
+            red.push(green);
+    }
     if (red.length === 0) {
         for (const [label, command] of [['tests', c.config.test], ['build', c.config.build]]) {
             if (!command)
@@ -1047,6 +1646,32 @@ export function handBackDroppedQuestions(ctxs) {
         }
     }
 }
+/**
+ * Prédicat « ce commit est l'œuvre d'une session de la vague » (L200) : les commits connus des étapes de TOUS les lots de la vague
+ * (`steps[].commits`) et ceux de `headBefore..headAfter` de chaque session terminée. Un rescellé du lead se fait entre deux sessions, hors de ces plages.
+ */
+function waveCommits(c, repo) {
+    const known = new Set();
+    const prefixes = [];
+    for (const l of [c.lot, ...c.wave.store.lots().filter((x) => lotKey(x.project, x.lot) !== lotKey(c.lot.project, c.lot.lot))]) {
+        for (const s of l.steps) {
+            for (const k of s.commits ?? [])
+                if (/^[0-9a-f]{7,40}\b/i.test(k))
+                    prefixes.push(k.split(' ')[0].toLowerCase());
+            if (!s.headBefore || !s.headAfter || l.repo !== repo)
+                continue;
+            try {
+                for (const sha of git(repo, 'rev-list', `${s.headBefore}..${s.headAfter}`).split('\n'))
+                    if (sha)
+                        known.add(sha);
+            }
+            catch {
+                // plage illisible (historique réécrit) : les commits connus de l'étape restent comptés
+            }
+        }
+    }
+    return (sha) => known.has(sha) || prefixes.some((p) => sha.startsWith(p));
+}
 /** Joue le cycle d'un lot jusqu'à son terme, ou jusqu'à l'arrêt (question, budget, quota). Ne lève jamais. */
 export async function runLot(c) {
     const l = c.lot;
@@ -1060,6 +1685,9 @@ export async function runLot(c) {
         }
         if (l.status === 'question' && !l.pendingAnswer)
             return;
+        // Un test rescellé par le lead pendant la question (L200) a déplacé le commit rouge : l'ancre suit, le verrou garde le reste.
+        if (l.status === 'question' && l.accept?.rouge)
+            l.accept.rouge = resealedRouge(l.repo, l.accept.acceptation, l.accept.rouge, waveCommits(c, l.repo)) ?? l.accept.rouge;
         if (l.next === null && l.steps.length === 0) {
             if (dropped(c)) {
                 stop(c, 'handed-back', DROPPED);
@@ -1082,13 +1710,23 @@ export async function runLot(c) {
                 return;
             }
             l.startedSha = (await snapshot(l.repo, { remote: false })).head ?? undefined;
-            l.next = needsPrecheck(c.config, c.loadPlan(), l.repo, l.lot, l.repos) ? 'precheck' : 'implement';
+            l.next = needsPrecheck(c.config, c.loadPlan(), l.repo, l.lot, l.repos) ? 'precheck' : firstWrite(c);
             save(c);
         }
         while (l.next && !TERMINAL.has(l.status)) {
             const kind = l.next;
+            if ((kind === 'accept' || kind === 'implement') && (await settleHypotheses(c)))
+                return;
             if (kind === 'precheck')
                 await precheck(c);
+            else if (kind === 'spec')
+                await specStep(c);
+            else if (kind === 'fiche')
+                await ficheStep(c);
+            else if (kind === 'maquette')
+                await maquetteStep(c);
+            else if (kind === 'accept')
+                await acceptStep(c);
             else if (kind === 'implement' || kind === 'fix')
                 await work(c, kind);
             else