@sylad/cadence 1.2.0 → 1.4.0

package/dist/orchestrate/cycle.js

@@ -2,8 +2,9 @@ import { execFileSync, spawn } from 'node:child_process';
 import { parse } from 'yaml';
 import { toolBinOf, withoutLaunchVars } from './snapshot.js';
 import { randomUUID } from 'node:crypto';
-import { dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
-import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
+import { copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { coveredTasks, lotCommits, lotWork } from '../audit.js';
 import { readDocsConfig } from '../config.js';
 import { docSyncBrief, docSyncGaps, filesOf } from '../docsync.js';
@@ -12,6 +13,7 @@ import { citedRefs } from '../link.js';
 import { repoShas, repoWork } from '../repos.js';
 import { isOpen } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
+import { compareBaseline, failedTests, hasUnnamedFailure } from './baseline.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
 import { capturesText, newsText, objective, renderBrief, reposText, TEMPLATES_DIR } from './briefs.js';
 import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig } from './launch.js';
@@ -25,6 +27,8 @@ import { answeredText, checkSpec, costlyHypotheses, ficheHasBack, ficheReady, fi
 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;
@@ -60,6 +64,12 @@ const short = (c) => `${c.sha.slice(0, 7)} ${c.subject}`;
 function git(repo, ...args) {
     return execFileSync('git', args, { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
 }
+/** Le message d'une commande git qui a échoué : sa sortie d'erreur (sur une ligne), à défaut le message de l'exception. */
+function gitFailure(e) {
+    const err = e.stderr;
+    const text = typeof err === 'string' && err.trim() ? err : e instanceof Error ? e.message : String(e);
+    return text.trim().replace(/\s*\n\s*/g, ' ');
+}
 function save(c) {
     c.wave.store.writeLot(c.lot);
 }
@@ -97,11 +107,136 @@ async function commitPlan(c, message) {
     git(repo, 'commit', '-q', '-m', message, '--', ...dirty);
     return null;
 }
+/**
+ * Sha d'où le lot est parti : le parent de son plus ancien commit de travail (un lot relancé, ou déjà en partie commité, a ses propres
+ * commits avant la vague), à défaut le HEAD d'avant la première session de la vague.
+ */
+const startSha = (c) => lotStartHead(c.lot.repo, lotWork(c.loadPlan(), c.lot.repo, c.lot.lot).map((k) => k.sha)) ?? c.lot.steps.find((s) => s.headBefore)?.headBefore;
+/** Dossiers ignorés de sortie de build : jamais liés dans le worktree jetable, une commande de tests qui y écrit toucherait le build du lot. */
+const OUTPUT_DIRS = new Set(['dist', 'build', 'out', 'coverage', 'target', '.next', '.nuxt', '.output', '.angular', '.turbo', '.svelte-kit', '.parcel-cache']);
+/**
+ * Un `node_modules` dans le worktree de base (L213) : un vrai dossier dont chaque entrée est un lien vers celle du dépôt vivant, SAUF les liens
+ * de workspace (npm, pnpm, yarn : `node_modules/@x/shared -> ../../packages/shared`) qui pointent vers du code du dépôt hors de tout
+ * `node_modules`. Lier le dossier d'un bloc les ferait résoudre dans le dépôt vivant, donc exécuter le code du lot au lieu de celui du sha de
+ * départ ; ils sont refaits vers la copie du worktree (absente au sha de départ : pas de lien). Les dossiers de portée `@x` sont parcourus,
+ * pas les paquets. Ajoute chaque lien créé à `links`.
+ */
+function mirrorNodeModules(repo, dir, name, links) {
+    const repoReal = realpathSync(repo);
+    const workspaceCopy = (live) => {
+        let real;
+        try {
+            real = realpathSync(live);
+        }
+        catch {
+            return null; // lien mort dans le dépôt vivant : rien à refaire
+        }
+        const rel = relative(repoReal, real);
+        if (!rel || rel.startsWith('..') || isAbsolute(rel) || rel.split(sep).includes('node_modules'))
+            return null;
+        return join(dir, rel);
+    };
+    const link = (target, at) => {
+        symlinkSync(target, at);
+        links.push(at);
+    };
+    const mirror = (liveDir, to, scope) => {
+        mkdirSync(to);
+        for (const e of readdirSync(liveDir, { withFileTypes: true })) {
+            const live = join(liveDir, e.name);
+            const at = join(to, e.name);
+            if (e.isSymbolicLink()) {
+                const copy = workspaceCopy(live);
+                if (copy) {
+                    if (existsSync(copy))
+                        link(copy, at);
+                    continue;
+                }
+            }
+            else if (!scope && e.isDirectory() && e.name.startsWith('@')) {
+                mirror(live, at, true);
+                continue;
+            }
+            link(live, at);
+        }
+    };
+    mirror(join(repo, name), join(dir, name), false);
+}
+/**
+ * Échecs des tests au sha de départ du lot (L213) : la commande est rejouée dans un worktree jetable de ce sha, hors du dépôt,
+ * avec des liens vers les dossiers ignorés de tout niveau (node_modules, .venv… ; `dist` et les autres sorties de build exclus, une commande
+ * de tests qui y écrit toucherait le build du lot) pour que les dépendances s'y trouvent. Les `node_modules` sont recréés entrée par entrée
+ * pour que les paquets de workspace résolvent dans le worktree (`mirrorNodeModules`). Null quand le worktree ne peut être monté :
+ * l'appelant garde alors les tests pour rouges.
+ */
+async function baselineFailures(c, command) {
+    const l = c.lot;
+    const sha = startSha(c);
+    if (!sha)
+        return null;
+    if (l.baseline?.verified && l.baseline.sha === sha && l.baseline.command === command)
+        return l.baseline.failures;
+    const dir = mkdtempSync(join(tmpdir(), 'cadence-baseline-'));
+    const links = [];
+    try {
+        git(l.repo, 'worktree', 'add', '--detach', '-f', dir, sha);
+        // Tous niveaux : en monorepo les dépendances vivent dans packages/*/node_modules. `--directory` ne descend pas dans un dossier ignoré, donc
+        // chaque entrée est le dossier ou fichier ignoré le plus haut ; son parent doit exister au sha de départ (sinon rien où le relier).
+        const ignored = git(l.repo, 'ls-files', '--others', '--ignored', '--exclude-standard', '--directory').split('\n').map((f) => f.replace(/\/$/, '')).filter((f) => f && !f.startsWith('.cadence') && !f.split('/').some((p) => OUTPUT_DIRS.has(p)));
+        for (const name of ignored) {
+            const to = join(dir, name);
+            if (existsSync(to) || !existsSync(dirname(to)))
+                continue;
+            if (basename(name) === 'node_modules' && lstatSync(join(l.repo, name)).isDirectory()) {
+                mirrorNodeModules(l.repo, dir, name, links);
+                continue;
+            }
+            symlinkSync(join(l.repo, name), to);
+            links.push(to);
+        }
+        const r = await sh(c, command, 30 * 60_000, {}, dir);
+        const failures = r.code === 0 ? [] : failedTests(r.output);
+        l.baseline = { sha, command, failures, verified: true };
+        save(c);
+        return failures;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        for (const k of links)
+            if (lstatSync(k, { throwIfNoEntry: false })?.isSymbolicLink())
+                unlinkSync(k);
+        try {
+            git(l.repo, 'worktree', 'remove', '--force', dir);
+        }
+        catch {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        try {
+            git(l.repo, 'worktree', 'prune');
+        }
+        catch {
+            // rien à élaguer
+        }
+    }
+}
+/** Des tests rouges comparés à la ligne de base (L213) : tous déjà rouges au départ, ou au moins un nouveau, ou rien de comparable. */
+async function againstBaseline(c, command, output) {
+    const now = failedTests(output);
+    if (!now.length || hasUnnamedFailure(output))
+        return { kind: 'unknown' };
+    const base = await baselineFailures(c, command);
+    if (!base?.length)
+        return { kind: 'unknown' };
+    const { nouveaux, existants } = compareBaseline(now, base);
+    return nouveaux.length ? { kind: 'new', nouveaux, existants: existants.length } : { kind: 'existing', n: existants.length };
+}
 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, env = {}) {
+function sh(c, command, timeoutMs = 30 * 60_000, env = {}, cwd = c.lot.repo) {
     return new Promise((resolve) => {
-        const child = spawn('sh', ['-c', command], { cwd: c.lot.repo, env: { ...withoutLaunchVars(process.env), ...env }, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
+        const child = spawn('sh', ['-c', command], { cwd, 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) }));
@@ -203,11 +338,15 @@ function choixText(choix) {
 }
 /** Tests et build déjà lancés par le programme au HEAD relu : le relecteur ne les refait pas (L75). Vide si HEAD a bougé depuis ou si rien n'a tourné. */
 function checksText(c) {
+    const b = c.lot.baseline;
+    // Sans orchestrate.test aucun rejeu : la base annoncée par la session (non vérifiée) est la seule trace des échecs de départ ; elle s'ajoute aux runs du programme (le build), elle ne les remplace pas.
+    const declared = b && !b.verified && b.failures.length ? `The author reports ${b.failures.length} test(s) already red at the start sha${b.sha ? ` ${b.sha.slice(0, 7)}` : ''}, before this lot (not verified by the program):\n${b.failures.map((t) => `- ${t}`).join('\n')}\nThey are not defects of this lot, do not report them as findings; a failing test outside this list is still a finding.` : '';
     const k = c.lot.checks;
     if (!k?.runs.length || k.head !== git(c.lot.repo, 'rev-parse', 'HEAD'))
-        return '';
-    const runs = k.runs.map((r) => `- \`${r.command}\` (${r.label}): ${r.code === 0 ? 'green' : `RED, exit code ${r.code}`}`);
-    return [`The program already ran these checks at HEAD ${k.head.slice(0, 7)}, just before this review:`, ...runs, 'Take these results as given: do not rebuild, do not rerun the whole suite, and do not wait on them. Run only a check they do not cover (a targeted test of a case you doubt), and list under "nonVerifie" what neither they nor you verified.'].join('\n');
+        return declared;
+    const runs = k.runs.map((r) => `- \`${r.command}\` (${r.label}): ${r.code === 0 ? 'green' : r.dejaRouges ? `RED, exit code ${r.code}, but every failing test (${r.dejaRouges}) was already red at the start sha${c.lot.baseline?.sha ? ` ${c.lot.baseline.sha.slice(0, 7)}` : ''}: not a defect of this lot, do not report them as findings` : `RED, exit code ${r.code}`}`);
+    const ran = [`The program already ran these checks at HEAD ${k.head.slice(0, 7)}, just before this review:`, ...runs, 'Take these results as given: do not rebuild, do not rerun the whole suite, and do not wait on them. Run only a check they do not cover (a targeted test of a case you doubt), and list under "nonVerifie" what neither they nor you verified.'].join('\n');
+    return declared ? `${ran}\n${declared}` : ran;
 }
 /** Consigne docs.sync du brief de revue (L143) : calculée sur les commits du lot au moment de la revue, pas écrite d'avance. */
 function docsText(c) {
@@ -368,18 +507,17 @@ export const lotSpent = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?
 /** Le lot a dépensé son propre budget (L78) : il ne compte plus que sur le lead, la vague garde le sien pour les autres. */
 const lotOver = (l) => l.budget !== undefined && lotSpent(l) >= l.budget;
 /**
- * Coût réservé à la revue qui suit une passe de correction (L145). Réserve fixe de 65 k tokens comptés, proche du p90 des
- * revues complètes. Mesure faite le 2026-10-09 sur les journaux `.cadence/runs/*` (67 dossiers de vague du 04 au 09-10,
- * `tokens.counted` des `N-review.json`, `N-review-small.json`, `N-ux.json` ; aucun journal `ux` conservé, 2 `review-small`
- * sans `tokens.counted` écartés ; p90 par interpolation linéaire) : 187 revues, médiane 43,4 k, p90 62,7 k, max 105,9 k ;
- * 114 revues courtes (review-small, après la passe des mineurs), médiane 37,4 k, p90 67,6 k, max 82,7 k ; ensemble des
- * 301 revues, médiane 42,3 k, p90 67,0 k, max 105,9 k. La revue courte a donc un p90 plus haut que la revue complète : 65 k
- * couvre 170 revues sur 187 (90,9 %) mais 99 revues courtes sur 114 (86,8 %). Une passe fix ne part que s'il reste de quoi payer cette revue.
+ * Coût réservé à une passe de correction et à la revue courte qui la suit (L145, étendu L218). Réserve fixe de 155 k tokens comptés :
+ * p90 d'une passe fix (65 k) plus p90 d'une revue courte Opus (88 k), arrondi. Mesure faite le 2026-10-15 sur les journaux
+ * `.cadence/runs` (523 fichiers de lot) : 497 passes fix Sonnet, médiane 45 k, p90 65 k, max 124 k ; 272 revues courtes Opus,
+ * médiane 45 k, p90 88 k ; la somme des p90 majore le p90 de la somme, elle n'a pas été recalculée par lot. La réserve de L145 (65 k, revue
+ * seule) laissait un lot rendu avant la correction à 740 k / 800 k (warhammer L120) ou 406 k / 450 k (maritime B26.1). Une passe fix ne part
+ * que s'il reste de quoi payer la correction ET sa revue ; sinon le lot est rendu avec « correction non jouée (budget) ».
  * Seule exception : des tests rouges après une écriture (work() appelle toFix() sans revue) — la passe fix suivante peut
  * alors être refusée et le lot revient au lead sans revue, avec ses constats.
  */
-export const REVIEW_RESERVE = 65_000;
-/** Une passe de correction laisse-t-elle de quoi rejouer la revue dans le budget du lot ? Sans budget de lot : toujours. */
+export const REVIEW_RESERVE = 155_000;
+/** Le budget du lot paie-t-il la passe de correction et la revue courte qui la suit ? Sans budget de lot : toujours. */
 const fixAffordable = (l) => l.budget === undefined || lotSpent(l) + REVIEW_RESERVE < l.budget;
 /** Cause d'une suspension demandée par `--stop-after-current` (L79). */
 export const STOP_REQUESTED = 'arrêt demandé (--stop-after-current)';
@@ -395,6 +533,8 @@ function halted(w, lot) {
     if (lot && w.dirtyRepos) {
         for (const r of lotRepoPaths(lot)) {
             const by = w.dirtyRepos.get(r);
+            if (by && w.movedRepos?.has(r))
+                return `dépôt ${r} laissé en HEAD déplacé par ${by} : à remettre sur sa branche par le lead avant de reprendre`;
             if (by)
                 return `dépôt ${r} sali par la revue de ${by} : à nettoyer par le lead avant de reprendre`;
         }
@@ -462,6 +602,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)],
@@ -551,7 +692,8 @@ async function session(c, kind, local = false) {
     step.headAfter = after.head ?? undefined;
     // Le dépôt du projet d'abord, puis chaque voisin : mêmes contrôles, l'incident nomme le dépôt voisin.
     const watched = [{ where: '', path: l.repo, before, after }, ...others.map((o) => ({ where: ` dans ${o.repo.rel}`, path: o.repo.path, before: o.before, after: o.after }))];
-    for (const { where, path, before: b, after: a } of watched) {
+    // Les incidents d'abord, dans TOUS les dépôts surveillés (projet et voisins) : un push ou un hook de garde supprimé où que ce soit arrête la vague, avant tout traitement d'un HEAD déplacé ou d'un lot rendu (L214).
+    for (const { where, before: b, after: a } of watched) {
         if (pushed(b, a)) {
             step.status = 'failed';
             step.cause = `push détecté${where}`;
@@ -566,6 +708,43 @@ async function session(c, kind, local = false) {
             w.saveWave();
             return stop(c, 'failed', `incident : ${w.incident}`);
         }
+    }
+    for (const { where, path, before: b, after: a } of watched) {
+        // Session d'écriture finie sur une autre branche ou en HEAD détaché (L214) : pas un push, mais les contrôles et le lot suivant partiraient d'un HEAD qui n'est plus la branche du lot.
+        if (write && b.branch !== a.branch) {
+            const was = `${a.branch ? `sur la branche ${a.branch}` : `en HEAD détaché (${(a.head ?? '').slice(0, 7)})`} au lieu de ${b.branch ?? 'HEAD détaché'}`;
+            const why = b.branch ? headStranded(path, b, a) : 'le dépôt n\'était pas sur une branche au départ';
+            // La remise peut échouer (index.lock, fichier en conflit) : le lot est rendu, l'orchestrateur ne s'arrête pas (L214).
+            let failed = null;
+            if (b.branch && why === null) {
+                try {
+                    git(path, 'checkout', '-q', b.branch);
+                }
+                catch (e) {
+                    failed = `HEAD déplacé — remise de la branche ${b.branch} impossible : ${gitFailure(e)}`;
+                }
+            }
+            if (b.branch && why === null && failed === null) {
+                Object.assign(a, await snapshot(path));
+                if (path === l.repo)
+                    step.headAfter = a.head ?? undefined;
+                const text = `${kind} : la session a fini${where} ${was} (arbre propre, rien hors de la branche) — branche ${b.branch} remise`;
+                l.warnings.push(text);
+                w.log(`${lotKey(l.project, l.lot)} · ${text}`);
+            }
+            else if (!b.branch) {
+                const text = `${kind} : la session a fini${where} ${was} — ${why}`;
+                l.warnings.push(text);
+                w.log(`${lotKey(l.project, l.lot)} · ${text}`);
+            }
+            else {
+                step.status = 'failed';
+                step.cause = failed ? `${failed}${where}` : `HEAD déplacé${where}`;
+                (w.dirtyRepos ??= new Map()).set(path, lotKey(l.project, l.lot));
+                (w.movedRepos ??= new Set()).add(path);
+                return stop(c, 'handed-back', `incident : HEAD déplacé${where} pendant ${lotKey(l.project, l.lot)} (${kind}) : la session a fini ${was} et ${failed ?? why}`);
+            }
+        }
         // É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);
@@ -590,6 +769,28 @@ async function session(c, kind, local = false) {
     save(c);
     return { step, report: res.structured, before, after, others };
 }
+/** Pourquoi la branche de départ ne peut pas être remise sans risque après un HEAD déplacé (L214), null si elle le peut : arbre propre et rien hors de la branche. */
+function headStranded(path, b, a) {
+    if (a.tracked.length || a.untracked.join() !== b.untracked.join())
+        return 'l\'arbre n\'est pas propre';
+    // Le HEAD final, et chaque position prise par HEAD pendant la session (reflog) : un commit fait en chemin puis quitté n'est plus que dans le reflog.
+    let seen = [];
+    try {
+        seen = git(path, 'reflog', '--format=%H', `-n${Math.max(0, a.reflog - b.reflog)}`, 'HEAD').split('\n').filter(Boolean);
+    }
+    catch {
+        // reflog illisible : le HEAD final seul juge
+    }
+    for (const sha of [a.head ?? 'HEAD', ...seen]) {
+        try {
+            git(path, 'merge-base', '--is-ancestor', sha, `refs/heads/${b.branch}`);
+        }
+        catch {
+            return `des commits ne sont pas dans la branche ${b.branch}`;
+        }
+    }
+    return null;
+}
 /** 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;
@@ -676,13 +877,14 @@ function overBudget(c, reserve = false) {
     // 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 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})`;
+    const why = reserve ? `budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés (${basis}), il ne reste pas de quoi payer la correction et la revue courte qui la suivrait (${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).
     const played = l.pass - 1;
     const after = l.minorPass && played === (l.minorPassAt ?? 0) ? 'la passe des mineurs' : played > 0 ? `la passe fix ${played}` : "l'implémentation";
-    const prefix = red ? `tests rouges après ${after}, correction suivante non abordable : ` : '';
+    const notPlayed = l.next === 'fix' ? 'correction non jouée (budget) : ' : '';
+    const prefix = notPlayed + (red ? `tests rouges après ${after}, correction suivante non abordable : ` : '');
     const unreviewed = red ? ' ; le lot revient sans revue, avec ses constats' : '';
     return stop(c, 'handed-back', `${prefix}${why} : étape « ${l.next ?? '?'} » non jouée${answer}${unreviewed}, à décider par le lead`);
 }
@@ -1368,8 +1570,28 @@ async function work(c, kind) {
     else if (made === 0)
         l.warnings.push(kind === 'fix' ? 'fix sans nouveau commit : revue lancée sur les commits du lot' : `${kind} sans nouveau commit : revue lancée sur les commits déjà faits du lot`);
     const red = [];
-    if (!rep.tests.vert)
-        red.push({ source: 'tests', gravite: 'bloquant', texte: `tests annoncés rouges par la session : ${rep.tests.commande} — ${rep.tests.resultat}` });
+    // Tests annoncés rouges (L213) : avec orchestrate.test, le programme rejoue et compare à la ligne de base, la session n'est crue que si les tests y sont rouges autrement que par des échecs de départ ; sans, la liste des échecs de base de la session, non vérifiée.
+    const claimed = { source: 'tests', gravite: 'bloquant', texte: `tests annoncés rouges par la session : ${rep.tests.commande} — ${rep.tests.resultat}` };
+    let deferred = false;
+    const declared = (rep.echecsDeBase ?? []).map((t) => t.trim()).filter(Boolean);
+    const newFailures = rep.nouveauxEchecs?.map((t) => t.trim()).filter(Boolean);
+    if (!c.config.test && declared.length) {
+        l.baseline = { sha: startSha(c) ?? '', failures: declared, verified: false };
+        l.warnings.push(`échecs déjà présents au sha de départ selon la session (${declared.length}) : non vérifié par le programme (orchestrate.test absent)`);
+    }
+    if (!rep.tests.vert) {
+        if (c.config.test)
+            deferred = true;
+        // Sans orchestrate.test (L215) : champ structuré, pas de lecture de la prose. vert:false + echecsDeBase + nouveauxEchecs présent et vide → pas de correction (non vérifié, signalé à la revue) ; nouveauxEchecs non vide → correction.
+        else if (declared.length && newFailures && !newFailures.length)
+            l.warnings.push(`tests annoncés rouges par la session, aucun nouvel échec déclaré (nouveauxEchecs vide) : les échecs sont ceux de la base qu'elle déclare (${declared.length}) ; pas de correction, non vérifié par le programme (orchestrate.test absent)`);
+        else if (newFailures?.length)
+            red.push({ ...claimed, texte: `${claimed.texte} — nouveaux échecs déclarés par la session : ${newFailures.join(' ; ')}` });
+        else
+            red.push(claimed);
+    }
+    if (rep.tests.vert && !c.config.test && newFailures?.length)
+        l.warnings.push(`rapport incohérent : tests annoncés verts mais nouveaux échecs déclarés (${newFailures.join(' ; ')}) ; pas de correction, non vérifié par le programme (orchestrate.test absent)`);
     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 = [];
@@ -1383,13 +1605,29 @@ async function work(c, kind) {
             if (!command)
                 continue;
             const r = await sh(c, command);
-            runs.push({ label, command, code: r.code });
-            if (r.code !== 0) {
-                red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) :\n${r.output.trim().split('\n').slice(-40).join('\n')}` });
+            const run = { label, command, code: r.code };
+            runs.push(run);
+            if (r.code === 0)
+                continue;
+            const vs = label === 'tests' ? await againstBaseline(c, command, r.output) : { kind: 'unknown' };
+            if (vs.kind === 'existing') {
+                run.dejaRouges = vs.n;
+                const note = `${vs.n} test(s) déjà rouge(s) au sha de départ ${(l.baseline?.sha ?? '').slice(0, 7)}, pas un défaut du lot : listés à part, la revue a lieu`;
+                if (!l.warnings.includes(note))
+                    l.warnings.push(note);
+                continue;
+            }
+            if (vs.kind === 'new') {
+                red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) : ${vs.nouveaux.length} test(s) rouge(s) qui ne l'étaient pas au sha de départ :\n${vs.nouveaux.map((t) => `- ${t}`).join('\n')}${vs.existants ? `\n(${vs.existants} autre(s) test(s) déjà rouge(s) au sha de départ : à ne pas corriger)` : ''}` });
                 break;
             }
+            red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) :\n${r.output.trim().split('\n').slice(-40).join('\n')}` });
+            break;
         }
     }
+    // La session annonçait des tests rouges et le programme ne les voit pas rouges au départ : l'annonce vaut.
+    if (deferred && red.length === 0 && !runs.some((r) => r.label === 'tests' && r.dejaRouges))
+        red.push(claimed);
     if (red.length) {
         toFix(c, red, 'tests rouges');
         return;
@@ -1422,8 +1660,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;
@@ -1512,7 +1754,7 @@ async function reviewStep(c, kind) {
     const noBudget = wanted && (w.budget.exhausted || !fixAffordable(l)) && !w.incident && !w.quota.hit;
     const minorPass = wanted && !noBudget;
     if (noBudget)
-        l.warnings.push(`${w.budget.exhausted ? 'budget atteint' : 'budget du lot trop juste pour payer la revue qui suivrait'} : la passe des mineurs n'a pas eu lieu, mineurs rendus en propositions`);
+        l.warnings.push(`${w.budget.exhausted ? 'budget atteint' : 'budget du lot trop juste pour payer la correction et la revue courte qui la suivrait'} : la passe des mineurs n'a pas eu lieu, mineurs rendus en propositions`);
     // Les mineurs confiés à la passe ont pu être proposés par une revue non conforme antérieure : si la revue qui la suit est
     // conforme, ils sont traités et ne restent pas en propositions (ceux que cette revue signale encore sont ajoutés juste après).
     if (l.minorPass && !minorPass && summary.conforme && uxOk && l.minorLines?.length) {
@@ -1532,6 +1774,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;
@@ -1547,6 +1791,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). */

package/dist/orchestrate/guard.js

@@ -250,10 +250,13 @@ export function guardPresent(repo) {
     return existsSync(file) && readFileSync(file, 'utf8').includes(MARK);
 }
 export async function snapshot(repo, opts = {}) {
-    const [status, head, upstream, remote] = await Promise.all([
+    const [status, head, upstream, upstreamRef, branch, reflog, remote] = await Promise.all([
         out(repo, ['status', '--porcelain', '--untracked-files=all']),
         out(repo, ['rev-parse', '--verify', '-q', 'HEAD']),
         out(repo, ['rev-parse', '-q', '--verify', '@{u}']),
+        out(repo, ['rev-parse', '-q', '--symbolic-full-name', '@{u}']),
+        out(repo, ['symbolic-ref', '-q', '--short', 'HEAD']),
+        out(repo, ['reflog', '--format=%H', 'HEAD']),
         opts.remote === false ? Promise.resolve(null) : out(repo, ['ls-remote', '--heads']),
     ]);
     const lines = (status ?? '').split('\n').filter(Boolean);
@@ -264,13 +267,20 @@ export async function snapshot(repo, opts = {}) {
         tracked: lines.filter((l) => !l.startsWith('??') && keep(l)),
         untracked: lines.filter((l) => l.startsWith('??') && keep(l)).map((l) => l.slice(3)),
         upstream,
+        upstreamRef: upstreamRef?.trim() || null,
+        branch: branch?.trim() || null,
+        reflog: (reflog ?? '').split('\n').filter(Boolean).length,
         guard: guardPresent(repo),
         remote,
     };
 }
-/** Écart de la référence amont ou du dépôt distant depuis `before` : un push est parti. */
+/**
+ * Écart de la référence amont ou du dépôt distant depuis `before` : un push est parti.
+ * La référence amont n'est comparée que si c'est la même branche amont des deux côtés : un `git checkout <sha>` (HEAD
+ * détaché, plus d'amont) ou un changement de branche déplace le HEAD, pas origin (L214) ; le dépôt distant reste juge.
+ */
 export function pushed(before, after) {
-    if (before.upstream !== after.upstream)
+    if (before.upstreamRef !== null && before.upstreamRef === after.upstreamRef && before.upstream !== after.upstream)
         return true;
     return before.remote !== null && after.remote !== null && before.remote !== after.remote;
 }

package/dist/orchestrate/launch.js

@@ -129,7 +129,7 @@ export function buildRetryArgs(spec, sessionId, agents) {
  */
 export async function runSession(spec, deps) {
     const sandbox = sandboxEnv(!!spec.prodAccess);
-    const launch = (args) => deps.claude(args, { local: spec.local, cwd: spec.cwd, unset: sandbox.unset, env: { CADENCE_ORCHESTRATED: spec.wave, ...sandbox.set, ...(spec.nodeBin || spec.toolBin ? { PATH: [spec.toolBin, spec.nodeBin, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {}) }, timeoutMs: spec.timeoutMs, onSpawn: deps.onSpawn });
+    const launch = (args) => deps.claude(args, { local: spec.local, cwd: spec.cwd, unset: sandbox.unset, env: { CADENCE_ORCHESTRATED: spec.wave, ...sandbox.set, ...(spec.nodeBin || spec.toolBin ? { PATH: [spec.toolBin, spec.nodeBin, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {}) }, timeoutMs: spec.timeoutMs, onSpawn: deps.onSpawn, lot: spec.lot });
     const out = await launch(spec.local ? buildLocalArgs(spec, deps.agents) : buildArgs(spec, deps.agents));
     const first = classify(out);
     if (spec.local)

package/dist/orchestrate/schemas.js

@@ -12,6 +12,8 @@ export const WORK_SCHEMA = {
         nonVerifie: strings,
         questions: strings,
         choix: strings,
+        echecsDeBase: strings,
+        nouveauxEchecs: strings,
         resume: str,
     },
     required: ['commits', 'tests', 'build', 'nonVerifie', 'questions', 'resume'],

package/dist/orchestrate/spec.js

@@ -2,6 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parse } from 'yaml';
+import { acceptationFile } from './accept.js';
 import { checkFiche, fichesDuDossier, LARGEURS } from '../spec.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 const list = (v) => (Array.isArray(v) ? v.filter(isObj) : []);
@@ -10,6 +11,19 @@ export function findFiche(repo, dir, lot) {
     const hit = fichesDuDossier(repo, dir).find(({ doc }) => (isObj(doc.ecran) && doc.ecran.lot === lot) || (isObj(doc.sujet) && doc.sujet.lot === lot));
     return hit ? `${dir}/${hit.name}/fiche.yaml` : null;
 }
+/**
+ * L'écran qui fait entrer un lot dans la chaîne spec → maquette → accept (L209) : `page` seul. `component` et `journey` restent des valeurs
+ * valides du plan mais le lot suit le chemin ordinaire, sauf s'il est déjà entré dans la chaîne (une fiche à bloc `ecran` du lot, ou son
+ * `acceptation-<lot>.json` à côté d'une fiche à bloc `ecran`, existent dans `dir`) : il garde alors sa fiche et son verrou.
+ */
+export function specScreen(repo, dir, lot) {
+    if (!lot.screen || lot.screen === 'page')
+        return lot.screen;
+    // Seul un bloc `ecran` compte : la fiche back (bloc `sujet`) et son acceptation sont ce qu'écrit la spec d'un lot `spec: true`.
+    const acceptation = acceptationFile('fiche.yaml', lot.id);
+    const entered = fichesDuDossier(repo, dir).some(({ name, doc }) => isObj(doc.ecran) && (doc.ecran.lot === lot.id || existsSync(join(repo, dir, name, acceptation))));
+    return entered ? lot.screen : undefined;
+}
 /** Texte sans accents ni majuscules, pour les mots-clés. */
 const plain = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
 /**

package/dist/orchestrate/table.js

@@ -93,6 +93,8 @@ function deliverable(lots, ancestor, fromGit) {
     }
     return out;
 }
+/** Tests déjà rouges au départ listés un par un dans le tableau ; au-delà, un compte. */
+const BASELINE_LISTED = 30;
 /** Le tableau de fin de vague (ou de `--status`), une ligne par lot puis le total et les questions. */
 export function renderTable(wave, lots, deps = {}) {
     const rows = lots.map((l) => [`${l.project}:${l.lot}`, LABEL[l.status], String(l.pass), review(l), ux(l), String(commits(l)), k(counted(l)), `${minutes(l)} min`]);
@@ -121,6 +123,15 @@ export function renderTable(wave, lots, deps = {}) {
             out.push(`${l.project}:${l.lot} — captures Playwright : ${l.uxCaptures}`);
         for (const w of l.warnings)
             out.push(`${l.project}:${l.lot} — ⚠ ${w}`);
+        // Ligne de base des tests (L213) : les échecs déjà présents au sha de départ, à part de ceux du lot.
+        const base = l.baseline;
+        if (base?.failures.length) {
+            const where = `${base.sha ? ` (${base.sha.slice(0, 7)}${base.verified ? '' : ', annoncé par la session, non vérifié'})` : ''}`;
+            for (const t of base.failures.slice(0, BASELINE_LISTED))
+                out.push(`${l.project}:${l.lot} — déjà rouge au départ${where} : ${t}`);
+            if (base.failures.length > BASELINE_LISTED)
+                out.push(`${l.project}:${l.lot} — déjà rouge au départ${where} : … et ${base.failures.length - BASELINE_LISTED} autre(s)`);
+        }
         for (const x of l.choix ?? [])
             out.push(`${l.project}:${l.lot} — choix fait : ${x}`);
         for (const h of l.hypotheses ?? [])