@sylad/cadence 1.12.1 → 1.14.1

package/dist/orchestrate/cycle.js

@@ -2,34 +2,39 @@ 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, 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 { 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';
 import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig } from './launch.js';
-import { cleanPlaywrightOutput, pushed, snapshot } from './guard.js';
+import { cleanPlaywrightOutput, pushed, remoteAdvances, snapshot } from './guard.js';
 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. */
@@ -109,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;
 }
 /**
@@ -136,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;
@@ -156,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;
@@ -195,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), ...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) }));
@@ -252,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;
     }
@@ -306,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;
 }
@@ -412,12 +481,14 @@ function avalOf(c, kind) {
     // la revue courte d'un petit lot visible est sa seule passe : elle porte aussi la conformité à la maquette
     return kind === 'review-small' && l.small && l.visible && screen ? `${text}\n${avalFicheText('ux', o)}` : text;
 }
+/** Consigne de la part de machine de la session (L350) ; vide quand la vague n'en a pas calculé. */
+const workersText = (c) => (c.wave.testWorkers ? testWorkersText(c.wave.testWorkers) : '');
 function briefFor(c, kind, local = false) {
     const plan = c.loadPlan();
     const l = c.lot;
     const lot = plan.lot(l.lot);
     const tmpDir = c.wave.store.tmpDir(l.project, l.lot);
-    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
+    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), workers: kind === 'implement' || kind === 'fix' ? workersText(c) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
         vars.news = newsText(l.lot, pwDir);
@@ -426,6 +497,11 @@ 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)
         vars.lecture = localReading({ ...lot, goal: l.goal ?? lot.goal });
     if (kind === 'spec') {
@@ -443,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}`;
@@ -494,7 +571,27 @@ function briefFor(c, kind, local = false) {
 /** Tokens comptés par les sessions d'un lot (un lot repris compte ses étapes d'avant). */
 export const lotSpent = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
 /** 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;
+const lotOver = (l) => l.budget !== undefined && lotSpent(l) >= l.budget - heldForEscalation(l);
+/**
+ * Coût réservé à l'escalade de modèle (L349) : une correction puis une revue neuve complète, jouées au modèle d'escalade. `lotBudget` l'ajoute au budget dérivé de
+ * l'estimate quand `orchestrate.escalation` est déclarée, comme REVIEW_RESERVE paie la dernière passe : sans elle, l'escalade (L337) ne jouait que sur les lots
+ * qui avaient peu consommé (cadence L341 494 k / 600 k et L342 572 k / 600 k, rendus « escalade fable non jouée (budget) »). ESTIMATION, aucune mesure : aucune
+ * escalade n'a été jouée depuis L337 (le seul journal qui en porte une, cadence L342, l'a laissée non jouée). Elle est déduite des journaux `.cadence/runs` du
+ * 2026-10-26 (823 passes fix : p90 67 k ; 1 009 revues complètes : p90 109 k), soit 176 k, arrondis à 175 k, au nombre de tokens comptés du modèle des passes
+ * (le comptage ne distingue pas le tarif du modèle). À remesurer sur les premières escalades jouées (`cadence perf`, « Escalade de modèle »).
+ */
+export const ESCALATION_RESERVE = 175_000;
+/** Part du budget que les passes ordinaires doivent laisser à l'escalade : retenue tant que l'escalade n'est pas engagée (ou écartée), libérée ensuite. */
+export const heldForEscalation = (l) => (l.escalation ? 0 : (l.escalationReserve ?? 0));
+/**
+ * Compteur du lot face au budget de ses passes ordinaires, pour les messages de refus (L349) : la part retenue pour l'escalade en est déduite et nommée
+ * (« 6000 / 160999 tokens comptés, 175000 retenus pour l'escalade sur 335999 »), sinon un refus dans cette part contredirait ses propres chiffres ; sans
+ * part retenue, le texte d'avant (« 6000 / 335999 tokens comptés »).
+ */
+const budgetCount = (l) => {
+    const held = heldForEscalation(l);
+    return `${lotSpent(l)} / ${(l.budget ?? 0) - held} tokens comptés${held ? `, ${held} retenus pour l'escalade sur ${l.budget}` : ''}`;
+};
 /**
  * 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
@@ -520,8 +617,8 @@ export function budgetStep(l) {
     const step = named ?? l.next;
     return step && step !== 'integrate' && 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;
+/** Le budget du lot paie-t-il la passe de correction et la revue courte qui la suit ? Sans budget de lot : toujours. La part de l'escalade (L349) n'est pas à dépenser, sauf pour décider l'escalade elle-même (`escalating`). */
+const fixAffordable = (l, escalating = false) => l.budget === undefined || lotSpent(l) + REVIEW_RESERVE < l.budget - (escalating ? 0 : heldForEscalation(l));
 /** Cause d'une suspension demandée par `--stop-after-current` (L79). */
 export const STOP_REQUESTED = 'arrêt demandé (--stop-after-current)';
 /** Le lot a-t-il été écarté de la vague par `--drop` (L79) ? */
@@ -642,6 +739,7 @@ async function session(c, kind, local = false) {
         prodAccess: c.config.prodAccess,
         addDirs: [...c.config.addDirs, ...(playwright && write ? [playwrightDir(dirname(mcpConfig))] : []), tmpDir, ...neighbourDirs(l), ...(kind === 'fix' && l.docsFix ? (docsConfig(c).articles ?? []).map((r) => articleRepoDir(l.repo, r)) : [])],
         nodeBin: l.node?.link,
+        testWorkers: w.testWorkers,
         toolBin: toolBinOf(w.store.dir),
         tmpDir,
         mcpConfig,
@@ -826,10 +924,13 @@ async function session(c, kind, local = false) {
     const others = neighbours.map((repo, i) => ({ repo, before: beforeOthers[i], after: afterOthers[i] }));
     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: wd(c), before, after }, ...others.map((o) => ({ where: ` dans ${o.repo.rel}`, path: o.repo.path, before: o.before, after: o.after }))];
+    const watched = [{ where: '', path: wd(c), repo: c.lot.repo, before, after }, ...others.map((o) => ({ where: ` dans ${o.repo.rel}`, path: o.repo.path, repo: o.repo.path, before: o.before, after: o.after }))];
     // 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)) {
+    for (const { where, repo, before: b, after: a } of watched) {
+        const delivered = pushed(b, a) ? leadDelivery(c, repo, b, a) : null;
+        if (delivered)
+            w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} : push du lead (livraison ${delivered.length ? `de ${delivered.join(', ')}` : 'du plan'}) toléré${where}`);
+        else if (pushed(b, a)) {
             step.status = 'failed';
             step.cause = `push détecté${where}`;
             w.incident = `push détecté${where} pendant ${lotKey(l.project, l.lot)} (${kind})`;
@@ -949,6 +1050,40 @@ function headStranded(path, b, a) {
     }
     return null;
 }
+/**
+ * Le push du lead pour livrer un lot prêt de la vague (L352) : `git push origin <sha>:main`, le chemin « livrable jusqu'à <sha> » du skill lead.
+ * Toléré quand chaque branche distante qui a bougé avance en avant (ou est créée) vers un sha ancêtre du HEAD du dépôt et que ce sha ne contient aucun
+ * commit d'un lot de la vague qui n'est pas prêt (la garde de `deliver --sha`, `blockingLots`) : ne restent que des commits de lots prêts ou du plan.
+ * Renvoie les lots prêts livrés (vide : du plan seulement) ; null pour tout autre push, qui reste un incident — dont une branche supprimée, un push
+ * forcé, un sha hors de l'histoire de HEAD ou des commits d'un lot en cours ou illisibles.
+ */
+function leadDelivery(c, repo, before, after) {
+    const moved = remoteAdvances(before, after);
+    if (!moved)
+        return null;
+    const lots = c.wave.store.lots().filter((x) => lotKey(x.project, x.lot) !== lotKey(c.lot.project, c.lot.lot));
+    const here = [c.lot, ...lots].filter((x) => x.repo === repo || (x.repos ?? []).some((r) => r.path === repo));
+    const delivered = new Set();
+    for (const { from, to } of moved) {
+        if (!isAncestor(repo, to, 'HEAD') || (from !== null && !isAncestor(repo, from, to)))
+            return null;
+        const { blocking, unreadable } = blockingLots(here, repo, to);
+        if (blocking.length > 0 || unreadable.length > 0)
+            return null;
+        for (const x of here) {
+            if (x.status !== 'ready')
+                continue;
+            try {
+                if (gitCommitsIn(x, repo).some((k) => isAncestor(repo, k, to) && (from === null || !isAncestor(repo, k, from))))
+                    delivered.add(lotKey(x.project, x.lot));
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return [...delivered];
+}
 /** 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;
@@ -1035,7 +1170,7 @@ 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 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})`;
+    const why = reserve ? `budget du lot : ${budgetCount(l)} (${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 (${budgetCount(l)}, ${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). Sans passe jouée, un lot repris déjà revu compte ses tests rouges depuis la revue de sa branche ; jamais revu (L315), c'est l'implémentation qui les a laissés.
@@ -1397,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) {
@@ -1539,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}`);
@@ -1570,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}`);
@@ -1841,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.
@@ -2053,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');
@@ -2074,7 +2278,7 @@ async function work(c, kind) {
             if (l.pass >= MAX_PASSES - 1)
                 l.warnings.push(`porte « code sans test » non jouée : ${l.pass} passe(s) de correction déjà faite(s), la correction prendrait la dernière et la revue arriverait sans passe pour ses majeurs (${missing.join(', ')})`);
             else if (!fixAffordable(l))
-                l.warnings.push(`porte « code sans test » non jouée : budget du lot (${lotSpent(l)} / ${l.budget} tokens comptés), il ne reste pas de quoi payer la correction et la revue qui la suit (${missing.join(', ')})`);
+                l.warnings.push(`porte « code sans test » non jouée : budget du lot (${budgetCount(l)}), il ne reste pas de quoi payer la correction et la revue qui la suit (${missing.join(', ')})`);
             else {
                 toFix(c, [{ source: 'code', gravite: 'majeur', fichier: missing[0], texte: `code modifié sans test (orchestrate.testGate, vérifié par le programme) : ${missing.join(', ')} — aucun fichier de test touché par les commits du lot. Écris les tests de chaque règle modifiée, nommés d'après la règle (test d'abord), puis commite avec le lot cité.` }], 'code sans test');
                 return;
@@ -2090,7 +2294,7 @@ async function work(c, kind) {
             if (l.pass >= MAX_PASSES - 1)
                 l.warnings.push(`bibliothécaire non appelé : ${l.pass} passe(s) de correction déjà faite(s), sa passe prendrait la dernière et la revue arriverait sans passe pour ses majeurs (${late})`);
             else if (!fixAffordable(l))
-                l.warnings.push(`bibliothécaire non appelé : budget du lot (${lotSpent(l)} / ${l.budget} tokens comptés), il ne reste pas de quoi payer sa passe et la revue qui la suit (${late})`);
+                l.warnings.push(`bibliothécaire non appelé : budget du lot (${budgetCount(l)}), il ne reste pas de quoi payer sa passe et la revue qui la suit (${late})`);
             else {
                 l.docsFix = true;
                 toFix(c, gaps.map((g) => ({ source: 'code', gravite: 'majeur', fichier: g.touched[0], texte: gapMessage(l.lot, g) })), 'documentation en retard');
@@ -2145,7 +2349,7 @@ function toFix(c, constats, what) {
             stop(c, 'handed-back', text);
             return;
         }
-        if (!fixAffordable(l)) {
+        if (!fixAffordable(l, true)) {
             l.escalation = { model: esc.model, stage: 'done', issue: 'non jouée' };
             c.wave.log(`${lotKey(l.project, l.lot)} · escalade ${esc.model} non jouée : budget du lot (${lotSpent(l)} / ${l.budget} tokens comptés)`);
             stop(c, 'handed-back', `${text} ; escalade ${esc.model} non jouée (budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés, il ne reste pas de quoi payer la correction et la revue)`);
@@ -2383,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;
     }
@@ -2400,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;
         }
@@ -2434,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;
@@ -2511,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}`);
                 }
-                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;
+                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;
+                    }
+                }
+                // 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)