@sylad/cadence 1.3.0 → 1.5.1

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';
@@ -62,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);
 }
@@ -99,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) }));
@@ -205,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) {
@@ -370,18 +507,31 @@ 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;
+/** Étapes d'écriture : les seules que le budget du lot borne (`session`), donc les seules qu'il puisse laisser non jouées. */
+const WRITE_STEPS = ['implement', 'fix', 'spec', 'accept'];
+/**
+ * Étape d'écriture que le budget a laissée non jouée (L223), pour un lot rendu au lead sur budget ; null sinon. `stop` vide `next` : l'étape se lit
+ * dans l'outcome que `overBudget` écrit (« étape « fix » non jouée »), repli sur `next` s'il est resté. Reconnu par ce texte (aucun marqueur dans
+ * l'état) : « correction non jouée (budget) » ou « budget du lot atteint ».
+ */
+export function budgetStep(l) {
+    if (l.status !== 'handed-back' || !/correction non jouée \(budget\)|budget du lot atteint/.test(l.outcome ?? ''))
+        return null;
+    const named = /étape « ([\w-]+) » non jouée/.exec(l.outcome ?? '')?.[1];
+    const step = named ?? l.next;
+    return step && WRITE_STEPS.includes(step) ? step : null;
+}
+/** 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)';
@@ -397,6 +547,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`;
         }
@@ -554,7 +706,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}`;
@@ -569,6 +722,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);
@@ -593,6 +783,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;
@@ -679,13 +891,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`);
 }
@@ -1277,6 +1490,12 @@ async function work(c, kind) {
         badReport(c, done.step, e);
         return;
     }
+    // L'écriture a changé le code (L221) : le verdict et les constats de la revue UX d'avant ne valent plus, l'UX est rejouée après la prochaine revue de code conforme.
+    if (!l.small) {
+        l.ux = undefined;
+        l.uxVerdict = null;
+        l.constats = l.constats.filter((k) => k.source !== 'ux');
+    }
     const plan = c.loadPlan();
     const range = done.step.headBefore ? `${done.step.headBefore}..HEAD` : undefined;
     const commits = readCommits(l.repo, { range });
@@ -1353,7 +1572,12 @@ async function work(c, kind) {
             propose(c, minorLine('code', k));
         l.constats = [];
         l.warnings.push('passe des mineurs sans commit : le lot conclut sur la revue conforme d\'origine, mineurs rendus en propositions');
-        if (l.code)
+        if (l.code && uxAfterReview(c)) {
+            // L221 : l'UX finale suit la dernière revue de code conforme, y compris quand la passe des mineurs n'a rien commité.
+            l.next = 'ux';
+            save(c);
+        }
+        else if (l.code)
             await conclude(c, l.code, ' sans commit');
         else
             stop(c, 'handed-back', 'passe des mineurs sans commit, mais aucune revue conforme gardée');
@@ -1371,8 +1595,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 = [];
@@ -1386,13 +1630,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;
@@ -1402,25 +1662,24 @@ async function work(c, kind) {
     l.next = firstReview(c);
     save(c);
 }
+/** Mention « sans commit » du verdict quand la passe des mineurs n'a rien commité (l'UX finale conclut alors à la place de la passe). */
+const noCommitNote = (l) => (l.warnings.some((w) => w.startsWith('passe des mineurs sans commit')) ? ' sans commit' : '');
 /** Revue de code qui clôt le cycle : complète, ou courte une fois la passe des mineurs jouée. */
 const codeReview = (l) => (l.minorPass ? 'review-small' : 'review');
 /**
- * Première étape après un travail d'écriture. Le code vient de changer : l'UX d'un lot visible est donc toujours rejouée
- * (une revue antérieure serait périmée), puis une revue de code clôt le cycle.
+ * Première étape après un travail d'écriture (L221) : la revue de code, jamais l'UX. La revue UX d'un lot visible est jouée une seule fois,
+ * après la dernière revue de code conforme (`uxAfterReview`), sur le code qui sera livré.
  */
 function firstReview(c) {
     const l = c.lot;
     if (l.small)
         return l.visible || l.minorPass ? 'review-small' : 'review'; // passe unique code + ergonomie ; sans écran, une revue de code
-    if (l.visible) {
-        if (!c.config.ux) {
-            l.uxNote = 'UX à faire par le lead (aucune application déclarée : cadence.yaml orchestrate.ux)';
-            return codeReview(l);
-        }
-        return 'ux';
-    }
+    if (l.visible && !c.config.ux)
+        l.uxNote = 'UX à faire par le lead (aucune application déclarée : cadence.yaml orchestrate.ux)';
     return codeReview(l);
 }
+/** La revue de code conforme d'un lot visible non petit est-elle suivie de la revue UX ? Sans `orchestrate.ux`, le lot conclut (note « UX à faire par le lead »). */
+const uxAfterReview = (c) => !c.lot.small && c.lot.visible && !!c.config.ux;
 /** Une passe de correction de plus, ou la main rendue au lead quand les deux sont faites. */
 function toFix(c, constats, what) {
     const l = c.lot;
@@ -1442,12 +1701,20 @@ const seesApp = (l, kind) => kind === 'ux' || (kind === 'review-small' && l.smal
 const appNote = (state, ux) => state.kind === 'busy' ? `UX non vérifiée : port occupé (${ux.url} répond déjà, l'application n'a pas été lancée)` : state.kind === 'unverified' ? `UX non vérifiée : ${state.cause}` : '';
 /**
  * Avec `command` ET `url`, le programme lance l'application avant l'étape et la tue après (succès, erreur ou signal) :
- * port occupé ou application muette, la revue UX n'a pas lieu (note dans le lot, la revue de code suit) ; la passe
- * unique d'un petit lot, elle, a lieu sur le code seul.
+ * port occupé ou application muette, la revue UX n'a pas lieu (étape `skipped`, note dans le lot) et le lot conclut
+ * sur la dernière revue de code conforme (R6) ; la passe unique d'un petit lot, elle, a lieu sur le code seul.
  */
 async function review(c, kind) {
     const l = c.lot;
     const ux = c.config.ux;
+    // Un état repris, écrit avant L221, peut porter next = ux : l'UX ne part que sur une revue de code conforme du HEAD courant, sinon la revue de code passe d'abord (R9).
+    if (kind === 'ux' && !(l.code?.conforme && l.code.head === git(l.repo, 'rev-parse', 'HEAD'))) {
+        l.next = codeReview(l);
+        if (l.status === 'suspended')
+            l.status = 'reviewing'; // reprise d'un lot suspendu : la boucle de runLot enchaîne sur la revue de code au lieu de rendre la main
+        save(c);
+        return;
+    }
     if (!ux?.command || !ux.url || !seesApp(l, kind))
         return reviewStep(c, kind);
     const halt = halted(c.wave, l);
@@ -1455,6 +1722,7 @@ async function review(c, kind) {
         suspend(c, halt); // la session n'aurait pas lieu : l'application ne se lance pas pour rien
         return;
     }
+    let skipped = false;
     c.wave.log(`${lotKey(l.project, l.lot)} · lancement de l'application (${ux.url})`);
     const app = await startApp({ command: ux.command, url: ux.url, cwd: l.repo, nodeBin: l.node?.link, log: join(c.wave.store.lotDir(l.project, l.lot), 'ux-app.log'), timeoutMs: (ux.timeout ?? APP_TIMEOUT_S) * 1000 });
     try {
@@ -1463,12 +1731,7 @@ async function review(c, kind) {
             l.uxNote = appNote(app.state, ux);
             c.wave.log(`${lotKey(l.project, l.lot)} · ${l.uxNote.split('\n')[0]}`);
             if (kind === 'ux') {
-                // Aucune session : une revue UX antérieure, périmée par le code qui a changé, ne pèse plus.
-                l.ux = undefined;
-                l.uxVerdict = null;
-                l.constats = l.constats.filter((k) => k.source !== 'ux');
-                l.next = codeReview(l);
-                save(c);
+                skipped = true; // aucune session : la revue de code conforme suffit, le lot conclut avec la note
                 return;
             }
         }
@@ -1479,6 +1742,8 @@ async function review(c, kind) {
     finally {
         c.app = undefined;
         await app.stop();
+        if (skipped && l.code)
+            await conclude(c, l.code, noCommitNote(l));
     }
 }
 async function reviewStep(c, kind) {
@@ -1500,8 +1765,12 @@ async function reviewStep(c, kind) {
         addProposals(c, rep, 'ux');
         l.uxVerdict = summary.verdict;
         l.constats = blockingConstats(rep, 'ux');
-        l.next = codeReview(l); // la revue de code clôt toujours le cycle
         save(c);
+        // L'UX est la dernière étape (L221) : conforme, le lot conclut avec la revue de code ; sinon une correction (jamais une revue de code d'office), la revue de code et l'UX rejouée suivent.
+        if (summary.conforme)
+            await conclude(c, l.code, noCommitNote(l));
+        else
+            toFix(c, l.constats, 'UX non conforme');
         return;
     }
     l.code = summary;
@@ -1511,18 +1780,18 @@ async function reviewStep(c, kind) {
         l.ux = summary;
         l.uxVerdict = summary.verdict;
     }
-    const uxOk = l.small || !l.ux || l.ux.conforme;
     const minors = minorConstats(rep);
     // Revue conforme avec mineurs : une seule passe de correction des mineurs, avant de conclure (rien sous le tapis).
-    // Budget épuisé : la passe n'aurait aucune session pour la jouer, le lot conclut sur la revue conforme et rend les mineurs.
-    const wanted = summary.conforme && uxOk && !l.minorPass && !l.light && minors.length > 0; // lot léger : les mineurs restent des notes (L108)
+    // Budget épuisé : la passe n'aurait aucune session pour la jouer, les mineurs sont rendus en propositions ; la revue conforme conclut le lot,
+    // sauf un lot visible avec orchestrate.ux, qui passe à next = 'ux' puis reste suspendu tant que le budget de la vague l'est.
+    const wanted = summary.conforme && !l.minorPass && !l.light && minors.length > 0; // lot léger : les mineurs restent des notes (L108)
     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) {
+    if (l.minorPass && !minorPass && summary.conforme && l.minorLines?.length) {
         // Chaque mineur confié retire UNE proposition : la même ligne d'abord, sinon une de même fichier et même texte (le correctif a pu décaler la ligne).
         // Un autre mineur de même fichier et même texte, à une autre ligne, reste donc proposé. Limite connue : un texte reformulé n'est pas reconnu et reste proposé.
         const left = [...l.proposals];
@@ -1539,7 +1808,7 @@ async function reviewStep(c, kind) {
         l.minorLines = [];
     }
     addProposals(c, rep, 'code', !minorPass);
-    if (summary.conforme && uxOk)
+    if (summary.conforme)
         (l.reviewCounts ??= []).push(0); // une revue conforme compte pour 0 dans la comparaison de la convergence (L205)
     if (minorPass) {
         l.minorPass = true;
@@ -1551,18 +1820,19 @@ async function reviewStep(c, kind) {
         save(c);
         return;
     }
-    if (summary.conforme && uxOk) {
-        await conclude(c, summary);
+    if (summary.conforme) {
+        if (uxAfterReview(c)) {
+            l.next = 'ux';
+            save(c);
+        }
+        else
+            await conclude(c, summary);
         return;
     }
-    const constats = [...blockingConstats(rep, 'code'), ...(!l.small && l.ux && !l.ux.conforme ? uxConstatsKept(c) : [])];
+    const constats = blockingConstats(rep, 'code');
     (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). */
-function uxConstatsKept(c) {
-    return c.lot.constats.filter((k) => k.source === 'ux');
-}
 /** Revue conforme : le verdict est enregistré avec le sha relu, puis le commit du plan. `raf done` reste au lead. */
 async function conclude(c, code, minorNote = '') {
     const l = c.lot;

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;
 }