@sylad/cadence 1.13.0 → 1.14.1

package/dist/orchestrate/cycle.js

@@ -2,21 +2,22 @@ import { 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 { delimiter, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
 import { copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { coveredTasks, lotCommits, lotWork } from '../audit.js';
-import { readDocsConfig } from '../config.js';
+import { readDocsConfig, readPlanConfig } from '../config.js';
+import { PLAN_ACTIONS, leadAnswerMessage, planCommitMessage } from '../plan-commit.js';
 import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
-import { changedFiles, gitCommonDir, isAncestor, readCommits, resolveCommit } from '../git.js';
+import { changedFiles, dirtyPaths, gitCommonDir, isAncestor, readCommits, resolveCommit, restorePaths } from '../git.js';
 import { blockingLots, gitCommitsIn } from './table.js';
 import { citedRefs } from '../link.js';
 import { repoShas, repoWork } from '../repos.js';
-import { isOpen } from '../plan.js';
+import { isOpen, RafError } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
-import { compareBaseline, failedTests, hasUnnamedFailure } from './baseline.js';
-import { TEST_WORKERS_ENV, testWorkersText } from './workers.js';
+import { compareBaseline, failedTests, hasUnnamedFailure, jestTestFiles } from './baseline.js';
+import { replayFile, replayRanFile, shellArg, TEST_WORKERS_ENV, testWorkersText } from './workers.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
 import { capturesText, headline, integrationText, localReading, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tmpText } from './briefs.js';
 import { SlotAbandoned } from './registry.js';
@@ -26,13 +27,14 @@ import { sumTokens } from './result.js';
 import { cutReport, EXTENSION_MS, MAX_EXTENSIONS, workTimeoutMs } from './timeouts.js';
 import { ACCEPT_SCHEMA, checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, WORK_SCHEMA } from './schemas.js';
 import { acceptationFile, acceptCommands, isAcceptList, acceptText, checkAcceptation, findAcceptation, isAcceptationFile, lockViolations, lotStartHead, parseAcceptation, planAcceptRuns, redSha, resealedRouge, sealAcceptation, setVert } from './accept.js';
+import { lotIds, referenceIdsText } from '../ref/coverage.js';
 import { avalFicheText, ficheContracts, ficheRules, hasScreenPart } from './aval.js';
 import { ficheReviewText, reviewedSheetText } from './fiche.js';
 import { bulletLines, maquetteText, reviewedText } from './maquette.js';
 import { answeredText, checkSpec, costlyHypotheses, ficheHasBack, ficheReady, findFiche, hypothesisLines, answerAltersRule, hypothesisNote, LEAD_SOURCE, ruleIdsSourcedByLead, sourceRules, specText } from './spec.js';
 import { decisionsText, humanDecisions } from './decisions.js';
 import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
-import { advance, INTEGRATE_WAIT_MS, mergeBase, patchId, rebaseOnto, repoBranch, takeRepoWrite } from './integrate.js';
+import { advance, baseMoved, INTEGRATE_WAIT_MS, MAX_REPLAYS, mergeBase, patchId, rebaseOnto, repoBranch, takeRepoWrite } from './integrate.js';
 import { mutexFor } from './mutex.js';
 import { branchExists, git, gitFailure, integrated, linkIgnored, lotBranch, planFileSet, planSeenFrom, prepareTree, removeTree, trackedDirty } from './worktree.js';
 /** Passes de correction au plus, puis la main est rendue au lead. */
@@ -112,22 +114,68 @@ const stop = (c, status, outcome, noResult = false) => {
 function trackedPaths(s) {
     return s.tracked.map((l) => l.slice(3).replace(/^.* -> /, '').replace(/^"|"$/g, ''));
 }
+/** Le gabarit `plan.commit` du projet (L343), undefined sans. */
+const planTemplate = (c) => readPlanConfig(join(c.lot.repo, 'cadence.yaml'), c.lot.repo)?.commit;
+/** Le message d'un commit de plan de la vague : le gabarit `plan.commit` du projet (L343), à défaut le message d'avant. */
+function planMessage(c, action) {
+    return planCommitMessage(planTemplate(c), { lot: c.lot.lot, action, wave: c.wave.id });
+}
+/**
+ * Ce que le lead a modifié dans le plan sans commiter, pris AVANT que cadence n'écrive : les fichiers suivis modifiés que `commitPlan` accepte (le plan, ce qui est
+ * tenu avec lui, les acceptation.json), avec leur contenu. Un commit de plan refusé (hook) les remet tels quels au lieu de les ramener à HEAD (L343).
+ */
+function planBefore(c, repo = c.lot.repo) {
+    const ownFile = planOwnFile(c, repo);
+    const kept = new Map();
+    for (const f of trackedDirty(repo).filter(ownFile)) {
+        try {
+            kept.set(f, readFileSync(join(repo, f), 'utf8'));
+        }
+        catch {
+            kept.set(f, null);
+        }
+    }
+    return kept;
+}
 /**
  * Commit d'entretien du plan, chemins explicites. Rend un message d'arbre sale quand autre chose que le plan a bougé.
  * Dans le dépôt du projet (`root` par défaut) : jamais dans un worktree de lot (R21). Les commits de TRAVAIL du cycle (scellé et `vert: true` de l'acceptation)
  * se font, eux, dans `wd(c)`, sur la branche du lot.
+ * `before` : ce que le lead avait modifié sans commiter avant l'écriture (`planBefore`) ; un commit refusé le remet, et ramène à HEAD ce que cadence seule a écrit.
  */
-async function commitPlan(c, message, root = c.lot.repo) {
+async function commitPlan(c, message, root = c.lot.repo, before = new Map()) {
     const repo = root;
     const ownFile = planOwnFile(c, repo);
-    const dirty = trackedPaths(await snapshot(repo, { remote: false }));
+    // Les fichiers de plan.onWrite (L346) entrent même non suivis : le premier plan publié n'est pas encore au dépôt.
+    const produced = c.loadPlan().produced;
+    const dirty = [...new Set([...trackedPaths(await snapshot(repo, { remote: false })), ...(produced.length ? dirtyPaths(repo, produced) : [])])];
     if (dirty.length === 0)
         return null;
     const foreign = dirty.filter((f) => !ownFile(f));
     if (foreign.length)
         return `arbre sale (fichiers hors plan) : ${foreign.join(', ')}`;
     git(repo, 'add', '--', ...dirty);
-    git(repo, 'commit', '-q', '-m', message, '--', ...dirty);
+    try {
+        git(repo, 'commit', '-q', '-m', message, '--', ...dirty);
+    }
+    catch (e) {
+        // Commit refusé (hook commit-msg…, L343) : le plan n'a pas à rester indexé ni modifié par cadence, le lot suivant y verrait un dépôt sale et serait rendu.
+        // Ce que le lead avait modifié sans commiter (raf add, raf note pendant la session) est remis, pas effacé.
+        git(repo, 'restore', '--staged', '--', ...dirty);
+        const own = dirty.filter((f) => !before.has(f));
+        // restorePaths : un fichier de plan.onWrite (L346) pas encore au dépôt est retiré, `git restore --source=HEAD` échouerait sur lui (pathspec) et laisserait le plan modifié.
+        if (own.length)
+            restorePaths(repo, own);
+        for (const [f, text] of before) {
+            if (!dirty.includes(f))
+                continue;
+            if (text === null)
+                rmSync(join(repo, f), { force: true });
+            else
+                writeFileSync(join(repo, f), text);
+        }
+        throw e;
+    }
     return null;
 }
 /**
@@ -139,8 +187,8 @@ const startSha = (c) => lotStartHead(wd(c), lotWork(histPlan(c), wd(c), c.lot.lo
  * É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.
+ * pour que les paquets de workspace résolvent dans le worktree (`mirrorNodeModules`). Avec `orchestrate.testReplay`, un rouge nommé y est rejoué seul (L354) avant d'être retenu.
+ * 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;
@@ -159,7 +207,13 @@ async function baselineFailures(c, command) {
         if (c.config.build && (await sh(c, c.config.build, 30 * 60_000, {}, dir)).code !== 0)
             return null;
         const r = await sh(c, command, 30 * 60_000, {}, dir);
-        const failures = r.code === 0 ? [] : failedTests(r.output);
+        // Ligne de base comprise (L354) : un rouge du sha de départ est rejoué seul dans le même worktree avant d'être retenu. Sous charge, un test
+        // qui passe seul au départ rougirait ici et excuserait une vraie régression du lot (« déjà rouge au départ »). Un échec sans nom reste tel quel.
+        const found = r.code === 0 ? [] : failedTests(r.output);
+        const named = c.config.testReplay && found.length && !hasUnnamedFailure(r.output) ? found : [];
+        const { red: failures, unstable } = named.length ? await replayAlone(c, c.config.testReplay, named, r.output, dir) : { red: found, unstable: [] };
+        if (unstable.length)
+            c.wave.log(`${lotKey(l.project, l.lot)} · ligne de base ${sha.slice(0, 7)} : ${unstable.length} test(s) rouge(s) sous charge, vert(s) rejoué(s) seul(s), non retenu(s) comme déjà rouge(s) : ${unstable.join(' ; ')}`);
         l.baseline = { sha, command, failures, verified: true };
         save(c);
         return failures;
@@ -198,9 +252,17 @@ async function againstBaseline(c, command, output) {
 }
 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. */
+/**
+ * PATH des commandes que le programme lance lui-même (porte, ligne de base, démarrage, acceptation, verdict) : le même que celui des sessions,
+ * le lien `node-bin/<version>` du .nvmrc du lot en tête (L351). Sans .nvmrc, rien : le PATH hérité reste tel quel.
+ */
+function nodePath(c) {
+    const link = c.lot.node?.link;
+    return link ? { PATH: [toolBinOf(c.wave.store.dir), link, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {};
+}
 function sh(c, command, timeoutMs = 30 * 60_000, env = {}, cwd = wd(c)) {
     return new Promise((resolve) => {
-        const child = spawn('sh', ['-c', command], { cwd, env: { ...withoutLaunchVars(process.env), ...(c.wave.testWorkers ? { [TEST_WORKERS_ENV]: String(c.wave.testWorkers) } : {}), ...env }, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
+        const child = spawn('sh', ['-c', command], { cwd, env: { ...withoutLaunchVars(process.env), ...nodePath(c), ...(c.wave.testWorkers ? { [TEST_WORKERS_ENV]: String(c.wave.testWorkers) } : {}), ...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) }));
@@ -255,7 +317,7 @@ async function startLot(c) {
             plan.setStatus(c.lot.lot, 'doing', c.wave.today);
             plan.save();
         }
-        const dirty = await commitPlan(c, `plan: ${c.lot.lot} démarré (orchestrate ${c.wave.id})`);
+        const dirty = await commitPlan(c, planMessage(c, PLAN_ACTIONS.started));
         if (dirty)
             return dirty;
     }
@@ -309,7 +371,11 @@ function checksText(c) {
     const k = c.lot.checks;
     if (!k?.runs.length || k.head !== git(wd(c), 'rev-parse', 'HEAD'))
         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 runs = k.runs.map((r) => {
+        const alone = r.instables?.length ? `${r.instables.length} test(s) red under load in the whole suite, green when replayed alone, not defects: ${r.instables.join(' ; ')}` : '';
+        const state = 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}`;
+        return `- \`${r.command}\` (${r.label}): ${state}${alone ? `${r.code === 0 ? ';' : '. Also'} ${alone}` : ''}`;
+    });
     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;
 }
@@ -431,6 +497,9 @@ function briefFor(c, kind, local = false) {
     if (mcpServersFor(kind, l.visible, '', l.small, !!l.screen).playwright)
         vars.shots = shotsText(playwrightDir(c.wave.store.lotDir(l.project, l.lot)));
     vars.fiche = hasSpecStage(l) ? avalOf(c, kind) : '';
+    // la vérification des ids d'un document de référence sur l'écran fini : la passe ux, ou la revue courte d'un petit lot visible qui n'a que celle-là (comme la conformité, avalOf)
+    if (kind === 'ux' || (kind === 'review-small' && l.small && l.visible))
+        vars.ux = [vars.ux, referenceIdsText('ux', lotIds({ ...lot, goal: l.goal ?? lot.goal }))].filter(Boolean).join('\n');
     if (kind === 'implement' || kind === 'fix')
         vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? plan.lots().find((x) => x.id === lot.parent) : undefined));
     if (kind === 'precheck' && local)
@@ -450,6 +519,7 @@ function briefFor(c, kind, local = false) {
             template: l.screen ? ficheTemplate() : undefined,
             templateBack: back || l.screen ? ficheBackTemplate() : undefined,
         });
+        vars.spec = [vars.spec, referenceIdsText('spec', lotIds({ ...lot, goal: l.goal ?? lot.goal }))].filter(Boolean).join('\n\n');
         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}`;
@@ -1462,7 +1532,7 @@ function sourceAnsweredRules(c) {
         if (!ids.length)
             return false;
         git(wd(c), 'add', '--', fiche);
-        git(wd(c), 'commit', '-q', '-m', `spec(${l.lot}): ${ids.join(', ')} ${ids.length > 1 ? 'sourcées' : 'sourcée'} par la réponse du lead (orchestrate ${c.wave.id})`, '--', fiche);
+        git(wd(c), 'commit', '-q', '-m', leadAnswerMessage(planTemplate(c), l.lot, ids, c.wave.id), '--', fiche);
         return false;
     }
     catch (e) {
@@ -1604,10 +1674,11 @@ async function noteHypotheses(c, lines, sujet) {
         const fresh = texts.filter((t) => !have.has(t));
         if (!fresh.length)
             return null;
+        const before = planBefore(c);
         for (const t of fresh)
             plan.note(l.lot, t, c.wave.today);
         plan.save();
-        return commitPlan(c, `plan: ${l.lot} hypothèses de la fiche ${sujet} notées (orchestrate ${c.wave.id})`);
+        return commitPlan(c, planMessage(c, PLAN_ACTIONS.hypotheses(sujet)), c.lot.repo, before);
     });
     if (dirty) {
         handBackPlan(c, `${HYPOTHESES_HANDBACK}${dirty}`);
@@ -1635,10 +1706,11 @@ async function noteMinors(c, rep, label) {
         const fresh = [...new Set(texts)].filter((t) => !have.has(t));
         if (!fresh.length)
             return null;
+        const before = planBefore(c);
         for (const t of fresh)
             plan.note(c.lot.lot, t, c.wave.today);
         plan.save();
-        return commitPlan(c, `plan: ${c.lot.lot} mineurs de la revue de ${label} notés (orchestrate ${c.wave.id})`);
+        return commitPlan(c, planMessage(c, PLAN_ACTIONS.minors(label)), c.lot.repo, before);
     });
     if (dirty) {
         handBackPlan(c, `${MINORS_HANDBACK}${label} : ${dirty}`);
@@ -1906,21 +1978,83 @@ async function programChecks(c, red, runs) {
         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`;
+        const onlyExisting = (n) => {
+            run.dejaRouges = n;
+            const note = `${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);
+        };
+        if (vs.kind === 'existing') {
+            onlyExisting(vs.n);
             continue;
         }
+        // Un rouge absent de la ligne de base est rejoué SEUL avant d'être compté (L354) : sous charge, des tests qui passent seuls rougissent ensemble.
+        // Sans `orchestrate.testReplay` rien n'est rejoué : le rouge est compté tel quel et rien n'est tenu pour instable (L354).
+        const replay = label === 'tests' ? c.config.testReplay : undefined;
+        const named = !replay ? [] : vs.kind === 'new' ? vs.nouveaux : !hasUnnamedFailure(r.output) ? failedTests(r.output) : [];
+        const { red: still, unstable } = named.length ? await replayAlone(c, replay, named, r.output) : { red: [], unstable: [] };
+        if (unstable.length) {
+            noteUnstable(c, unstable);
+            run.instables = unstable;
+        }
+        if (unstable.length && !still.length) {
+            if (vs.kind === 'new' && vs.existants)
+                run.dejaRouges = vs.existants;
+            else
+                run.code = 0;
+            continue;
+        }
+        const alone = unstable.length ? `\n(${unstable.length} test(s) rouge(s) sous charge, verts rejoués seuls : instables, à ne pas corriger)` : '';
         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)` : ''}` });
+            const left = vs.nouveaux.filter((t) => !unstable.includes(t));
+            red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) : ${left.length} test(s) rouge(s) qui ne l'étaient pas au sha de départ :\n${left.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)` : ''}${alone}` });
             return;
         }
-        red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) :\n${r.output.trim().split('\n').slice(-40).join('\n')}` });
+        // Des instables sont écartés : la sortie de la suite entière les montre encore en FAIL, le constat ne nomme que ceux qui restent rouges.
+        const shown = unstable.length ? `${still.length} test(s) rouge(s) après rejeu seul :\n${still.map((t) => `- ${t}`).join('\n')}` : r.output.trim().split('\n').slice(-40).join('\n');
+        red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) :\n${shown}${alone}` });
         return;
     }
 }
+/** Sortie d'un lanceur qui n'a trouvé aucun test à rejouer : la ligne de fin du lanceur (vitest « No test files found, exiting with code », jest « No tests found, exiting with code », pytest « no tests ran in »), en début de ligne — pas ces mots cités dans le titre ou la sortie d'un test. */
+const NO_TEST_RAN = /^\W*(?:no test files? found, exiting with code|no tests? found, exiting with code|no tests ran in)\b/im;
+/** Rejeux d'un test rouge de la porte, seul (L354) : rouge aux deux, il est compté. */
+const REPLAYS = 2;
+/**
+ * Rejoue SEULS (la commande `orchestrate.testReplay` où `{files}` devient les fichiers de ces tests, dans `cwd` : le worktree du lot, ou celui de la ligne de base) les tests rouges d'une suite entière (L354). Le 26-10, vitest à 31 workers par suite sur une machine à 4 sessions rougissait des tests
+ * qui passaient seuls : quatre corrections vides (4 à 11 min chacune). Un test vert à un rejeu est `unstable` ; rouge aux `REPLAYS` rejeux, ou sans fichier désignable (rien à rejouer seul), il reste dans `red`.
+ */
+async function replayAlone(c, template, names, output, cwd = wd(c)) {
+    const jest = jestTestFiles(output);
+    const fileOf = (n) => replayFile(n) ?? jest.get(n) ?? null;
+    let red = names;
+    const unstable = [];
+    for (let i = 0; i < REPLAYS; i++) {
+        const replayable = red.filter((n) => fileOf(n));
+        const files = [...new Set(replayable.map((n) => fileOf(n)))];
+        if (!files.length)
+            break;
+        const r = await sh(c, template.replaceAll('{files}', () => files.map(shellArg).join(' ')), undefined, undefined, cwd);
+        // Seul un rejeu qui sort en 0 en ayant exécuté le FICHIER du test vaut vert. Un rejeu en échec ne conclut rien pour un test qu'il ne nomme pas : sur une porte composée (`a && b`) les fichiers n'atteignent que le dernier lanceur, un premier lanceur qui rougit coupe avant lui. Un rejeu sans test exécuté (filtre sans fichier, `passWithNoTests`) sort en 0 sans rien prouver, et un lanceur qui ignore sans rien dire un fichier qu'il ne trouve pas (vitest d'un autre espace de travail) sort en 0 sans l'avoir joué : le fichier doit figurer, chemin entier, sur une ligne du lanceur de la sortie du rejeu, hors écho de la commande par npm/pnpm/yarn (`replayRanFile`).
+        const ran = r.code === 0 && !NO_TEST_RAN.test(r.output);
+        const passed = ran ? replayable.filter((n) => replayRanFile(r.output, fileOf(n))) : [];
+        unstable.push(...passed);
+        red = red.filter((n) => !passed.includes(n));
+    }
+    return { red, unstable };
+}
+/** Trace des tests instables sous charge (L354) : le lot (`instables`, journal et `cadence perf`), un avertissement du lot (tableau de fin de vague) et une ligne du journal de la vague. */
+function noteUnstable(c, tests) {
+    const l = c.lot;
+    const fresh = tests.filter((t) => !(l.instables ?? []).includes(t));
+    if (!fresh.length)
+        return;
+    l.instables = [...(l.instables ?? []), ...fresh];
+    const text = `${fresh.length} test(s) instable(s) sous charge (rouge(s) dans la suite, vert(s) rejoué(s) seul(s)), pas de passe de correction : ${fresh.join(' ; ')}`;
+    l.warnings.push(text);
+    c.wave.log(`${lotKey(l.project, l.lot)} · ${text}`);
+    save(c);
+}
 /**
  * Contrôles du sommet intégré (L328) : un rouge est relancé une fois avant de rendre le lot. Le 25-10, L326 a été rendu pour un rouge de charge (L325 tournait en même
  * temps) alors que le même sommet rejoué seul était vert. Rouge deux fois = rendu, avec le résultat de la seconde passe ; vert à la relance = une alerte sur le lot et une ligne du journal.
@@ -2118,8 +2252,13 @@ async function work(c, kind) {
     }
     if (red.length === 0)
         await programChecks(c, red, runs);
-    // 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))
+    // La session annonçait des tests rouges et le programme ne les voit ni déjà rouges au départ (L213) ni instables sous charge (L354, verts rejoués seuls) : l'annonce vaut.
+    // L361 : la porte du programme est verte (code 0) et la session n'annonce que des échecs de base (echecsDeBase non vide, nouveauxEchecs présent et vide) : rien de rouge pour le programme, rien de nouveau pour la session → revue, sans correction ni escalade.
+    const gateGreen = runs.some((r) => r.label === 'tests' && r.code === 0);
+    const baseOnly = declared.length > 0 && !!newFailures && !newFailures.length;
+    if (deferred && red.length === 0 && gateGreen && baseOnly)
+        l.warnings.push(`tests annoncés rouges par la session, mais la porte du programme verte (${c.config.test}, code 0) et aucun nouvel échec déclaré (nouveauxEchecs vide) : les échecs sont ceux de la base qu'elle déclare (${declared.length}) ; pas de correction`);
+    else if (deferred && red.length === 0 && !runs.some((r) => r.label === 'tests' && (r.dejaRouges || r.instables?.length)))
         red.push(claimed);
     if (red.length) {
         toFix(c, red, 'tests rouges');
@@ -2448,13 +2587,21 @@ async function writeVerdict(c, verdict, commit, reporte) {
         // Déjà écrit et commité au même sha (reprise de l'intégration, R23) : une seule fois.
         if (c.tree && commit !== null && plan.lot(l.lot).review?.commit === commit && !covered.length && !trackedDirty(l.repo).includes(relative(l.repo, plan.path)))
             return null;
+        const before = planBefore(c);
         plan.recordReview(l.lot, verdict, c.wave.today, commit, neighbours.length ? shas : undefined, reporte);
         for (const k of covered)
             plan.setStatus(`${l.lot}/${k.task}`, 'done', c.wave.today);
         if (covered.length)
             l.warnings.push(`sous-tâches closes (couvertes par des commits qui les citent, revue conforme) : ${covered.map((k) => `${l.lot}/${k.task} (${k.sha.slice(0, 7)})`).join(', ')}`);
-        plan.save();
-        const dirty = await commitPlan(c, `plan: ${l.lot} revue de code enregistrée (orchestrate ${c.wave.id})`);
+        try {
+            plan.save();
+        }
+        catch (e) {
+            if (e instanceof RafError)
+                return e.message;
+            throw e;
+        }
+        const dirty = await commitPlan(c, planMessage(c, PLAN_ACTIONS.reviewRecorded), l.repo, before);
         if (dirty)
             return dirty;
     }
@@ -2465,11 +2612,12 @@ async function writeVerdict(c, verdict, commit, reporte) {
     if (plan.readonly && c.config.verdict) {
         // La trace d'un verdict reporté va dans le texte, le seul endroit où l'outil du projet la lit (R23).
         const text = reporte ? `${verdict} ; verdict reporté : ${reporte.de.slice(0, 7)} → ${reporte.vers.slice(0, 7)} (patch-id identique)` : verdict;
+        const before = planBefore(c);
         const r = await sh(c, c.config.verdict.replaceAll('{lot}', l.lot).replaceAll('{verdict}', shEscape(text)), undefined, undefined, l.repo);
         if (r.code !== 0)
             l.warnings.push(`orchestrate.verdict en échec (code ${r.code}) : le lead reporte le verdict`);
         else {
-            const dirty = await commitPlan(c, `plan: ${l.lot} revue de code notée (orchestrate ${c.wave.id})`);
+            const dirty = await commitPlan(c, planMessage(c, PLAN_ACTIONS.reviewNoted), l.repo, before);
             if (dirty)
                 return dirty;
         }
@@ -2499,8 +2647,20 @@ function leadMoved(repo, base) {
     const dirty = trackedDirty(repo);
     return dirty.length ? `arbre du dépôt modifié (${dirty.join(', ')})` : null;
 }
+/** Un refus d'écrire le plan par Plan.save() (plan.onWrite en échec, L346) est la cause d'un lot rendu, pas une erreur du lot. */
+async function refusal(write) {
+    try {
+        return await write();
+    }
+    catch (e) {
+        if (e instanceof RafError)
+            return e.message;
+        throw e;
+    }
+}
 /** Une écriture de plan du programme (R21, R26) : sous la file et le verrou du dépôt, le dépôt encore sur la branche de départ, aucun fichier suivi modifié hors plan. Rend la cause du refus, null si l'écriture a eu lieu. Hors worktree, rien ne change. */
-async function planWrite(c, write) {
+async function planWrite(c, doWrite) {
+    const write = () => refusal(doWrite);
     if (!c.tree)
         return write();
     const l = c.lot;
@@ -2576,43 +2736,62 @@ async function integrateLot(c) {
         start = git(l.repo, 'rev-parse', `refs/heads/${t.base}`);
         // Une branche déjà contenue dans celle du dépôt (arrêt entre l'avance et l'écriture du verdict) : ni rebase ni avance, seul le plan reste à écrire (R23).
         if (!integrated(l.repo, t.branch, t.base)) {
+            // Le verdict de départ et le commit relu servent à chaque tour : un rebase rejoué repart d'eux, pas des traces ni du sommet du tour précédent.
+            const opening = verdict;
             const reviewed = l.code?.head ?? git(t.dir, 'rev-parse', 'HEAD');
-            const rebased = rebaseOnto(t.dir, t.base);
-            if (rebased.kind === 'conflict') {
-                return refuse(`intégration impossible : conflit en rebasant ${t.branch} sur ${t.base}${rebased.files.length ? ` (fichiers : ${rebased.files.join(', ')})` : ` (${rebased.detail})`} ; ${kept}`);
-            }
-            if (rebased.kind === 'rebased' && rebased.changelog > 0)
-                c.wave.log(`${key} CHANGELOG.md : conflit d'ajout pur résolu par union sous [Unreleased] (${rebased.changelog} commit(s))`);
-            const tip = git(t.dir, 'rev-parse', 'HEAD');
-            if (tip !== reviewed) {
-                // Le rebase a changé les commits : tests et build rejoués au sommet rebasé, avant que la branche du dépôt ne bouge (R7).
-                const { red, runs } = await integratedChecks(c, key);
-                l.checks = runs.length ? { head: tip, runs } : undefined;
-                save(c);
-                if (red.length)
-                    return refuse(`intégration refusée : tests rouges au sommet intégré (${red.map(redExcerpt).join(' ; ')}) ; branche du dépôt inchangée, ${kept}`);
-                const before = patchId(t.dir, mergeBase(t.dir, reviewed, t.base), reviewed);
-                const after = patchId(t.dir, t.base, 'HEAD');
-                if (before !== '' && before === after) {
-                    const vers = lotWork(histPlan(c), t.dir, l.lot)[0]?.sha ?? tip;
-                    reporte = { de: reviewed, vers, patchId: before };
+            for (let replays = 0;; replays++) {
+                verdict = opening;
+                reporte = undefined;
+                const rebased = rebaseOnto(t.dir, t.base);
+                if (rebased.kind === 'conflict') {
+                    return refuse(`intégration impossible : conflit en rebasant ${t.branch} sur ${t.base}${rebased.files.length ? ` (fichiers : ${rebased.files.join(', ')})` : ` (${rebased.detail})`} ; ${kept}`);
+                }
+                if (rebased.kind === 'rebased' && rebased.changelog > 0)
+                    c.wave.log(`${key} CHANGELOG.md : conflit d'ajout pur résolu par union sous [Unreleased] (${rebased.changelog} commit(s))`);
+                if (rebased.kind === 'rebased' && rebased.moved > 0)
+                    c.wave.log(`${key} CHANGELOG.md : ${rebased.moved} entrée(s) du lot replacée(s) sous [Unreleased], une publication a eu lieu pendant la branche`);
+                const tip = git(t.dir, 'rev-parse', 'HEAD');
+                if (tip !== reviewed) {
+                    // Le rebase a changé les commits : tests et build rejoués au sommet rebasé, avant que la branche du dépôt ne bouge (R7).
+                    const { red, runs } = await integratedChecks(c, key);
+                    l.checks = runs.length ? { head: tip, runs } : undefined;
+                    save(c);
+                    if (red.length)
+                        return refuse(`intégration refusée : tests rouges au sommet intégré (${red.map(redExcerpt).join(' ; ')}) ; branche du dépôt inchangée, ${kept}`);
+                    const before = patchId(t.dir, mergeBase(t.dir, reviewed, t.base), reviewed);
+                    const after = patchId(t.dir, t.base, 'HEAD');
+                    if (before !== '' && before === after) {
+                        const vers = lotWork(histPlan(c), t.dir, l.lot)[0]?.sha ?? tip;
+                        reporte = { de: reviewed, vers, patchId: before };
+                    }
+                    else {
+                        // Le diff du lot n'est plus celui qui a été relu (contexte modifié, conflit résolu) : une revue courte du diff rebasé avant l'avance (R17).
+                        const short = await shortReview(c);
+                        if (short === null)
+                            return;
+                        if (short.refused)
+                            return refuse(`intégration refusée : revue courte du diff rebasé : ${short.refused} ; branche du dépôt inchangée, ${kept}`);
+                        verdict = `${verdict}${SHORT_REVIEW_TRACE}${short.verdict}`;
+                        l.verdict = verdict;
+                    }
                 }
-                else {
-                    // Le diff du lot n'est plus celui qui a été relu (contexte modifié, conflit résolu) : une revue courte du diff rebasé avant l'avance (R17).
-                    const short = await shortReview(c);
-                    if (short === null)
-                        return;
-                    if (short.refused)
-                        return refuse(`intégration refusée : revue courte du diff rebasé : ${short.refused} ; branche du dépôt inchangée, ${kept}`);
-                    verdict = `${verdict}${SHORT_REVIEW_TRACE}${short.verdict}`;
-                    l.verdict = verdict;
+                // Les contrôles rejoués et la revue courte ont pu durer : le lead a pu changer de branche ou salir son arbre depuis le contrôle du départ (R24, R8).
+                const late = leadMoved(l.repo, t.base);
+                if (late)
+                    return refuse(`intégration refusée : ${late} ; branche du dépôt inchangée, ${kept}`);
+                try {
+                    advance(l.repo, t.branch);
+                    break;
+                }
+                catch (e) {
+                    // L364 : un commit est tombé sur la branche du dépôt pendant le rebase, les contrôles ou la revue courte (plan du lead, autre lot) : l'avance n'est plus une avance rapide.
+                    if (!baseMoved(l.repo, t.branch, t.base))
+                        throw e;
+                    if (replays >= MAX_REPLAYS)
+                        return refuse(`intégration refusée : ${t.base} a encore avancé après ${MAX_REPLAYS} rebases rejoués ; branche du dépôt inchangée par le lot, ${kept}`);
+                    c.wave.log(`${key} ${t.base} a avancé pendant l'intégration, rebase rejoué (${replays + 1}/${MAX_REPLAYS})`);
                 }
             }
-            // Les contrôles rejoués et la revue courte ont pu durer : le lead a pu changer de branche ou salir son arbre depuis le contrôle du départ (R24, R8).
-            const late = leadMoved(l.repo, t.base);
-            if (late)
-                return refuse(`intégration refusée : ${late} ; branche du dépôt inchangée, ${kept}`);
-            advance(l.repo, t.branch);
         }
         const end = git(l.repo, 'rev-parse', `refs/heads/${t.base}`);
         if (end !== start)

package/dist/orchestrate/decisions.js

@@ -9,6 +9,8 @@ const DECIDED = /(décision|décid|tranch|valid|arbitr|demand|veut|voulu|exig|re
  * un abandon (cli.ts `drop --reason`). Elles citent souvent l'utilisateur ou le lead sans porter aucune décision de l'humain.
  */
 const PROGRAM_NOTE = /^(\[[^\]\n]{1,40}\] )?(Hypothèses \(fiche |Revue de [^\n]{1,60}? — mineur : |titre remplacé : |remis en attente(\s*:|$)|abandonné : )/;
+/** Une note que le programme écrit (`PROGRAM_NOTE`) ou posée sur une sous-tâche (`[L5/T2] …`) : ce n'est pas le lead qui l'a écrite sur le lot. */
+export const isProgramNote = (text) => PROGRAM_NOTE.test(text) || /^\[[^\]\n]{1,40}\] /.test(text);
 const isDecision = (text) => !PROGRAM_NOTE.test(text) && WHO.test(text) && DECIDED.test(text);
 /**
  * Les décisions de l'humain écrites dans les notes d'un lot et de son parent (le parent d'abord), dans l'ordre du plan. Le texte est

package/dist/orchestrate/integrate.js

@@ -1,10 +1,10 @@
 import { execFileSync } from 'node:child_process';
-import { writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { gitCommonDir } from '../git.js';
 import { sharedStateDir } from '../state.js';
 import { activeLock, releaseLock, takeLock } from './lock.js';
-import { mergeUnreleased } from './changelog-merge.js';
+import { mergeUnreleased, moveToUnreleased } from './changelog-merge.js';
 import { mutexFor } from './mutex.js';
 import { git, gitFailure, tryGit } from './worktree.js';
 /** Verrou d'intégration d'un dépôt (L279, R10) : dans l'état commun aux worktrees, au format du verrou d'orchestration, sous un autre nom. */
@@ -12,6 +12,8 @@ export const INTEGRATION_LOCK = 'orchestrate-integration.lock';
 /** Attente du verrou d'intégration (R25) : une intégration dure un rebase et la relance des tests. */
 export const INTEGRATE_WAIT_MS = 10 * 60_000;
 export const INTEGRATE_POLL_MS = 1_000;
+/** Rebases rejoués quand la branche du dépôt avance pendant l'intégration (L364) : au-delà, le lot est rendu. */
+export const MAX_REPLAYS = 2;
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /**
  * Prend la main sur le dépôt pour une intégration ou une écriture de plan du programme (R10, R21, R26) : d'abord la file en mémoire du dépôt (les lots d'une
@@ -77,6 +79,24 @@ function resolveChangelog(work, start) {
         return false;
     }
 }
+/**
+ * Après un rebase réussi : les entrées que le lot a ajoutées sous `[Unreleased]` et qu'une publication de la branche a laissées sous la version publiée
+ * (git les y range sans conflit quand le bloc a été renommé) sont remises sous le `[Unreleased]` de la branche, dans un commit à part (L362). Rend leur nombre.
+ */
+function moveOwnEntries(work, base, before, start) {
+    if (start === undefined)
+        return 0;
+    const [tip, main] = [tryGit(work, 'show', `${before}:${CHANGELOG}`), tryGit(work, 'show', `refs/heads/${base}:${CHANGELOG}`)];
+    if (tip === null || main === null || !existsSync(join(work, CHANGELOG)))
+        return 0;
+    const fixed = moveToUnreleased(readFileSync(join(work, CHANGELOG), 'utf8'), tip, start, main);
+    if (!fixed)
+        return 0;
+    writeFileSync(join(work, CHANGELOG), fixed.text);
+    run(work, 'add', '--', CHANGELOG);
+    run(work, 'commit', '--no-verify', '-q', '-m', 'docs: CHANGELOG — les entrées du lot replacées sous [Unreleased] (une publication a eu lieu pendant la branche)');
+    return fixed.moved;
+}
 /**
  * Rebase le worktree `work` sur la branche `base` (R6). Une branche qui descend déjà du sommet de `base` n'a rien à rebaser (fast-forward pur : aucun sha ne
  * change). Un conflit d'ajout pur dans le CHANGELOG est résolu par union à chaque commit qui le porte (L314, `changelog` les compte). Tout autre conflit — ou
@@ -111,7 +131,8 @@ export function rebaseOnto(work, base) {
             }
         }
     }
-    return { kind: 'rebased', before, after: git(work, 'rev-parse', 'HEAD'), changelog };
+    const moved = moveOwnEntries(work, base, before, start);
+    return { kind: 'rebased', before, after: git(work, 'rev-parse', 'HEAD'), changelog, moved };
 }
 /**
  * Patch-id stable (`git patch-id --stable`) du diff cumulé de `from` à `to` (R9) : le même diff reste le même quand le contexte se déplace, il change quand
@@ -127,3 +148,5 @@ export function patchId(cwd, from, to) {
 export function advance(repo, branch) {
     git(repo, 'merge', '--ff-only', '--quiet', `refs/heads/${branch}`);
 }
+/** Vrai quand la branche du dépôt n'est plus un ancêtre de celle du lot : elle a avancé depuis le rebase, l'avance rapide est impossible (L364). */
+export const baseMoved = (repo, branch, base) => tryGit(repo, 'merge-base', '--is-ancestor', `refs/heads/${base}`, `refs/heads/${branch}`) === null;

package/dist/orchestrate/launch.js

@@ -9,6 +9,8 @@ import { SlotAbandoned } from './registry.js';
 import { TEST_WORKERS_ENV } from './workers.js';
 import { killMarked, SESSION_MARK_VAR, TreeTracker } from '../proc.js';
 import { isQuotaMessage, lacksStructuredOutput, parseSession, salvageUsage, sumTokens, tokensOf } from './result.js';
+/** Les alias que `claude --model` comprend sans connaître le compte : tout autre nom est passé tel quel (L345) et le dry-run en avertit. */
+export const MODEL_ALIASES = ['haiku', 'sonnet', 'opus'];
 /**
  * Serveurs MCP d'une étape : Playwright pour `ux` et `maquette` (revue des captures et du HTML local, L172) et, sur un lot `visible`, pour `spec` quand il a un écran `screen:` (rendu 1440/390 de la maquette, L171), `implement` et `fix` (fix-minors compris) ;
  * et `review-small` d'un petit lot visible (sa seule revue d'ergonomie) ; rien pour `review`, ni pour un lot sans écran.

package/dist/orchestrate/state.js

@@ -8,7 +8,7 @@ import { gitCommonDir, gitRoot } from '../git.js';
 export const LOCAL_PRECHECK_UNREADABLE = 'contrôle préalable : rapport du modèle local illisible';
 export const PRECHECK_UNREADABLE = 'contrôle préalable illisible, implémentation lancée';
 export function newLot(o) {
-    return { ...o, status: 'queued', pass: 0, next: null, steps: [], constats: [], verdict: null, uxVerdict: null, questions: [], choix: [], answers: [], proposals: [], warnings: [], outcome: null };
+    return { ...o, status: 'queued', pass: 0, next: null, steps: [], constats: [], verdict: null, uxVerdict: null, questions: [], choix: [], answers: [], proposals: [], warnings: [], instables: undefined, outcome: null };
 }
 /** Un lot fini ne travaille plus dans son dépôt : prêt, rendu ou échoué. */
 export const lotFinished = (l) => l.status === 'ready' || l.status === 'handed-back' || l.status === 'failed';