@sylad/cadence 0.28.0 → 1.1.0

package/dist/orchestrate/cycle.js

@@ -1,21 +1,26 @@
 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 { 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, acceptText, checkAcceptation, findAcceptation, isAcceptationFile, lockViolations, lotStartHead, parseAcceptation, redSha, sealAcceptation, setVert } from './accept.js';
+import { avalFicheText, ficheRules } from './aval.js';
+import { bulletLines, maquetteText, reviewedText } from './maquette.js';
+import { answeredText, checkSpec, costlyHypotheses, ficheReady, findFiche, 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 +83,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 +98,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) }));
@@ -216,16 +224,86 @@ function briefName(l, kind) {
         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 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;
+    try {
+        rules = ficheRules(parse(readFileSync(join(l.repo, fiche), 'utf8')));
+    }
+    catch {
+        return '';
+    }
+    if (!rules.length)
+        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 };
+    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 ? `${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 = l.screen ? avalOf(c, kind) : '';
+    if (kind === 'spec') {
+        vars.spec = specText({ dir: c.config.spec.dir, render: c.config.spec.render, screen: l.screen, problems: l.specProblems, review: l.maquetteConstats?.length ? reviewedText(l.maquetteConstats) : undefined, template: ficheTemplate() });
+        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 === '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`, 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 +381,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' ? '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 +394,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' };
     transition(c, label[kind]);
     w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} (${model})`);
     let brief;
@@ -341,10 +419,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),
@@ -447,20 +526,91 @@ async function session(c, kind, local = false) {
             w.saveWave();
             return stop(c, 'failed', `incident : ${w.incident}`);
         }
+        // Étape en lecture seule qui n'a laissé que des fichiers NON SUIVIS (captures d'un script en chemin relatif, L162) : déplacés dans le dossier du lot, avertissement, le verdict est gardé.
+        if (!write && b.head === a.head && b.tracked.join() === a.tracked.join() && b.untracked.join() !== a.untracked.join() && b.untracked.every((f) => a.untracked.includes(f))) {
+            const fresh = a.untracked.filter((f) => !b.untracked.includes(f)).map(unquotePath);
+            const stray = join(dir, 'stray');
+            const to = where ? join(stray, relative(l.repo, path).replace(/[\\/]/g, '_')) : stray;
+            const moved = moveStray(path, fresh, to);
+            if (moved.length) {
+                const text = `${kind} : ${moved.length} fichier(s) non suivi(s) laissé(s)${where} par une étape en lecture seule, déplacé(s) dans ${to} : ${moved.join(', ')}`;
+                c.lot.warnings.push(text);
+                w.log(`${lotKey(l.project, l.lot)} · ${text}`);
+            }
+            if (moved.length === fresh.length)
+                continue;
+            // Déplacement partiel : l'incident ne nomme que ce qui reste dans le dépôt.
+            return handBack(c, kind, res.structured, step, where, path, b, a, fresh.filter((f) => !moved.includes(f)));
+        }
         if (!write && (b.head !== a.head || b.tracked.join() !== a.tracked.join() || b.untracked.join() !== a.untracked.join())) {
-            // Incident du LOT (L133) : la revue a laissé des traces (captures, commit), ni push ni garde supprimée — les lots des autres dépôts continuent.
-            step.status = 'failed';
-            step.cause = `le dépôt${where} a changé pendant une revue`;
-            const traces = [...trackedPaths(a).filter((f) => !trackedPaths(b).includes(f)), ...a.untracked.filter((f) => !b.untracked.includes(f))];
-            (w.dirtyRepos ??= new Map()).set(path, lotKey(l.project, l.lot));
-            const what = traces.length ? ` (${traces.join(', ')})` : b.head !== a.head ? ' (commit)' : '';
-            return stop(c, 'handed-back', `incident : ${kind} de ${lotKey(l.project, l.lot)} a modifié le dépôt${where}${what}${lostVerdict(c, kind, res.structured)}`);
+            return handBack(c, kind, res.structured, step, where, path, b, a);
         }
     }
     step.status = 'ok';
     save(c);
     return { step, report: res.structured, before, after, others };
 }
+/** Incident du LOT (L133) : la revue a laissé des traces (captures, commit), ni push ni garde supprimée — les lots des autres dépôts continuent. */
+function handBack(c, kind, report, step, where, path, b, a, left) {
+    const l = c.lot;
+    const w = c.wave;
+    step.status = 'failed';
+    step.cause = `le dépôt${where} a changé pendant une revue`;
+    const traces = left ?? [...trackedPaths(a).filter((f) => !trackedPaths(b).includes(f)), ...a.untracked.filter((f) => !b.untracked.includes(f))];
+    (w.dirtyRepos ??= new Map()).set(path, lotKey(l.project, l.lot));
+    const what = traces.length ? ` (${traces.join(', ')})` : b.head !== a.head ? ' (commit)' : '';
+    return stop(c, 'handed-back', `incident : ${kind} de ${lotKey(l.project, l.lot)} a modifié le dépôt${where}${what}${lostVerdict(c, kind, report)}`);
+}
+/** Décode un chemin de `git status --porcelain` : entre guillemets, avec les échappements du C-quoting (`\303\251`, `\"`, `\\`, `\t`…). */
+function unquotePath(f) {
+    if (!/^".*"$/s.test(f))
+        return f;
+    const bytes = [];
+    const esc = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13 };
+    const body = f.slice(1, -1);
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (ch !== '\\') {
+            bytes.push(...Buffer.from(ch));
+            continue;
+        }
+        const oct = /^[0-7]{3}/.exec(body.slice(i + 1));
+        if (oct) {
+            bytes.push(parseInt(oct[0], 8));
+            i += 3;
+        }
+        else {
+            const n = body[++i];
+            bytes.push(...(n in esc ? [esc[n]] : Buffer.from(n)));
+        }
+    }
+    return Buffer.from(bytes).toString('utf8');
+}
+/** Déplace des fichiers non suivis (chemins relatifs au dépôt, décodés) sous `to`, arborescence gardée ; renvoie ceux qui l'ont été (s'arrête au premier échec). */
+function moveStray(repo, files, to) {
+    const moved = [];
+    for (const rel of files) {
+        try {
+            const from = join(repo, rel);
+            let dest = join(to, rel);
+            for (let i = 1; existsSync(dest); i++)
+                dest = join(to, `${rel}.${i}`);
+            mkdirSync(dirname(dest), { recursive: true });
+            try {
+                renameSync(from, dest);
+            }
+            catch {
+                copyFileSync(from, dest); // autre volume
+                rmSync(from);
+            }
+            moved.push(rel);
+        }
+        catch {
+            break;
+        }
+    }
+    return moved;
+}
 /** Verdict d'une revue interrompue par un incident du lot : rapporté au lead plutôt que perdu (L133). Rien n'est enregistré dans le plan. */
 function lostVerdict(c, kind, report) {
     if (kind === 'precheck')
@@ -570,7 +720,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;
         }
@@ -593,9 +743,348 @@ 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 de son écran quand il déclare `screen:` et qu'aucune fiche n'est écrite, sinon l'implémentation. */
+function firstWrite(c) {
+    const l = c.lot;
+    if (!l.screen || l.spec)
+        return 'implement';
+    const fiche = findFiche(l.repo, c.config.spec.dir, l.lot);
+    return fiche && ficheReady(l.repo, fiche, l.lot) ? 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;
+    if (c.config.maquette && !l.maquette?.conforme && !acceptationProof(c, fiche) && !codeAfterFiche(c, fiche))
+        return 'maquette';
+    return afterMaquette(c, fiche);
+}
+/** Étape qui suit une maquette relue : 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;
+    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;
+    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.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, aucune maquette — ${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 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}/<écran>/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}/<écran>/fiche.yaml)`] : fiche ? checkSpec(l.repo, fiche, l.lot) : [`aucune fiche écrite : ${c.config.spec.dir}/<écran>/fiche.yaml est attendue (ou une raison dans « sousSeuil » si le lot ne change aucun écran)`];
+    if (problems.length) {
+        if (l.specProblems) {
+            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.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.next = afterSpec(c, fiche);
+    save(c);
+}
+/**
+ * Étape maquette (L172, spec etape-spec S4) : l'agent ux-reviewer, en lecture seule, relit la maquette et sa fiche. Un bloquant ou un majeur renvoie
+ * à la spec (une seule seconde passe, avec les constats), puis la maquette est relue ; ce qui reste après la seconde revue est rendu au lead.
+ * Les mineurs vont en notes du lot. Ce verdict n'est pas `raf ux` : la conformité après code garde ce rôle.
+ */
+async function maquetteStep(c) {
+    const l = c.lot;
+    const fiche = ficheOf(c);
+    if (!fiche) {
+        l.warnings.push('revue de la maquette ignorée : aucune fiche trouvée pour ce lot');
+        l.next = 'implement';
+        save(c);
+        return;
+    }
+    const done = await session(c, 'maquette');
+    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.maquette?.passes ?? 0) + 1;
+    l.maquette = { passes, conforme: summary.conforme, verdict: summary.verdict };
+    addProposals(c, rep, 'maquette');
+    const constats = blockingConstats(rep, 'ux');
+    if (summary.conforme) {
+        l.maquetteConstats = undefined;
+        l.next = afterMaquette(c, fiche);
+        save(c);
+        return;
+    }
+    if (passes >= 2) {
+        stop(c, 'handed-back', `maquette non conforme après 2 revues : ${summary.verdict}\n${bulletLines(constats).join('\n')}`);
+        return;
+    }
+    l.maquetteConstats = constats.length ? constats : [{ source: 'ux', gravite: 'majeur', texte: summary.verdict }];
+    l.next = 'spec';
+    save(c);
+}
+/** Commande dédiée aux tests d'acceptation du lot : `{acceptation}` y est remplacé, `CADENCE_ACCEPTATION` posé, chemin absolu dans les deux cas. */
+function runAccept(c, json) {
+    const abs = join(c.lot.repo, json);
+    return sh(c, (c.config.accept ?? '').replaceAll('{acceptation}', abs), 30 * 60_000, { CADENCE_ACCEPTATION: abs });
+}
+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.code === 0)
+        out.push(`la commande dédiée (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(red.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 r = await runAccept(c, json);
+    if (r.code !== 0)
+        return { source: 'tests', gravite: 'bloquant', texte: `tests d'acceptation encore rouges (${c.config.accept}, code ${r.code}) : à rendre verts sans modifier les fichiers listés dans ${json} :\n${tail(r.output)}` };
+    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;
@@ -661,15 +1150,17 @@ 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;
     }
+    // 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.
+    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;
+    }
     // Reprise : une session précédente de l'étape (correction ordinaire ou passe des mineurs) a pu commiter avant d'être coupée ; la revue d'origine ne vaut alors plus.
     // Référence : le HEAD de départ de la première session coupée de la série qui précède celle-ci (pas la revue, qui peut ne pas exister encore).
     let resumedFrom;
@@ -708,6 +1199,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)
@@ -1011,13 +1507,19 @@ 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 === 'precheck')
                 await precheck(c);
+            else if (kind === 'spec')
+                await specStep(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