@sylad/cadence 1.1.0 → 1.3.0

package/dist/orchestrate/cycle.js

@@ -17,13 +17,16 @@ import { capturesText, newsText, objective, renderBrief, reposText, TEMPLATES_DI
 import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig } from './launch.js';
 import { cleanPlaywrightOutput, pushed, snapshot } from './guard.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 { 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, ficheReady, findFiche, specText } from './spec.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;
+/** Plafond quand la revue converge (L205) : le nombre de bloquants+majeurs a baissé d'une revue à l'autre et il n'en reste qu'un. */
+export const MAX_PASSES_CONVERGING = MAX_PASSES + 1;
 export class Budget {
     limit;
     consumed = 0;
@@ -217,7 +220,9 @@ 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))
@@ -233,6 +238,22 @@ function ficheTemplate() {
         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 {
@@ -258,19 +279,24 @@ function avalOf(c, kind) {
     if (!step || !fiche)
         return '';
     let rules;
+    let contracts;
+    let screen;
     try {
-        rules = ficheRules(parse(readFileSync(join(l.repo, fiche), 'utf8')));
+        const doc = parse(readFileSync(join(l.repo, fiche), 'utf8'));
+        rules = ficheRules(doc);
+        contracts = ficheContracts(doc);
+        screen = hasScreenPart(doc);
     }
     catch {
         return '';
     }
-    if (!rules.length)
+    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 };
+    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 ? `${text}\n${avalFicheText('ux', o)}` : text;
+    return kind === 'review-small' && l.small && l.visible && screen ? `${text}\n${avalFicheText('ux', o)}` : text;
 }
 function briefFor(c, kind) {
     const plan = c.loadPlan();
@@ -282,15 +308,31 @@ function briefFor(c, kind) {
         vars.news = newsText(l.lot, pwDir);
         vars.captures = capturesText(pwDir);
     }
-    vars.fiche = l.screen ? avalOf(c, kind) : '';
+    vars.fiche = hasSpecStage(l) ? 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 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 = '';
@@ -298,7 +340,7 @@ function briefFor(c, kind) {
     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.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)
@@ -385,7 +427,7 @@ async function session(c, kind, local = false) {
     // 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 = 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 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 ?? [];
@@ -394,7 +436,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', spec: 'implementing', accept: 'implementing', maquette: 'reviewing' };
+    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;
@@ -406,8 +448,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
@@ -422,6 +464,7 @@ async function session(c, kind, local = false) {
         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,
+        lot: lotKey(l.project, l.lot),
         permissionMode: c.config.permissionMode,
         prodAccess: c.config.prodAccess,
         addDirs: [...c.config.addDirs, ...(playwright && write ? [playwrightDir(dirname(mcpConfig))] : []), ...neighbourDirs(l)],
@@ -635,7 +678,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).
@@ -746,13 +790,13 @@ async function precheck(c) {
     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. */
+/** 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 (!l.screen || l.spec)
+    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) ? afterSpec(c, fiche) : 'spec';
+    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';
@@ -762,13 +806,24 @@ const NO_ACCEPT = 'étape accept ignorée : orchestrate.accept absent (commande
  */
 function afterSpec(c, fiche) {
     const l = c.lot;
-    if (c.config.maquette && !l.maquette?.conforme && !acceptationProof(c, fiche) && !codeAfterFiche(c, fiche))
+    // 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 : 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. */
+/** É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);
@@ -868,6 +923,7 @@ async function specStep(c) {
     const done = await session(c, 'spec');
     if (!done)
         return;
+    l.specRuns = (l.specRuns ?? 0) + 1;
     let rep;
     try {
         rep = checkShape(done.report, SPEC_SCHEMA);
@@ -879,6 +935,7 @@ async function specStep(c) {
     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]);
@@ -893,7 +950,7 @@ async function specStep(c) {
     if (reason) {
         l.spec = { sousSeuil: reason };
         l.specProblems = undefined;
-        l.warnings.push(`étape spec : sous le seuil, aucune maquette — ${reason}`);
+        l.warnings.push(`étape spec : sous le seuil, ${l.screen ? 'aucune maquette' : 'aucune fiche'} — ${reason}`);
         l.next = 'implement';
         save(c);
         return;
@@ -903,10 +960,11 @@ async function specStep(c) {
     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}/<é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)`];
+    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.specProblems) {
+        if ((l.specRuns ?? 0) >= 2) {
             stop(c, 'handed-back', `spec non conforme après 2 passes : ${problems.join(' ; ')}`);
             return;
         }
@@ -922,6 +980,7 @@ async function specStep(c) {
     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;
@@ -929,24 +988,113 @@ async function specStep(c) {
     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);
 }
 /**
- * É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.
+ * 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 maquetteStep(c) {
+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 maquette ignorée : aucune fiche trouvée pour ce lot');
+        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, 'maquette');
+    const done = await session(c, r.kind);
     if (!done)
         return;
     let rep;
@@ -958,28 +1106,50 @@ async function maquetteStep(c) {
         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');
+    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.maquetteConstats = undefined;
-        l.next = afterMaquette(c, fiche);
+        l[key] = undefined;
+        l.next = r.after(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')}`);
+        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.maquetteConstats = constats.length ? constats : [{ source: 'ux', gravite: 'majeur', texte: summary.verdict }];
-    l.next = 'spec';
+    l[key] = constats.length ? constats : [{ source: r.source, gravite: 'majeur', texte: summary.verdict }];
+    l.next = r.retry(c, fiche);
     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 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);
-    return sh(c, (c.config.accept ?? '').replaceAll('{acceptation}', abs), 30 * 60_000, { CADENCE_ACCEPTATION: abs });
+    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. */
@@ -990,8 +1160,11 @@ async function acceptProblems(c, fiche, json, 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 (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);
@@ -1076,9 +1249,12 @@ async function acceptGreen(c) {
     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)}` };
+    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)
@@ -1135,6 +1311,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.
@@ -1155,12 +1338,6 @@ async function work(c, kind) {
         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;
@@ -1248,8 +1425,12 @@ function firstReview(c) {
 function toFix(c, constats, what) {
     const l = c.lot;
     l.constats = constats;
-    if (l.pass >= MAX_PASSES) {
-        stop(c, 'handed-back', `${what} après ${MAX_PASSES} passe(s) de correction`);
+    // Revue qui converge (L205) : un seul constat bloquant ou majeur reste, après une baisse d'une revue à l'autre → une passe de plus (budget : fixAffordable, à l'entrée de la session).
+    const counts = l.reviewCounts ?? [];
+    const converging = what === 'revue non conforme' && counts.length >= 2 && counts[counts.length - 1] === 1 && counts[counts.length - 1] < counts[counts.length - 2];
+    const cap = converging ? MAX_PASSES_CONVERGING : MAX_PASSES;
+    if (l.pass >= cap) {
+        stop(c, 'handed-back', `${what} après ${l.pass} passe(s) de correction`);
         return;
     }
     l.pass += 1;
@@ -1358,6 +1539,8 @@ async function reviewStep(c, kind) {
         l.minorLines = [];
     }
     addProposals(c, rep, 'code', !minorPass);
+    if (summary.conforme && uxOk)
+        (l.reviewCounts ??= []).push(0); // une revue conforme compte pour 0 dans la comparaison de la convergence (L205)
     if (minorPass) {
         l.minorPass = true;
         l.minorPassAt = l.pass;
@@ -1373,6 +1556,7 @@ async function reviewStep(c, kind) {
         return;
     }
     const constats = [...blockingConstats(rep, 'code'), ...(!l.small && l.ux && !l.ux.conforme ? uxConstatsKept(c) : [])];
+    (l.reviewCounts ??= []).push(constats.length);
     toFix(c, constats, 'revue non conforme');
 }
 /** Constats UX de la dernière revue UX, gardés dans l'état par la revue elle-même (l.constats avant la revue de code). */
@@ -1472,6 +1656,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;
@@ -1485,6 +1695,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);
@@ -1512,10 +1725,14 @@ export async function runLot(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')

package/dist/orchestrate/fiche.js

@@ -0,0 +1,22 @@
+import { bulletLines } from './maquette.js';
+// Revue de la fiche back (L188, spec etape-spec-back B3) : ce que le programme dit à l'agent code-reviewer en mode « fiche », et à l'agent spec à la seconde passe.
+/** Consigne de la revue de fiche dans le brief : la fiche, la passe en cours, les points de la première revue à la seconde. */
+export function ficheReviewText(o) {
+    const second = o.passes >= 1;
+    const lines = [
+        `Sheet mode: review the sheet \`${o.fiche}\` (back part: \`sujet\`, \`cas\`, \`regles\`, \`contrats\`, \`donnees\`). It is a document, not code: read it, then open the code, the tests and the sources it cites.`,
+        second
+            ? 'This is the second and last review: the spec writer fixed the points of the first one (below). Check them first, then review the whole sheet again.'
+            : 'This is the first review of this sheet.',
+    ];
+    if (second && o.previous?.length)
+        lines.push('', 'Points of the first review that the spec writer had to fix:', ...bulletLines(o.previous));
+    return lines.join('\n');
+}
+/** Consigne de la seconde passe `spec` : les constats bloquants et majeurs des revues de la fiche (et de la maquette d'un lot mixte), ensemble. */
+export function reviewedSheetText(constats, mockup) {
+    return [
+        `The review of your ${mockup ? 'sheet and mockup' : 'sheet'} found the blocking and major points below. Fix exactly these in the sheet${mockup ? ', the mockup and the captures' : ''} (one more pass only: it is reviewed again, and what remains goes back to the lead). Keep the sheet consistent: every rule sourced or a hypothesis with its \`si_faux\`, every rule attached to a case and tested, every contract with its errors:`,
+        ...bulletLines(constats),
+    ].join('\n');
+}