@sylad/cadence 1.8.0 → 1.10.0

package/dist/orchestrate/cycle.js

@@ -1,30 +1,37 @@
-import { execFileSync, spawn } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { parse } from 'yaml';
 import { toolBinOf, withoutLaunchVars } from './snapshot.js';
 import { randomUUID } from 'node:crypto';
-import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
-import { copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
+import { 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 { docSyncBrief, docSyncGaps, filesOf } from '../docsync.js';
-import { changedFiles, readCommits, resolveCommit } from '../git.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 { citedRefs } from '../link.js';
 import { repoShas, repoWork } from '../repos.js';
 import { isOpen } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
 import { compareBaseline, failedTests, hasUnnamedFailure } from './baseline.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
-import { capturesText, newsText, objective, renderBrief, reposText, TEMPLATES_DIR } from './briefs.js';
+import { 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 { 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 { 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, hypothesisNote, specText } from './spec.js';
-import { lotKey, lotRepoPaths, neighbourDirs } from './state.js';
+import { answeredText, checkSpec, costlyHypotheses, ficheHasBack, ficheReady, findFiche, hypothesisLines, answerAltersRule, hypothesisNote, LEAD_SOURCE, ruleIdsSourcedByLead, sourceRules, specText } from './spec.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 { 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. */
 export const MAX_PASSES = 2;
 /** Plafond quand la revue converge (L205) : le nombre de bloquants+majeurs a baissé d'une revue à l'autre et il n'en reste qu'un. */
@@ -60,16 +67,15 @@ export function countInterrupted(claudeHome, repo, step, budget) {
     return true;
 }
 const TERMINAL = new Set(['ready', 'handed-back', 'failed']);
+/**
+ * Où le lot travaille (L279) : son worktree quand il en a un, sinon le dépôt du projet. Tout ce que le cycle lit ou écrit du travail du lot — sessions,
+ * commits, contrôles, fiche, acceptation — passe par là ; le plan, lui, n'est jamais lu ni écrit ici que dans le dépôt du projet (`c.lot.repo`, R21).
+ */
+export const workDir = (c) => (c.tree?.active ? c.tree.dir : c.lot.repo);
+const wd = workDir;
+/** Le plan tel que les lectures d'historique (lotWork, isPlanOnly, coveredTasks, unreviewedWork) le voient depuis `wd(c)` : son chemin est celui du fichier correspondant dans le worktree (R21). */
+const histPlan = (c) => (wd(c) === c.lot.repo ? c.loadPlan() : planSeenFrom(c.loadPlan(), c.lot.repo, wd(c)));
 const short = (c) => `${c.sha.slice(0, 7)} ${c.subject}`;
-function git(repo, ...args) {
-    return execFileSync('git', args, { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
-}
-/** Le message d'une commande git qui a échoué : sa sortie d'erreur (sur une ligne), à défaut le message de l'exception. */
-function gitFailure(e) {
-    const err = e.stderr;
-    const text = typeof err === 'string' && err.trim() ? err : e instanceof Error ? e.message : String(e);
-    return text.trim().replace(/\s*\n\s*/g, ' ');
-}
 function save(c) {
     c.wave.store.writeLot(c.lot);
 }
@@ -89,14 +95,14 @@ const stop = (c, status, outcome) => {
 function trackedPaths(s) {
     return s.tracked.map((l) => l.slice(3).replace(/^.* -> /, '').replace(/^"|"$/g, ''));
 }
-/** Commit d'entretien du plan, chemins explicites. Rend un message d'arbre sale quand autre chose que le plan a bougé. */
-async function commitPlan(c, message) {
-    const repo = c.lot.repo;
-    const plan = c.loadPlan();
-    const own = new Set([relative(repo, plan.path), ...plan.maintained]);
-    // Les acceptation.json (L173) rejoignent les fichiers que le cycle a le droit de commiter : il y pose le scellé et `vert: true`.
-    const specDir = `${c.config.spec.dir.replace(/\/+$/, '')}/`;
-    const ownFile = (f) => own.has(f) || (f.startsWith(specDir) && isAcceptationFile(f));
+/**
+ * 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.
+ */
+async function commitPlan(c, message, root = c.lot.repo) {
+    const repo = root;
+    const ownFile = planOwnFile(c, repo);
     const dirty = trackedPaths(await snapshot(repo, { remote: false }));
     if (dirty.length === 0)
         return null;
@@ -111,57 +117,7 @@ async function commitPlan(c, message) {
  * Sha d'où le lot est parti : le parent de son plus ancien commit de travail (un lot relancé, ou déjà en partie commité, a ses propres
  * commits avant la vague), à défaut le HEAD d'avant la première session de la vague.
  */
-const startSha = (c) => lotStartHead(c.lot.repo, lotWork(c.loadPlan(), c.lot.repo, c.lot.lot).map((k) => k.sha)) ?? c.lot.steps.find((s) => s.headBefore)?.headBefore;
-/** Dossiers ignorés de sortie de build : jamais liés dans le worktree jetable, une commande de tests qui y écrit toucherait le build du lot. */
-const OUTPUT_DIRS = new Set(['dist', 'build', 'out', 'coverage', 'target', '.next', '.nuxt', '.output', '.angular', '.turbo', '.svelte-kit', '.parcel-cache']);
-/**
- * Un `node_modules` dans le worktree de base (L213) : un vrai dossier dont chaque entrée est un lien vers celle du dépôt vivant, SAUF les liens
- * de workspace (npm, pnpm, yarn : `node_modules/@x/shared -> ../../packages/shared`) qui pointent vers du code du dépôt hors de tout
- * `node_modules`. Lier le dossier d'un bloc les ferait résoudre dans le dépôt vivant, donc exécuter le code du lot au lieu de celui du sha de
- * départ ; ils sont refaits vers la copie du worktree (absente au sha de départ : pas de lien). Les dossiers de portée `@x` sont parcourus,
- * pas les paquets. Ajoute chaque lien créé à `links`.
- */
-function mirrorNodeModules(repo, dir, name, links) {
-    const repoReal = realpathSync(repo);
-    const workspaceCopy = (live) => {
-        let real;
-        try {
-            real = realpathSync(live);
-        }
-        catch {
-            return null; // lien mort dans le dépôt vivant : rien à refaire
-        }
-        const rel = relative(repoReal, real);
-        if (!rel || rel.startsWith('..') || isAbsolute(rel) || rel.split(sep).includes('node_modules'))
-            return null;
-        return join(dir, rel);
-    };
-    const link = (target, at) => {
-        symlinkSync(target, at);
-        links.push(at);
-    };
-    const mirror = (liveDir, to, scope) => {
-        mkdirSync(to);
-        for (const e of readdirSync(liveDir, { withFileTypes: true })) {
-            const live = join(liveDir, e.name);
-            const at = join(to, e.name);
-            if (e.isSymbolicLink()) {
-                const copy = workspaceCopy(live);
-                if (copy) {
-                    if (existsSync(copy))
-                        link(copy, at);
-                    continue;
-                }
-            }
-            else if (!scope && e.isDirectory() && e.name.startsWith('@')) {
-                mirror(live, at, true);
-                continue;
-            }
-            link(live, at);
-        }
-    };
-    mirror(join(repo, name), join(dir, name), false);
-}
+const startSha = (c) => lotStartHead(wd(c), lotWork(histPlan(c), wd(c), c.lot.lot).map((k) => k.sha)) ?? c.lot.steps.find((s) => s.headBefore)?.headBefore;
 /**
  * É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
@@ -180,20 +136,11 @@ async function baselineFailures(c, command) {
     const links = [];
     try {
         git(l.repo, 'worktree', 'add', '--detach', '-f', dir, sha);
-        // Tous niveaux : en monorepo les dépendances vivent dans packages/*/node_modules. `--directory` ne descend pas dans un dossier ignoré, donc
-        // chaque entrée est le dossier ou fichier ignoré le plus haut ; son parent doit exister au sha de départ (sinon rien où le relier).
-        const ignored = git(l.repo, 'ls-files', '--others', '--ignored', '--exclude-standard', '--directory').split('\n').map((f) => f.replace(/\/$/, '')).filter((f) => f && !f.startsWith('.cadence') && !f.split('/').some((p) => OUTPUT_DIRS.has(p)));
-        for (const name of ignored) {
-            const to = join(dir, name);
-            if (existsSync(to) || !existsSync(dirname(to)))
-                continue;
-            if (basename(name) === 'node_modules' && lstatSync(join(l.repo, name)).isDirectory()) {
-                mirrorNodeModules(l.repo, dir, name, links);
-                continue;
-            }
-            symlinkSync(join(l.repo, name), to);
-            links.push(to);
-        }
+        links.push(...linkIgnored(l.repo, dir));
+        // Le build d'abord, comme dans la porte (L333) : les tests lisent ce qu'il produit (`dist`), le départ sans lui rougirait tout. Un build rouge au départ
+        // ne dit rien des tests : pas de ligne de base, l'appelant garde les tests pour rouges.
+        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);
         l.baseline = { sha, command, failures, verified: true };
@@ -234,7 +181,7 @@ 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. */
-function sh(c, command, timeoutMs = 30 * 60_000, env = {}, cwd = c.lot.repo) {
+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 pid = child.pid;
@@ -283,7 +230,7 @@ async function startLot(c) {
         if (plan.readonly) {
             if (!c.config.start)
                 return 'plan en lecture seule : démarrer le lot avec l\'outil du projet';
-            const r = await sh(c, c.config.start.replaceAll('{lot}', c.lot.lot));
+            const r = await sh(c, c.config.start.replaceAll('{lot}', c.lot.lot), undefined, undefined, c.lot.repo);
             if (r.code !== 0)
                 return `orchestrate.start en échec (code ${r.code}) : ${r.output.trim().split('\n').slice(-3).join(' ')}`;
         }
@@ -298,14 +245,14 @@ async function startLot(c) {
     return null;
 }
 function lotCommitLines(c) {
-    const plan = c.loadPlan();
-    const mine = lotWork(plan, c.lot.repo, c.lot.lot).reverse().map((k) => `- ${short(k)}`);
+    const plan = histPlan(c);
+    const mine = lotWork(plan, wd(c), c.lot.lot).reverse().map((k) => `- ${short(k)}`);
     const theirs = (c.lot.repos ?? []).flatMap((r) => repoWork(plan, r, c.lot.lot).reverse().map((k) => `- [${r.rel}] ${short(k)}`));
     return [...mine, ...theirs].join('\n');
 }
 /** Le lot a déjà du travail (commits citant le lot) dans son dépôt ou dans un dépôt voisin. */
-function hasWork(plan, l) {
-    return lotWork(plan, l.repo, l.lot).length > 0 || (l.repos ?? []).some((r) => repoWork(plan, r, l.lot).length > 0);
+function hasWork(plan, root, l) {
+    return lotWork(plan, root, l.lot).length > 0 || (l.repos ?? []).some((r) => repoWork(plan, r, l.lot).length > 0);
 }
 function constatLines(constats) {
     return constats
@@ -313,9 +260,10 @@ function constatLines(constats) {
         .join('\n');
 }
 /** Consigne de captures : `uxText` n'alimente que `ux` et `review-small` d'un petit lot visible, deux étapes qui chargent toujours le serveur Playwright de la vague. */
-const SHOTS_TEXT = 'Take screenshots at 1440 and 390 px width, each with a relative file name only (e.g. `home-1440px.png`): they land in the wave\'s capture directory, outside the repository.';
+const shotsAt = (dir) => `Take screenshots at 1440 and 390 px width, in the wave's capture directory (outside the repository), each named with its full path, e.g. \`${dir}/home-1440px.png\`.`;
 function uxText(c) {
     const ux = c.config.ux;
+    const SHOTS_TEXT = shotsAt(playwrightDir(c.wave.store.lotDir(c.lot.project, c.lot.lot)));
     if (!ux) {
         return 'No way to run the app is declared (cadence.yaml: orchestrate.ux): review the interface from the code, and list under "nonVerifie" what you could not see.';
     }
@@ -342,28 +290,43 @@ function checksText(c) {
     // Sans orchestrate.test aucun rejeu : la base annoncée par la session (non vérifiée) est la seule trace des échecs de départ ; elle s'ajoute aux runs du programme (le build), elle ne les remplace pas.
     const declared = b && !b.verified && b.failures.length ? `The author reports ${b.failures.length} test(s) already red at the start sha${b.sha ? ` ${b.sha.slice(0, 7)}` : ''}, before this lot (not verified by the program):\n${b.failures.map((t) => `- ${t}`).join('\n')}\nThey are not defects of this lot, do not report them as findings; a failing test outside this list is still a finding.` : '';
     const k = c.lot.checks;
-    if (!k?.runs.length || k.head !== git(c.lot.repo, 'rev-parse', 'HEAD'))
+    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 ran = [`The program already ran these checks at HEAD ${k.head.slice(0, 7)}, just before this review:`, ...runs, 'Take these results as given: do not rebuild, do not rerun the whole suite, and do not wait on them. Run only a check they do not cover (a targeted test of a case you doubt), and list under "nonVerifie" what neither they nor you verified.'].join('\n');
     return declared ? `${ran}\n${declared}` : ran;
 }
-/** Consigne docs.sync du brief de revue (L143) : calculée sur les commits du lot au moment de la revue, pas écrite d'avance. */
+/** La clé `docs` du cadence.yaml du projet de ce lot. */
+const docsConfig = (c) => readDocsConfig(histPlan(c).configFile ?? join(wd(c), 'cadence.yaml'));
+/** Écarts docs.sync des commits du lot (L143), calculés au moment de la demande : ni gardés ni écrits d'avance. Un écart acquitté et motivé (`raf docs-ok`, L317) n'en est plus un. */
+function docGaps(c) {
+    const { sync } = docsConfig(c);
+    const plan = histPlan(c);
+    const acknowledged = !!plan.lots().find((x) => x.id === c.lot.lot)?.docsOk;
+    return { sync, gaps: sync.length && !acknowledged ? docSyncGaps(sync, filesOf(wd(c), lotWork(plan, wd(c), c.lot.lot))) : [] };
+}
+/** Cause du renvoi au lead d'un lot dont l'écart docs.sync est ouvert (L317), null sans écart. */
+function openDocGap(c) {
+    const { gaps } = docGaps(c);
+    if (!gaps.length)
+        return null;
+    return `documentation en retard (docs.sync) : ${gaps.flatMap((g) => g.touched).join(', ')} sans la documentation attendue, et aucun écart acquitté — écrire la documentation, ou \`raf docs-ok ${c.lot.lot} --reason "…"\` si elle reste vraie`;
+}
+/** Consigne docs.sync du brief de revue (L143). */
 function docsText(c) {
-    const plan = c.loadPlan();
-    const { sync } = readDocsConfig(plan.configFile ?? join(c.lot.repo, 'cadence.yaml'));
-    if (!sync.length)
-        return '';
-    return docSyncBrief(sync, docSyncGaps(sync, filesOf(c.lot.repo, lotWork(plan, c.lot.repo, c.lot.lot))));
+    const { sync, gaps } = docGaps(c);
+    return sync.length ? docSyncBrief(sync, gaps) : '';
 }
 /** Gabarit d'une étape : la passe des mineurs et la revue courte qui la suit ont chacune le leur. */
-export function briefName(l, kind) {
+export function briefName(l, kind, integration = false) {
     if (l.specLot && !l.screen && (kind === 'spec' || kind === 'accept'))
         return `${kind}-back`;
+    if (kind === 'fix' && l.docsFix)
+        return 'fix-docs';
     if (kind === 'fix' && l.minorFix)
         return 'fix-minors';
-    if (kind === 'review-small' && l.minorPass && !(l.small && l.visible))
-        return 'review-recheck';
+    if (kind === 'review-small' && l.minorPass && !integration && !(l.small && l.visible))
+        return 'review-recheck'; // la revue d'intégration (R17) garde le gabarit qui porte {{integration}}
     return kind;
 }
 /** Gabarit de fiche livré avec le paquet, joint au brief de la spec (la session ne lit pas le dossier du paquet). */
@@ -390,7 +353,7 @@ const hasSpecStage = (l) => !!(l.screen || l.specLot);
  * Les parties que la fiche du lot doit avoir : l'écran d'un lot à `screen:`, le sujet d'un lot à `spec: true` (sans écran). Un lot mixte est un lot
  * `screen:` dont la FICHE a une partie back (bloc `sujet`, décision du lead) : la fiche écrite le dit, pas un champ du plan.
  */
-const partsOf = (l, fiche) => ({ screen: !!l.screen, back: !!l.specLot || (!!l.screen && !!fiche && ficheHasBack(l.repo, fiche)) });
+const partsOf = (c, fiche) => ({ screen: !!c.lot.screen, back: !!c.lot.specLot || (!!c.lot.screen && !!fiche && ficheHasBack(wd(c), fiche)) });
 /** Gabarit du lanceur de tests livré avec le paquet, joint au brief de l'étape accept. */
 function acceptRunner() {
     try {
@@ -403,7 +366,7 @@ function acceptRunner() {
 /** Fiche du lot : celle de l'étape spec, ou la fiche retrouvée dans le dépôt (reprise). */
 function ficheOf(c) {
     const l = c.lot;
-    return l.spec && 'fiche' in l.spec ? l.spec.fiche : findFiche(l.repo, c.config.spec.dir, l.lot);
+    return l.spec && 'fiche' in l.spec ? l.spec.fiche : findFiche(wd(c), c.config.spec.dir, l.lot);
 }
 /**
  * Consigne de la fiche pour les étapes en aval d'un lot qui en a une (L174) : implement, fix, revue de code, UX de conformité.
@@ -419,7 +382,7 @@ function avalOf(c, kind) {
     let contracts;
     let screen;
     try {
-        const doc = parse(readFileSync(join(l.repo, fiche), 'utf8'));
+        const doc = parse(readFileSync(join(wd(c), fiche), 'utf8'));
         rules = ficheRules(doc);
         contracts = ficheContracts(doc);
         screen = hasScreenPart(doc);
@@ -429,27 +392,32 @@ function avalOf(c, kind) {
     }
     if (!rules.length || (step === 'ux' && !screen))
         return '';
-    const acceptation = l.accept?.acceptation ?? findAcceptation(l.repo, c.config.spec.dir, l.lot) ?? undefined;
+    const acceptation = l.accept?.acceptation ?? findAcceptation(wd(c), c.config.spec.dir, l.lot) ?? undefined;
     const o = { fiche, rules, acceptation, rouge: l.accept?.rouge, contracts, screen };
     const text = avalFicheText(step, o);
     // la revue courte d'un petit lot visible est sa seule passe : elle porte aussi la conformité à la maquette
     return kind === 'review-small' && l.small && l.visible && screen ? `${text}\n${avalFicheText('ux', o)}` : text;
 }
-function briefFor(c, kind) {
+function briefFor(c, kind, local = false) {
     const plan = c.loadPlan();
     const l = c.lot;
     const lot = plan.lot(l.lot);
-    const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), 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: '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []) };
+    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) : '' };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
         vars.news = newsText(l.lot, pwDir);
         vars.captures = capturesText(pwDir);
     }
+    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) : '';
+    if (kind === 'precheck' && local)
+        vars.lecture = localReading({ ...lot, goal: l.goal ?? lot.goal });
     if (kind === 'spec') {
         const reviewed = [...(l.ficheConstats ?? []), ...(l.maquetteConstats ?? [])];
         const written = ficheOf(c);
-        const back = partsOf(l, written).back;
+        const back = partsOf(c, written).back;
         const session = { run: (l.specRuns ?? 0) + 1, max: specBudget(c) };
         vars.spec = specText({
             dir: c.config.spec.dir,
@@ -465,7 +433,7 @@ function briefFor(c, kind) {
         if (mine)
             vars.commits = `Commits of the lot already present (do not redo them; fix or complete the spec from them):\n${mine}`;
         if (l.pendingAnswer)
-            vars.reponse = l.specAsked?.length ? answeredText(l.specAsked, l.pendingAnswer) : `Answer from the human to your earlier question: ${l.pendingAnswer}`;
+            vars.reponse = l.specAsked?.length ? answeredText(l.specAsked, l.pendingAnswer, ruleIdsSourcedByLead(wd(c), ficheOf(c) ?? '', l.specAskedRules ?? [])) : `Answer from the human to your earlier question: ${l.pendingAnswer}`;
     }
     if (kind === 'fiche') {
         vars.fiche = ficheReviewText({ fiche: ficheOf(c) ?? '', passes: l.fiche?.passes ?? 0, previous: l.ficheConstats });
@@ -478,7 +446,7 @@ function briefFor(c, kind) {
     if (kind === 'accept') {
         const fiche = ficheOf(c) ?? '';
         const folder = posix.dirname(fiche);
-        vars.accept = acceptText({ fiche, maquette: `${folder}/maquette.html`, screen: !!l.screen, back: !!l.screen && partsOf(l, fiche).back, acceptation: acceptationFile(fiche, l.lot), command: c.config.accept ?? '', test: c.config.test, runner: acceptRunner(), problems: l.acceptProblems });
+        vars.accept = acceptText({ fiche, maquette: `${folder}/maquette.html`, screen: !!l.screen, back: !!l.screen && partsOf(c, fiche).back, acceptation: acceptationFile(fiche, l.lot), command: c.config.accept ?? '', test: c.config.test, runner: acceptRunner(), problems: l.acceptProblems });
         vars.objectif = ''; // l'oracle est écrit depuis la fiche et la maquette seules, pas depuis le texte du lot
         vars.commits = '';
         if (l.pendingAnswer)
@@ -489,6 +457,12 @@ function briefFor(c, kind) {
         if (kind === 'fix') {
             vars.commits = lotCommitLines(c);
             vars.constats = constatLines(l.constats);
+            if (l.docsFix) {
+                vars.elsewhere = articlesBrief(l.repo, docsConfig(c).articles ?? []);
+                vars.ack = wd(c) === l.repo
+                    ? `run \`raf docs-ok ${l.lot} --reason "why the documentation stays true"\` (a reason is required), then commit the plan file alone (\`git add -- .cadence/raf.yaml\`, or the path of the plan; message \`chore(${l.lot}): docs-ok\`).`
+                    : `this is a worktree, where only the program writes the plan: do not run \`raf docs-ok\` and do not touch the plan file. Make no commit and say under "choix" why the documentation stays true: the lot is handed back to the lead, who acknowledges it in the main checkout (\`raf docs-ok ${l.lot} --reason "…"\`).`;
+            }
         }
         else if (interrupted) {
             const mine = lotCommitLines(c);
@@ -501,7 +475,7 @@ function briefFor(c, kind) {
         if (l.pendingAnswer)
             vars.reponse = `Answer from the human to your earlier question: ${l.pendingAnswer}`;
     }
-    return renderBrief(briefName(l, kind), vars, c.wave.templates);
+    return renderBrief(briefName(l, kind, !!c.integration), vars, c.wave.templates);
 }
 /** 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);
@@ -530,7 +504,7 @@ export function budgetStep(l) {
         return null;
     const named = /étape « ([\w-]+) » non jouée/.exec(l.outcome ?? '')?.[1];
     const step = named ?? l.next;
-    return step && WRITE_STEPS.includes(step) ? step : null;
+    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;
@@ -539,6 +513,8 @@ export const STOP_REQUESTED = 'arrêt demandé (--stop-after-current)';
 /** Le lot a-t-il été écarté de la vague par `--drop` (L79) ? */
 const dropped = (c) => c.wave.store.control().drops.includes(lotKey(c.lot.project, c.lot.lot));
 export const DROPPED = 'retiré de la vague (--drop)';
+/** Mention de la réponse du lead restée en attente : un lot rendu sans que la session l'ait lue le dit (comme overBudget). */
+const unplayedAnswer = (l) => (l.pendingAnswer ? ` ; la réponse du lead (« ${l.pendingAnswer} ») n'a pas été jouée` : '');
 /** Pourquoi plus aucune session ne doit partir (incident, quota, budget), sinon null. */
 function halted(w, lot) {
     if (w.store.control().stopAfterCurrent)
@@ -565,14 +541,17 @@ function reviewModel(c, kind) {
     const { light, full } = c.config.review;
     return c.lot.light && c.lot.pass === 0 && (kind === 'review' || kind === 'review-small') ? light : full;
 }
-/** Une session : budget et quota vérifiés avant, état écrit avant et après, journal gardé, contrôles du dépôt après. */
+/** Écarte le modèle local pour le reste de la vague (L322) : le premier échec suffit, les lots suivants n'attendent pas de le constater à leur tour. */
+function benchLocal(c, cause) {
+    c.wave.localOut ??= cause.slice(0, 200);
+}
 /** Rendu par `session(…, true)` quand l'étape locale n'a rien donné (Ollama éteint, délai, rapport sans structure) : l'appelant se replie sur Sonnet (L146). */
 const LOCAL_FAILED = Symbol('local-failed');
 async function session(c, kind, local = false) {
     const w = c.wave;
     const l = c.lot;
     if (dropped(c))
-        return stop(c, 'handed-back', DROPPED);
+        return stop(c, 'handed-back', DROPPED + unplayedAnswer(l));
     const halt = halted(w, l);
     if (halt)
         return suspend(c, halt);
@@ -582,7 +561,7 @@ async function session(c, kind, local = false) {
         return overBudget(c, kind === 'fix' && !lotOver(l));
     const model = kind === 'spec' || kind === 'accept' || kind === 'fiche' ? 'sonnet' : write ? l.model : local ? 'local' : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
     const effort = c.config.effort[kind === 'review-small' ? 'review' : kind];
-    const before = await snapshot(l.repo);
+    const before = await snapshot(wd(c));
     const neighbours = l.repos ?? [];
     const beforeOthers = await Promise.all(neighbours.map((r) => snapshot(r.path)));
     const n = l.steps.length + 1;
@@ -594,7 +573,7 @@ async function session(c, kind, local = false) {
     w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} (${model})`);
     let brief;
     try {
-        brief = briefFor(c, kind);
+        brief = briefFor(c, kind, local);
     }
     catch (e) {
         step.status = 'failed';
@@ -605,7 +584,31 @@ async function session(c, kind, local = false) {
     const playwright = !!mcpServersFor(kind, l.visible, '', l.small, !!l.screen).playwright;
     if (playwright)
         l.uxCaptures = join(dirname(mcpConfig), 'playwright');
+    const answerInBrief = l.pendingAnswer; // gardée pour la rendre si la session ne part jamais (créneau abandonné, L332)
     l.pendingAnswer = null; // la réponse est dans le brief : elle ne repart pas avec la session suivante
+    const tmpDir = w.store.tmpDir(l.project, l.lot); // TMPDIR de la session, aussi en --add-dir : hors du cwd, un Write y serait refusé en `claude -p`
+    // Délai (L298) : l'étape d'écriture est proportionnée à l'estimate et à la fiche du lot, puis prolongée à chaque échéance où elle a commité.
+    const delay = write ? workTimeoutMs(c.config.timeouts.work, l.estimate, hasSpecStage(l)) : c.config.timeouts.review;
+    let seenHead = before.head;
+    const extend = write
+        ? {
+            progressed: () => {
+                const head = (() => {
+                    try {
+                        return git(wd(c), 'rev-parse', 'HEAD').trim();
+                    }
+                    catch {
+                        return seenHead;
+                    }
+                })();
+                const moved = head !== seenHead;
+                seenHead = head;
+                return moved;
+            },
+            ms: EXTENSION_MS,
+            max: MAX_EXTENSIONS,
+        }
+        : undefined;
     const outcome = await runSession({
         kind,
         sessionId,
@@ -614,18 +617,20 @@ async function session(c, kind, local = false) {
         effort,
         local,
         schema: schemaFor(kind),
-        agent: kind === 'spec' ? 'spec-writer' : kind === 'accept' ? 'acceptance-writer' : kind === 'ux' || kind === 'maquette' ? 'ux-reviewer' : kind === 'precheck' ? 'precheck-reader' : write ? undefined : 'code-reviewer',
-        cwd: l.repo,
+        agent: kind === 'spec' ? 'spec-writer' : kind === 'accept' ? 'acceptance-writer' : kind === 'ux' || kind === 'maquette' ? 'ux-reviewer' : kind === 'precheck' ? 'precheck-reader' : kind === 'fix' && l.docsFix ? 'doc-keeper' : write ? undefined : 'code-reviewer',
+        cwd: wd(c),
         wave: w.id,
         lot: lotKey(l.project, l.lot),
         permissionMode: c.config.permissionMode,
         prodAccess: c.config.prodAccess,
-        addDirs: [...c.config.addDirs, ...(playwright && write ? [playwrightDir(dirname(mcpConfig))] : []), ...neighbourDirs(l)],
+        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,
         toolBin: toolBinOf(w.store.dir),
+        tmpDir,
         mcpConfig,
         playwright,
-        timeoutMs: write ? c.config.timeouts.work : c.config.timeouts.review,
+        timeoutMs: delay,
+        extend,
     }, {
         claude: w.claude,
         agents: w.agents,
@@ -633,26 +638,100 @@ async function session(c, kind, local = false) {
             step.pid = pid;
             save(c);
         },
+        // La session neuve de la relance (L256) devient la session de l'étape dès son lancement : un signal pendant qu'elle tourne la tue (killSessions) et compte ses jetons (countInterrupted).
+        onRelaunch: (id) => {
+            step.sessionId = id;
+            save(c);
+        },
+    }).catch((e) => {
+        if (e instanceof SlotAbandoned)
+            return e;
+        throw e;
     });
+    if (outcome instanceof SlotAbandoned) {
+        // L332 : la demande est arrivée pendant l'attente d'un créneau. Une étape qui n'a pas démarré (aucun pid) n'a pas eu lieu : elle ne figure pas à l'état.
+        // Rien de ce que le brief a consommé n'a servi : la réponse du lead (retirée de pendingAnswer avant le lancement) revient, la reprise rejoue l'étape avec elle.
+        if (step.pid === undefined) {
+            l.steps.pop();
+            l.pendingAnswer = answerInBrief;
+        }
+        else {
+            // Une session de l'étape a déjà tourné (le pid est le sien) et c'est son lancement SUIVANT qui attendait un créneau (relance d'une session coupée, relance de mise en forme) :
+            // sa sortie, son identifiant et ses jetons sont gardés, la cause dit ce qui n'a pas eu lieu.
+            const dir = w.store.lotDir(l.project, l.lot);
+            const base = `${n}-${kind}`;
+            const after = outcome.after;
+            const spentOf = (sessionId) => (w.claudeHome ? (journalTokens(w.claudeHome, wd(c), sessionId)?.tokens ?? null) : null);
+            let tokens = null;
+            let cause = outcome.message;
+            if (after?.relaunched) {
+                const cutRun = after.relaunched;
+                tokens = spentOf(cutRun.sessionId);
+                step.sessionId = cutRun.sessionId; // la session neuve n'a jamais démarré : l'étape est celle de la session coupée
+                writeFileSync(join(dir, `${base}.first.err`), cutRun.stderr);
+                cause = `coupée (${cutRun.cause}), relance en session neuve non faite : ${outcome.message}`;
+                l.warnings.push(`${kind} coupée (${cutRun.cause}) : sa relance en session neuve n'a pas eu lieu, ${outcome.message}`);
+            }
+            else if (after?.formatting) {
+                const first = after.formatting;
+                tokens = first.tokens ?? (first.sessionId ? spentOf(first.sessionId) : null);
+                if (first.sessionId)
+                    step.sessionId = first.sessionId;
+                writeFileSync(join(dir, `${base}.first.json`), first.stdout);
+                writeFileSync(join(dir, `${base}.first.err`), first.stderr);
+                cause = `sortie sans structured_output, relance de mise en forme non faite : ${outcome.message}`;
+            }
+            if (tokens && !local) {
+                step.tokens = tokens;
+                w.budget.add(tokens);
+            }
+            step.status = 'failed';
+            step.cause = cause;
+            step.ended = new Date().toISOString();
+            w.saveWave();
+        }
+        return outcome.reason === DROPPED ? stop(c, 'handed-back', DROPPED + unplayedAnswer(l)) : suspend(c, outcome.reason);
+    }
     step.ended = new Date().toISOString();
     const dir = w.store.lotDir(l.project, l.lot);
     const base = `${n}-${kind}`;
+    // Jetons de la session coupée (L256) : au budget de la vague ci-dessous, et à l'étape pour que le lot (L78) et le tableau les comptent.
+    let cutTokens = null;
+    if (outcome.relaunched) {
+        // Étape en lecture coupée (signal, sortie vide) puis relancée en session neuve (L256) : la session coupée a consommé des jetons (son journal), garde sa sortie d'erreur, et la relance est signalée au tableau.
+        const cutRun = outcome.relaunched;
+        const spent = w.claudeHome ? journalTokens(w.claudeHome, wd(c), cutRun.sessionId) : null;
+        if (spent) {
+            w.budget.add(spent.tokens);
+            cutTokens = spent.tokens;
+        }
+        writeFileSync(join(dir, `${base}.first.err`), cutRun.stderr);
+        const text = `${kind} relancée en session neuve après une coupure (${cutRun.cause})`;
+        l.warnings.push(text);
+        w.log(`${lotKey(l.project, l.lot)} · session ${n} ${text}`);
+        w.saveWave();
+    }
     if (outcome.kind !== 'ok' && !local) {
         // Une session en échec, au quota ou tuée au délai a consommé des tokens : ceux de sa sortie, sinon ceux de son journal.
-        const spent = outcome.tokens ? { tokens: outcome.tokens, sessionId: outcome.sessionId } : w.claudeHome ? journalTokens(w.claudeHome, l.repo, outcome.sessionId ?? sessionId) : null;
+        const spent = outcome.tokens ? { tokens: outcome.tokens, sessionId: outcome.sessionId } : w.claudeHome ? journalTokens(w.claudeHome, wd(c), outcome.sessionId ?? sessionId) : null;
         if (spent) {
-            step.tokens = spent.tokens;
+            step.tokens = cutTokens ? sumTokens(cutTokens, spent.tokens) : spent.tokens;
             if (spent.sessionId)
                 step.sessionId = spent.sessionId;
             w.budget.add(spent.tokens);
             w.saveWave();
             if (w.claudeHome && spent.sessionId)
-                step.peakContext = peakContext(w.claudeHome, l.repo, spent.sessionId);
+                step.peakContext = peakContext(w.claudeHome, wd(c), spent.sessionId);
+        }
+        else if (cutTokens) {
+            step.tokens = cutTokens;
         }
     }
     if (local && outcome.kind !== 'ok') {
         // Hors quota Anthropic : rien au budget (ni sortie, ni journal), et jamais d'arrêt du lot — Sonnet reprend le contrôle.
-        const cause = outcome.kind === 'failed' ? outcome.cause : outcome.message;
+        // Un appel d'outil écrit en texte (`<function=Bash>`) est une sortie sans structured_output : le local n'a pas tenu l'appel d'outils, inutile d'attendre un second tour.
+        const textCall = outcome.kind === 'failed' && outcome.stdout.includes('<function=');
+        const cause = textCall ? 'appel d\'outil écrit en texte, pas de structured_output' : outcome.kind === 'failed' ? outcome.cause : outcome.message;
         writeFileSync(join(dir, `${base}.json`), outcome.kind === 'failed' ? outcome.stdout : '');
         if (outcome.kind === 'failed')
             writeFileSync(join(dir, `${base}.err`), outcome.stderr);
@@ -661,6 +740,7 @@ async function session(c, kind, local = false) {
         step.report = `${base}.json`;
         delete step.tokens;
         l.warnings.push(`contrôle préalable : modèle local sans résultat (${cause.slice(0, 200)}), repli sur Sonnet`);
+        benchLocal(c, cause);
         save(c);
         return LOCAL_FAILED;
     }
@@ -672,7 +752,30 @@ async function session(c, kind, local = false) {
         step.report = `${base}.json`;
         step.status = 'failed';
         step.cause = outcome.cause;
-        return stop(c, 'failed', `${kind} sans résultat : ${outcome.cause}`);
+        if (write && outcome.cause === 'délai dépassé') {
+            // L298 : le travail laissé par une étape d'écriture coupée au délai est signalé (commits, fichiers, tests), pas un « échec » sec ; L303 : dans les dépôts voisins aussi.
+            const repos = [{ rel: '', path: wd(c), before }, ...neighbours.map((r, i) => ({ rel: r.rel, path: r.path, before: beforeOthers[i] }))];
+            const files = [];
+            let commits = 0;
+            let numstat = '';
+            for (const r of repos) {
+                const after = await snapshot(r.path);
+                files.push(...dirtBetween(r.before, after).map((f) => (r.rel ? `${r.rel}: ${f}` : f)));
+                if (r.before.head)
+                    commits += readCommits(r.path, { range: `${r.before.head}..HEAD` }).length;
+                try {
+                    numstat += git(r.path, 'diff', '--numstat', 'HEAD');
+                }
+                catch {
+                    // pas de HEAD : aucune ligne comptée
+                }
+                numstat += '\n';
+            }
+            const report = cutReport({ minutes: Math.round(delay / 60_000), commits, files, numstat });
+            step.cause = report;
+            return stop(c, files.length || commits ? 'handed-back' : 'failed', `délai dépassé : ${kind} ${report}`);
+        }
+        return stop(c, 'failed', outcome.cut ? `coupure : ${kind} ${outcome.cause}` : `échec : ${kind} sans résultat : ${outcome.cause}`);
     }
     if (outcome.kind === 'quota') {
         if (outcome.firstStdout !== undefined)
@@ -691,7 +794,7 @@ async function session(c, kind, local = false) {
     writeFileSync(join(dir, `${base}.json`), JSON.stringify({ ...res, structured: res.structured }, null, 2));
     step.report = `${base}.json`;
     step.sessionId = res.sessionId;
-    step.tokens = local ? { ...res.tokens, counted: 0 } : res.tokens; // local : hors quota, hors budget
+    step.tokens = local ? { ...res.tokens, counted: 0 } : cutTokens ? sumTokens(cutTokens, res.tokens) : res.tokens; // local : hors quota, hors budget
     if (res.formattingRetry) {
         step.formatRetry = true;
         w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} : rapport sans sortie structurée, relance de mise en forme`);
@@ -700,13 +803,13 @@ async function session(c, kind, local = false) {
         w.budget.add(res.tokens);
     w.saveWave();
     if (w.claudeHome)
-        step.peakContext = peakContext(w.claudeHome, l.repo, res.sessionId);
-    const after = await snapshot(l.repo);
+        step.peakContext = peakContext(w.claudeHome, wd(c), res.sessionId);
+    const after = await snapshot(wd(c));
     const afterOthers = await Promise.all(neighbours.map((r) => snapshot(r.path)));
     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: l.repo, 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), before, after }, ...others.map((o) => ({ where: ` dans ${o.repo.rel}`, path: 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)) {
@@ -741,7 +844,7 @@ async function session(c, kind, local = false) {
             }
             if (b.branch && why === null && failed === null) {
                 Object.assign(a, await snapshot(path));
-                if (path === l.repo)
+                if (path === wd(c))
                     step.headAfter = a.head ?? undefined;
                 const text = `${kind} : la session a fini${where} ${was} (arbre propre, rien hors de la branche) — branche ${b.branch} remise`;
                 l.warnings.push(text);
@@ -764,7 +867,7 @@ async function session(c, kind, local = false) {
         if (!write && b.head === a.head && b.tracked.join() === a.tracked.join() && b.untracked.join() !== a.untracked.join() && b.untracked.every((f) => a.untracked.includes(f))) {
             const fresh = a.untracked.filter((f) => !b.untracked.includes(f)).map(unquotePath);
             const stray = join(dir, 'stray');
-            const to = where ? join(stray, relative(l.repo, path).replace(/[\\/]/g, '_')) : stray;
+            const to = where ? join(stray, relative(wd(c), path).replace(/[\\/]/g, '_')) : stray;
             const moved = moveStray(path, fresh, to);
             if (moved.length) {
                 const text = `${kind} : ${moved.length} fichier(s) non suivi(s) laissé(s)${where} par une étape en lecture seule, déplacé(s) dans ${to} : ${moved.join(', ')}`;
@@ -780,10 +883,33 @@ async function session(c, kind, local = false) {
             return handBack(c, kind, res.structured, step, where, path, b, a);
         }
     }
+    const touched = write && c.tree?.active ? planTouched(c, before.head, after) : null;
+    if (touched) {
+        step.status = 'failed';
+        step.cause = touched;
+        return stop(c, 'handed-back', `la session a modifié le plan dans son worktree ${touched} : le plan n'est écrit que par le programme ; worktree conservé : ${wd(c)}`);
+    }
     step.status = 'ok';
     save(c);
     return { step, report: res.structured, before, after, others };
 }
+/**
+ * Une session d'écriture a-t-elle touché, dans son worktree, le fichier de plan ou un fichier généré avec lui (plan.files, la page Gantt) ? (R21) Le plan n'est
+ * écrit que par le programme, dans le dépôt du projet : un commit de plan sur la branche du lot reviendrait en conflit au rebase. Rend « (fichier, commit sha) »
+ * ou « (fichier, non commité) », null sinon.
+ */
+function planTouched(c, headBefore, after) {
+    const files = planFileSet(c.loadPlan(), c.lot.repo);
+    if (headBefore && after.head && headBefore !== after.head) {
+        for (const sha of git(wd(c), 'log', '--format=%H', `${headBefore}..${after.head}`).split('\n').filter(Boolean)) {
+            const hit = changedFiles(wd(c), sha).find((f) => files.has(f));
+            if (hit)
+                return `(${hit}, commit ${sha.slice(0, 7)})`;
+        }
+    }
+    const dirty = trackedPaths(after).find((f) => files.has(f));
+    return dirty ? `(${dirty}, non commité)` : null;
+}
 /** Pourquoi la branche de départ ne peut pas être remise sans risque après un HEAD déplacé (L214), null si elle le peut : arbre propre et rien hors de la branche. */
 function headStranded(path, b, a) {
     if (a.tracked.length || a.untracked.join() !== b.untracked.join())
@@ -895,9 +1021,9 @@ function overBudget(c, reserve = false) {
     const why = reserve ? `budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés (${basis}), il ne reste pas de quoi payer la correction et la revue courte qui la suivrait (${REVIEW_RESERVE} réservés)` : `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, ${basis})`;
     // Tests rouges après une écriture : la passe fix refusée aurait suivi, le lot revient sans revue (L145) — la cause le dit.
     const red = l.next === 'fix' && l.constats.some((k) => k.source === 'tests');
-    // Passe d'écriture qui vient d'être jouée, nommée d'après le compteur : l.pass - 1 passes de correction l'ont précédée (minorPass reste vrai après la passe des mineurs).
+    // 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.
     const played = l.pass - 1;
-    const after = l.minorPass && played === (l.minorPassAt ?? 0) ? 'la passe des mineurs' : played > 0 ? `la passe fix ${played}` : "l'implémentation";
+    const after = l.minorPass && played === (l.minorPassAt ?? 0) ? 'la passe des mineurs' : played > 0 ? `la passe fix ${played}` : l.resumedFrom && l.resumedReviewed ? 'la dernière revue de la branche reprise' : "l'implémentation";
     const notPlayed = l.next === 'fix' ? 'correction non jouée (budget) : ' : '';
     const prefix = notPlayed + (red ? `tests rouges après ${after}, correction suivante non abordable : ` : '');
     const unreviewed = red ? ' ; le lot revient sans revue, avec ses constats' : '';
@@ -938,9 +1064,96 @@ function badReport(c, step, e) {
     step.cause = e.message;
     return stop(c, 'failed', `${step.kind} : ${e.message}`);
 }
-/** Le contrôle préalable ne vaut que pour un lot sans commit : avec des commits, l'implémentation reprend légitimement. */
-export function needsPrecheck(config, plan, repo, lot, repos = []) {
-    return config.precheck && !hasWork(plan, { repo, repos, lot });
+/**
+ * Mots du titre ou du goal qui disent que le lot reprend un constat : le livrable peut déjà exister. Mots entiers (« review » ne
+ * se lit pas dans `qa-reviewer` ni `review-small`), au pluriel ou accordés pour « constat ».
+ */
+const CITES_FINDING = /(?<![\w-])(?:constat\w*|revues?|reviews?|audits?)(?![\w-])/i;
+/**
+ * Le texte du lot (titre, goal, objectif donné) cite un constat, ou un autre lot dont le travail a pu être fait. Pour un lot
+ * `L<n>`, « L12 » compte dans le texte de `L30` (aussi dans « L12-L15 », « L12-bis », « L12.3 ») et non celui de `L12` ni d'un lot postérieur ; tout identifiant du plan qui n'est
+ * pas `L<n>` (`Q-CAN5`, `B28.1`, `Q4/qa-expectations`) compte cité en entier (`B28.1` n'est pas `B28.10`), pour un lot `L<n>`
+ * comme pour un autre ; un lot d'un autre projet (`cadence:L68`) compte toujours.
+ */
+function citesPriorWork(text, lot, ids) {
+    if (CITES_FINDING.test(text))
+        return true;
+    const { ids: cited, foreign } = citedLots(text, lot, ids);
+    return foreign || cited.length > 0;
+}
+/**
+ * Les lots que le texte cite (même reconnaissance que `citesPriorWork`, L288/L292) : les identifiants du plan cités, et `foreign` quand il cite un lot d'un autre projet
+ * (`cadence:L68`, dont on ne lit pas les commits ici).
+ */
+function citedLots(text, lot, ids) {
+    const foreign = /(?<![\w-])[a-z][\w-]*:L\d+(?!\w)/i.test(text);
+    const own = /^L(\d+)$/.exec(lot);
+    const cited = (id) => new RegExp(`(?<![\\w.-])${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w-]|\\.\\w)`).test(text);
+    return {
+        foreign,
+        ids: ids.filter((id) => {
+            if (id === lot)
+                return false;
+            const n = /^L(\d+)$/.exec(id);
+            if (own && n)
+                return Number(n[1]) < Number(own[1]) && new RegExp(`(?<![\\w-])${id}(?!\\w)`).test(text);
+            return cited(id);
+        }),
+    };
+}
+/**
+ * Le contrôle préalable ne vaut que pour un lot sans commit (avec des commits, l'implémentation reprend légitimement) dont le
+ * titre ou le goal (clé `goal:` du plan, ou `goal` donné au lancement) cite un constat ou un autre lot (L288, L292) : sans cela
+ * rien ne laisse croire qu'un autre lot l'a déjà livré, et le contrôle coûtait 7 % des tokens pour 10 « oui » sur 30 mesurés
+ * (audit du 24-10). Sur le modèle local (`precheck: local`, L296) le critère tombe : le titre faisait perdre 7 des 17 « oui »
+ * réels, et le contrôle ne coûte plus rien au quota (seul un « oui » est confirmé par Sonnet).
+ */
+export function needsPrecheck(config, plan, repo, lot, repos = [], goal) {
+    if (!config.precheck || hasWork(plan, repo, { repos, lot }))
+        return false;
+    if (config.precheckLocal)
+        return true;
+    const l = plan.lot(lot);
+    const text = [l.title, l.goal, goal].filter(Boolean).join('\n');
+    return citesPriorWork(text, lot, plan.lots().map((x) => x.id));
+}
+/**
+ * Un lot créé après le dernier commit de code du dépôt n'a rien à retrouver (L322) : tout ce que le dépôt contient date d'avant le lot, donc aucun autre lot ne l'a livré.
+ * Rend la raison à écrire au journal, ou null quand le contrôle garde un sens. Le lot est daté par le commit qui a ajouté son id au plan, borné par sa clé `created` (une
+ * migration ou un déplacement du plan ne rajeunit pas un vieux lot) ; le dernier commit de code est le dernier qui ne touche pas que le plan (`isPlanOnly`). Prudent : lot
+ * qui travaille dans des dépôts voisins, id introuvable dans l'historique du plan, dépôt sans commit de code ou instants égaux → le contrôle reste.
+ * Le contrôle reste aussi quand le titre ou le goal (ou le goal donné au lancement) cite un lot qui a déjà ses propres commits, ou un lot d'un autre projet : une « suite de revue L<n> » écrite
+ * juste après le dernier correctif de L<n> liste des constats que les passes de correction de L<n> ont pu régler avant la création du lot (rejoué depuis le 24-10 : 5 lots sautés à tort,
+ * dont 2 avec un vrai « partiel »).
+ */
+export function precheckNothingToFind(plan, root, lot, repos = [], goal) {
+    if (repos.length)
+        return null;
+    try {
+        const rel = relative(root, plan.path);
+        const idLine = `^\\s*- id: ["']?${lot.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')}["']?\\s*$`;
+        // Pas de `--reverse` : avec `--follow`, git 2.43 ne rend rien sur un fichier renommé (`raf migrate`) ; le plus ancien est la dernière ligne.
+        const added = git(root, '-c', 'core.quotepath=off', 'log', '--follow', '--format=%ct', '-G', idLine, '--', rel).split('\n').filter(Boolean).pop();
+        if (!added)
+            return null;
+        const created = plan.lot(lot).created;
+        const endOfCreated = created ? Date.parse(`${created}T23:59:59`) / 1000 : Infinity;
+        const createdAt = Math.min(Number(added), Number.isNaN(endOfCreated) ? Infinity : endOfCreated);
+        const log = git(root, 'log', '--format=%H %ct').split('\n').filter(Boolean);
+        const code = log.map((x) => x.split(' ')).find(([sha]) => !isPlanOnly(sha, plan, root));
+        if (!code)
+            return null;
+        if (createdAt <= Number(code[1]))
+            return null;
+        const l = plan.lot(lot);
+        const { ids, foreign } = citedLots([l.title, l.goal, goal].filter(Boolean).join('\n'), lot, plan.lots().map((x) => x.id));
+        if (foreign || ids.some((id) => lotWork(plan, root, id).length > 0))
+            return null;
+        return `lot créé après le dernier commit de code du dépôt (${code[0].slice(0, 7)}) : rien à retrouver`;
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Contrôle préalable (L77) : une session de lecture seule cherche si le livrable du lot est déjà dans le dépôt (fait par un
@@ -951,7 +1164,10 @@ async function precheck(c) {
     const l = c.lot;
     let rep = null;
     let localYes = false;
-    if (c.config.precheckLocal) {
+    if (c.config.precheckLocal && c.wave.localOut) {
+        l.warnings.push(`contrôle préalable : modèle local écarté pour la vague (${c.wave.localOut}), Sonnet directement`);
+    }
+    else if (c.config.precheckLocal) {
         // Modèle local (L146) : un échec, un rapport illisible ou un « oui » (qui rendrait le lot sans implémentation) rend la main à Sonnet.
         const done = await session(c, 'precheck', true);
         if (!done)
@@ -961,7 +1177,8 @@ async function precheck(c) {
                 rep = checkShape(done.report, PRECHECK_SCHEMA);
             }
             catch (e) {
-                l.warnings.push(`contrôle préalable : rapport du modèle local illisible (${e.message}), repli sur Sonnet`);
+                l.warnings.push(`${LOCAL_PRECHECK_UNREADABLE} (${e.message}), repli sur Sonnet`);
+                benchLocal(c, `rapport illisible : ${e.message}`);
             }
             if (rep?.dejaPresent === 'oui') {
                 localYes = true;
@@ -977,7 +1194,7 @@ async function precheck(c) {
             rep = checkShape(done.report, PRECHECK_SCHEMA);
         }
         catch (e) {
-            l.warnings.push(`contrôle préalable illisible, implémentation lancée : ${e.message}`);
+            l.warnings.push(`${PRECHECK_UNREADABLE} : ${e.message}`);
             l.next = firstWrite(c);
             save(c);
             return;
@@ -991,6 +1208,7 @@ async function precheck(c) {
     const proofs = rep.preuves.length ? ` (${rep.preuves.join(' ; ')})` : '';
     // « oui » sans preuve ne se vérifie pas : il vaut « partiel », l'implémentation part avec le constat.
     const unproven = rep.dejaPresent === 'oui' && rep.preuves.length === 0;
+    l.precheckVerdict = unproven ? 'partiel' : rep.dejaPresent;
     if (unproven)
         l.warnings.push('contrôle préalable : « oui » sans preuve, traité comme partiel');
     if (rep.dejaPresent === 'oui' && !unproven) {
@@ -1004,13 +1222,23 @@ async function precheck(c) {
     l.next = firstWrite(c);
     save(c);
 }
+/** Le lot passe-t-il par le contrôle préalable ? Un lot qui n'a rien à retrouver (L322) saute l'étape, et le journal du lot le dit. */
+function precheckOrSkip(c) {
+    const plan = c.loadPlan();
+    if (!needsPrecheck(c.config, plan, c.lot.repo, c.lot.lot, c.lot.repos, c.lot.goal))
+        return false;
+    const nothing = precheckNothingToFind(histPlan(c), wd(c), c.lot.lot, c.lot.repos, c.lot.goal);
+    if (nothing)
+        c.lot.warnings.push(`contrôle préalable sauté : ${nothing}`);
+    return !nothing;
+}
 /** Première session d'écriture d'un lot : la spec quand il déclare `screen:` ou `spec: true` et qu'aucune fiche n'est écrite, sinon l'implémentation. */
 function firstWrite(c) {
     const l = c.lot;
     if (!hasSpecStage(l) || l.spec)
         return 'implement';
-    const fiche = findFiche(l.repo, c.config.spec.dir, l.lot);
-    return fiche && ficheReady(l.repo, fiche, l.lot, partsOf(l, fiche)) ? afterSpec(c, fiche) : 'spec';
+    const fiche = findFiche(wd(c), c.config.spec.dir, l.lot);
+    return fiche && ficheReady(wd(c), fiche, l.lot, partsOf(c, fiche)) ? afterSpec(c, fiche) : 'spec';
 }
 const NO_TEST_ACCEPT = 'étape accept : orchestrate.test absent, rien ne prouve que les tests rouges sont exclus du lanceur de tests et de la CI (vérifier à la main la config du lanceur avant de livrer)';
 const NO_ACCEPT = 'étape accept ignorée : orchestrate.accept absent (commande dédiée aux tests d\'acceptation), le lot passe de spec à implement sans tests rouges';
@@ -1021,7 +1249,7 @@ const NO_ACCEPT = 'étape accept ignorée : orchestrate.accept absent (commande
 function afterSpec(c, fiche) {
     const l = c.lot;
     // Revue de la fiche back (L188) d'abord, puis celle de la maquette d'un lot mixte ; la même preuve (acceptation scellée, code déjà commité) dispense des deux.
-    if (c.config.fiche && partsOf(l, fiche).back && !l.fiche?.conforme && !acceptationProof(c, fiche) && !codeAfterFiche(c, fiche))
+    if (c.config.fiche && partsOf(c, fiche).back && !l.fiche?.conforme && !acceptationProof(c, fiche) && !codeAfterFiche(c, fiche))
         return 'fiche';
     return afterFiche(c, fiche);
 }
@@ -1045,7 +1273,7 @@ function afterMaquette(c, fiche) {
     }
     const json = lotAcceptation(c, fiche);
     if (acceptationProof(c, fiche)) {
-        l.accept = { acceptation: json, rouge: redSha(l.repo, json) ?? '' };
+        l.accept = { acceptation: json, rouge: redSha(wd(c), json) ?? '' };
         return 'implement';
     }
     return 'accept';
@@ -1056,7 +1284,7 @@ function codeAfterFiche(c, fiche) {
     let sha;
     try {
         // Le point de départ est le commit qui a créé la fiche : un commit plus récent du dossier (capture corrigée) ne doit pas masquer le code commité avant lui.
-        sha = git(l.repo, 'log', '--diff-filter=A', '--format=%H', '--', fiche).split('\n').filter(Boolean).pop() ?? git(l.repo, 'log', '-1', '--format=%H', '--', posix.dirname(fiche));
+        sha = git(wd(c), 'log', '--diff-filter=A', '--format=%H', '--', fiche).split('\n').filter(Boolean).pop() ?? git(wd(c), 'log', '-1', '--format=%H', '--', posix.dirname(fiche));
     }
     catch {
         return false;
@@ -1064,21 +1292,21 @@ function codeAfterFiche(c, fiche) {
     if (!sha)
         return false;
     const dir = `${posix.dirname(fiche)}/`;
-    const after = new Set(readCommits(l.repo, { range: `${sha}..HEAD` }).map((k) => k.sha));
+    const after = new Set(readCommits(wd(c), { range: `${sha}..HEAD` }).map((k) => k.sha));
     // Un commit de la session spec elle-même (fiche, maquette, captures) ou de la session accept (tests listés) n'est pas du code.
     const tests = new Set();
     const json = lotAcceptation(c, fiche);
     if (listed(c, json)) {
-        const doc = parseAcceptation(readFileSync(join(l.repo, json), 'utf8'));
+        const doc = parseAcceptation(readFileSync(join(wd(c), json), 'utf8'));
         if (typeof doc !== 'string')
             for (const f of doc.fichiers)
                 tests.add(posix.normalize(f));
     }
-    return lotWork(c.loadPlan(), l.repo, l.lot).some((k) => after.has(k.sha) && changedFiles(l.repo, k.sha).some((f) => !f.startsWith(dir) && !tests.has(f)));
+    return lotWork(histPlan(c), wd(c), l.lot).some((k) => after.has(k.sha) && changedFiles(wd(c), k.sha).some((f) => !f.startsWith(dir) && !tests.has(f)));
 }
 /** L'acceptation du lot : celle que git suit déjà pour lui (même un ancien `acceptation.json`), sinon `acceptation-<lot>.json` à côté de la fiche. */
-const lotAcceptation = (c, fiche) => findAcceptation(c.lot.repo, c.config.spec.dir, c.lot.lot) ?? acceptationFile(fiche, c.lot.lot);
-const listed = (c, json) => existsSync(join(c.lot.repo, json));
+const lotAcceptation = (c, fiche) => findAcceptation(wd(c), c.config.spec.dir, c.lot.lot) ?? acceptationFile(fiche, c.lot.lot);
+const listed = (c, json) => existsSync(join(wd(c), json));
 /** Une acceptation porte-t-elle une empreinte par fichier listé ? Le contenu n'est pas comparé (L233) : `empreintes: {}` ou celles d'un autre fichier ne scellent rien. */
 const hasSeals = (doc) => !!doc.empreintes && doc.fichiers.every((f) => !!doc.empreintes[posix.normalize(f)]);
 /**
@@ -1090,7 +1318,7 @@ function acceptationProof(c, fiche) {
     const json = lotAcceptation(c, fiche);
     if (!c.config.accept || !listed(c, json))
         return false;
-    const doc = parseAcceptation(readFileSync(join(l.repo, json), 'utf8'));
+    const doc = parseAcceptation(readFileSync(join(wd(c), json), 'utf8'));
     if (typeof doc === 'string')
         return false;
     // Un lot déjà vert (L233) n'a plus d'oracle à écrire : le cycle seul a pu poser `vert: true`, après le scellé et les tests rouges. Même une preuve qui ne tient plus
@@ -1104,24 +1332,22 @@ function acceptationProof(c, fiche) {
     const emp = doc.empreintes ?? {};
     const sealed = doc.fichiers.every((f) => {
         const norm = posix.normalize(f);
-        return existsSync(join(l.repo, norm)) && emp[norm] === git(l.repo, 'hash-object', '--', norm).trim();
+        return existsSync(join(wd(c), norm)) && emp[norm] === git(wd(c), 'hash-object', '--', norm).trim();
     });
     if (!sealed)
         return false;
-    return checkAcceptation(l.repo, json, l.lot, fiche).length === 0;
+    return checkAcceptation(wd(c), json, l.lot, fiche).length === 0;
 }
 /** Chemins salis par une session : suivis modifiés, nouveaux fichiers non suivis, et ceux des dépôts voisins. */
 function dirtAfter(done) {
-    return [
-        ...trackedPaths(done.after),
-        ...done.after.untracked.filter((f) => !done.before.untracked.includes(f)),
-        ...done.others.flatMap((o) => [...trackedPaths(o.after), ...o.after.untracked.filter((f) => !o.before.untracked.includes(f))].map((f) => `${o.repo.rel}: ${f}`)),
-    ];
+    return [...dirtBetween(done.before, done.after), ...done.others.flatMap((o) => dirtBetween(o.before, o.after).map((f) => `${o.repo.rel}: ${f}`))];
 }
+/** Chemins salis d'un dépôt entre deux relevés : suivis modifiés, et fichiers non suivis apparus. */
+const dirtBetween = (before, after) => [...trackedPaths(after), ...after.untracked.filter((f) => !before.untracked.includes(f))];
 /** Suite commune des étapes spec et accept : commits de la session (avertis s'ils ne citent pas le lot), choix reportés, vraies questions (les non-questions deviennent un avertissement). */
 function takeReport(c, done, rep) {
     const l = c.lot;
-    const commits = readCommits(l.repo, { range: done.step.headBefore ? `${done.step.headBefore}..HEAD` : undefined });
+    const commits = readCommits(wd(c), { range: done.step.headBefore ? `${done.step.headBefore}..HEAD` : undefined });
     done.step.commits = commits.map(short).reverse();
     for (const k of commits)
         if (!citedRefs(k, c.loadPlan().refs).some((r) => r.lot === l.lot))
@@ -1135,6 +1361,33 @@ function takeReport(c, done, rep) {
             l.warnings.push(`question ignorée (non-question) : « ${q.trim()} »`);
     return rep.questions.filter((q) => !isNonQuestion(q));
 }
+/**
+ * La réponse du lead à une question sur des hypothèses coûteuses de la fiche (L297) : le programme passe lui-même ces règles en `sourcee`
+ * (`réponse du lead, <date>, vague <id>`) et commite la fiche AVANT la session spec reprise, qui pourrait être perdue ou ne rien écrire — la fiche est alors
+ * conforme quand la revue de fiche la lit. Une réponse qui supprime ou change la règle (`answerAltersRule`) n'en source aucune. Rend vrai quand le lot est rendu (fiche introuvable, commit refusé).
+ */
+function sourceAnsweredRules(c) {
+    const l = c.lot;
+    if (!l.pendingAnswer || !l.specAsked?.length || !l.specAskedRules?.length)
+        return false;
+    if (answerAltersRule(l.pendingAnswer))
+        return false; // le lead corrige la règle : la session spec reprise l'applique, sinon la question lui revient (L302)
+    const fiche = ficheOf(c);
+    if (!fiche)
+        return false; // la session spec reprise l'écrira : l'ancienne consigne s'applique
+    try {
+        const ids = sourceRules(wd(c), fiche, l.specAskedRules, `${LEAD_SOURCE}, ${c.wave.today}, vague ${c.wave.id}`);
+        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);
+        return false;
+    }
+    catch (e) {
+        stop(c, 'handed-back', `réponse du lead non reportée dans la fiche ${fiche} : ${e.message.split('\n')[0]}`);
+        return true;
+    }
+}
 /** Plafond de sessions `spec` du lot (L230) : les revues de maquette d'un lot à écran, sinon deux. Fiche et maquette partagent `l.specRuns`. */
 const specBudget = (c) => (c.lot.screen && c.config.maquette ? c.config.maquetteReviews : 2);
 /**
@@ -1144,6 +1397,8 @@ const specBudget = (c) => (c.lot.screen && c.config.maquette ? c.config.maquette
  */
 async function specStep(c) {
     const l = c.lot;
+    if (sourceAnsweredRules(c))
+        return;
     const done = await session(c, 'spec');
     if (!done)
         return;
@@ -1161,6 +1416,7 @@ async function specStep(c) {
         l.questions = questions;
         l.specRuns = undefined; // la réponse ouvre un nouveau budget de sessions
         l.specAsked = undefined; // la prochaine réponse porte sur la question de la session, pas sur d'anciennes hypothèses coûteuses
+        l.specAskedRules = undefined;
         l.next = 'spec';
         transition(c, 'question', questions[0]);
         return;
@@ -1181,12 +1437,12 @@ async function specStep(c) {
     }
     // Le chemin du rapport est ramené relatif au dépôt (absolu, `./…` ou `a/../b` donneraient de faux écarts) ; hors du dépôt, c'est un écart.
     const reported = rep.fiche.trim();
-    const asked = reported ? relative(l.repo, resolve(l.repo, reported)) : '';
+    const asked = reported ? relative(wd(c), resolve(wd(c), reported)) : '';
     const outside = asked === '..' || asked.startsWith('../') || isAbsolute(asked);
-    const fiche = outside ? '' : asked || findFiche(l.repo, c.config.spec.dir, l.lot) || '';
+    const fiche = outside ? '' : asked || findFiche(wd(c), c.config.spec.dir, l.lot) || '';
     const what = l.screen ? '<écran>' : '<sujet>';
     const inDir = fiche === '' || fiche.startsWith(`${c.config.spec.dir.replace(/\/+$/, '')}/`);
-    const problems = !outside && fiche && !inDir ? [`${fiche} : fiche hors de ${c.config.spec.dir} (la spec vit dans ${c.config.spec.dir}/${what}/fiche.yaml, où l'étape la retrouve)`] : outside ? [`${reported} : fiche hors du dépôt (le chemin de « fiche » est relatif au dépôt : ${c.config.spec.dir}/${what}/fiche.yaml)`] : fiche ? checkSpec(l.repo, fiche, l.lot, partsOf(l, fiche)) : [`aucune fiche écrite : ${c.config.spec.dir}/${what}/fiche.yaml est attendue (ou une raison dans « sousSeuil » si le lot ne change ${l.screen ? 'aucun écran' : 'aucun comportement'})`];
+    const problems = !outside && fiche && !inDir ? [`${fiche} : fiche hors de ${c.config.spec.dir} (la spec vit dans ${c.config.spec.dir}/${what}/fiche.yaml, où l'étape la retrouve)`] : outside ? [`${reported} : fiche hors du dépôt (le chemin de « fiche » est relatif au dépôt : ${c.config.spec.dir}/${what}/fiche.yaml)`] : fiche ? checkSpec(wd(c), fiche, l.lot, partsOf(c, fiche)) : [`aucune fiche écrite : ${c.config.spec.dir}/${what}/fiche.yaml est attendue (ou une raison dans « sousSeuil » si le lot ne change ${l.screen ? 'aucun écran' : 'aucun comportement'})`];
     if (problems.length) {
         if ((l.specRuns ?? 0) >= specBudget(c)) {
             stop(c, 'handed-back', `spec non conforme après ${specBudget(c)} passes : ${problems.join(' ; ')}`);
@@ -1198,18 +1454,20 @@ async function specStep(c) {
         return;
     }
     l.specProblems = undefined; // les contrôles passent : les écarts de la passe précédente sont corrigés
-    const doc = parse(readFileSync(join(l.repo, fiche), 'utf8'));
+    const doc = parse(readFileSync(join(wd(c), fiche), 'utf8'));
     // Un choix coûteux à défaire n'est pas une hypothèse : la question remonte au lead, la session reprend avec sa réponse.
     const costly = costlyHypotheses(doc);
     if (costly.length) {
         l.questions = costly.map((x) => `${x.id} est posée comme hypothèse mais touche un choix coûteux à défaire (${x.categorie}) : « ${x.siFaux} » — la confirmer, ou la corriger, avant que la fiche serve de référence.`);
         l.specAsked = [...l.questions];
+        l.specAskedRules = costly.map((x) => x.id);
         l.specRuns = undefined; // la réponse du lead ouvre un nouveau budget de sessions, comme celle d'une question de la session
         l.next = 'spec';
         transition(c, 'question', l.questions[0]);
         return;
     }
     l.specAsked = undefined;
+    l.specAskedRules = undefined;
     l.spec = { fiche, hypotheses: (doc.regles ?? []).filter((r) => r.statut === 'hypothese').length };
     l.specProblems = undefined;
     l.hypotheses = undefined; // la fiche vient d'être (ré)écrite : ses hypothèses se posent une fois la fiche relue, pas avant (settleHypotheses)
@@ -1236,7 +1494,7 @@ async function settleHypotheses(c) {
         return false;
     let doc;
     try {
-        doc = parse(readFileSync(join(l.repo, fiche), 'utf8'));
+        doc = parse(readFileSync(join(wd(c), fiche), 'utf8'));
     }
     catch {
         return false;
@@ -1252,23 +1510,25 @@ async function noteHypotheses(c, lines, sujet) {
     l.hypotheses = lines;
     if (!lines.length)
         return false;
-    const plan = c.loadPlan();
     const texts = lines.map((x) => hypothesisNote(sujet, x));
-    if (plan.readonly) {
-        for (const t of texts)
-            propose(c, `[note à poser] ${t}`);
-        return false;
-    }
-    const have = new Set(plan.lot(l.lot).notes.map((n) => n.text));
-    const fresh = texts.filter((t) => !have.has(t));
-    if (!fresh.length)
-        return false;
-    for (const t of fresh)
-        plan.note(l.lot, t, c.wave.today);
-    plan.save();
-    const dirty = await commitPlan(c, `plan: ${l.lot} hypothèses de la fiche ${sujet} notées (orchestrate ${c.wave.id})`);
+    const dirty = await planWrite(c, async () => {
+        const plan = c.loadPlan();
+        if (plan.readonly) {
+            for (const t of texts)
+                propose(c, `[note à poser] ${t}`);
+            return null;
+        }
+        const have = new Set(plan.lot(l.lot).notes.map((n) => n.text));
+        const fresh = texts.filter((t) => !have.has(t));
+        if (!fresh.length)
+            return null;
+        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})`);
+    });
     if (dirty) {
-        stop(c, 'handed-back', `notes des hypothèses de la fiche : ${dirty}`);
+        handBackPlan(c, `${HYPOTHESES_HANDBACK}${dirty}`);
         return true;
     }
     return false;
@@ -1282,22 +1542,24 @@ async function noteMinors(c, rep, label) {
     const texts = rep.constats.filter((k) => k.gravite === 'mineur').map((k) => `Revue de ${label} — mineur : ${k.fichier ? `${k.fichier}${k.ligne ? `:${k.ligne}` : ''} — ` : ''}${k.texte}`);
     if (!texts.length)
         return false;
-    const plan = c.loadPlan();
-    if (plan.readonly) {
-        for (const t of texts)
-            propose(c, `[note à poser] ${t}`);
-        return false;
-    }
-    const have = new Set(plan.lot(c.lot.lot).notes.map((n) => n.text));
-    const fresh = [...new Set(texts)].filter((t) => !have.has(t));
-    if (!fresh.length)
-        return false;
-    for (const t of fresh)
-        plan.note(c.lot.lot, t, c.wave.today);
-    plan.save();
-    const dirty = await commitPlan(c, `plan: ${c.lot.lot} mineurs de la revue de ${label} notés (orchestrate ${c.wave.id})`);
+    const dirty = await planWrite(c, async () => {
+        const plan = c.loadPlan();
+        if (plan.readonly) {
+            for (const t of texts)
+                propose(c, `[note à poser] ${t}`);
+            return null;
+        }
+        const have = new Set(plan.lot(c.lot.lot).notes.map((n) => n.text));
+        const fresh = [...new Set(texts)].filter((t) => !have.has(t));
+        if (!fresh.length)
+            return null;
+        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})`);
+    });
     if (dirty) {
-        stop(c, 'handed-back', `notes des mineurs de la revue de ${label} : ${dirty}`);
+        handBackPlan(c, `${MINORS_HANDBACK}${label} : ${dirty}`);
         return true;
     }
     return false;
@@ -1331,11 +1593,12 @@ async function reviewSpecStep(c, r) {
     }
     const summary = summarize(rep, done.after.head ?? '');
     const passes = (l[r.kind]?.passes ?? 0) + 1;
-    l[r.kind] = { passes, conforme: summary.conforme, verdict: summary.verdict };
     // Fiche : les mineurs sont des notes du lot (design § 4). Maquette : inchangé (propositions du tableau final).
     addProposals(c, rep, r.kind, r.kind !== 'fiche');
+    // Un lot rendu sur le refus d'écrire ses notes (R26) rejoue cette revue à la reprise : le compte des passes n'est posé qu'une fois les notes écrites.
     if (r.kind === 'fiche' && (await noteMinors(c, rep, `la ${r.label}`)))
         return;
+    l[r.kind] = { passes, conforme: summary.conforme, verdict: summary.verdict };
     const constats = blockingConstats(rep, r.source);
     if (r.kind === 'maquette' && passes >= 2) {
         // Lu sur rep.constats : blockingConstats ne garde pas `inchange`. Seul le booléen vrai est une marque (checkShape ne descend pas dans constats[]).
@@ -1372,7 +1635,7 @@ const maquetteStep = (c) => reviewSpecStep(c, MAQUETTE_REVIEW);
  * listés sous aucune racine sont rendus (`orphans`) sans rien lancer.
  */
 async function runAccept(c, json) {
-    const abs = join(c.lot.repo, json);
+    const abs = join(wd(c), json);
     const doc = parseAcceptation(readFileSync(abs, 'utf8'));
     const plan = planAcceptRuns(acceptCommands(c.config.accept), typeof doc === 'string' ? [] : doc.fichiers, !isAcceptList(c.config.accept));
     if (plan.orphans.length)
@@ -1386,8 +1649,8 @@ const tail = (output, n = 40) => output.trim().split('\n').slice(-n).join('\n');
 /** Écarts des tests d'acceptation écrits par la session (vide = acceptés) : autres lots intacts, acceptation.json conforme, tests rouges, config.test toujours verte. */
 async function acceptProblems(c, fiche, json, headBefore) {
     const l = c.lot;
-    const out = headBefore ? lockViolations(l.repo, c.config.spec.dir, headBefore, { skip: json }) : [];
-    out.push(...checkAcceptation(l.repo, json, l.lot, fiche, l.steps.find((s) => s.kind === 'accept')?.headBefore));
+    const out = headBefore ? lockViolations(wd(c), c.config.spec.dir, headBefore, { skip: json }) : [];
+    out.push(...checkAcceptation(wd(c), json, l.lot, fiche, l.steps.find((s) => s.kind === 'accept')?.headBefore));
     if (out.length)
         return out;
     const red = await runAccept(c, json);
@@ -1416,16 +1679,16 @@ function greenDrift(c, json, first, before, was) {
     const l = c.lot;
     if (!listed(c, json))
         return 'acceptation.json supprimé depuis la première session accept (verrou des tests d\'acceptation)';
-    const text = readFileSync(join(l.repo, json), 'utf8');
+    const text = readFileSync(join(wd(c), json), 'utf8');
     // `before` vient de git() qui rogne les blancs de fin, le fichier écrit par le programme finit par un saut de ligne : les deux se comparent rognés.
     if (text.trim() === before.trim())
         return null;
     const now = parseAcceptation(text);
-    const dirty = git(l.repo, 'status', '--porcelain', '--', json).trim() !== '';
+    const dirty = git(wd(c), 'status', '--porcelain', '--', json).trim() !== '';
     let bySession = false;
     try {
-        const mine = waveCommits(c, l.repo);
-        bySession = git(l.repo, 'log', '--format=%H', `${first}..HEAD`, '--', json).split('\n').some((sha) => sha && mine(sha));
+        const mine = waveCommits(c, c.lot.repo);
+        bySession = git(wd(c), 'log', '--format=%H', `${first}..HEAD`, '--', json).split('\n').some((sha) => sha && mine(sha));
     }
     catch {
         bySession = true;
@@ -1454,7 +1717,7 @@ async function acceptStep(c) {
     const first = l.steps.find((s) => s.kind === 'accept')?.headBefore;
     let text = null;
     try {
-        text = first ? git(l.repo, 'show', `${first}:${json}`) : listed(c, json) ? readFileSync(join(l.repo, json), 'utf8') : null;
+        text = first ? git(wd(c), 'show', `${first}:${json}`) : listed(c, json) ? readFileSync(join(wd(c), json), 'utf8') : null;
     }
     catch {
         text = null;
@@ -1468,7 +1731,7 @@ async function acceptStep(c) {
             stop(c, 'handed-back', `verrou des tests d'acceptation : ${json} : ${drift}`);
             return;
         }
-        l.accept = { acceptation: json, rouge: redSha(l.repo, json) ?? '' };
+        l.accept = { acceptation: json, rouge: redSha(wd(c), json) ?? '' };
         l.next = 'implement';
         // Un lot en question n'a plus rien à demander : la réponse du lead (« ne réécris rien ») est prise en compte par ce choix, elle ne repart pas dans le brief d'implement.
         l.pendingAnswer = null;
@@ -1510,13 +1773,13 @@ async function acceptStep(c) {
         return;
     }
     l.acceptProblems = undefined;
-    sealAcceptation(l.repo, json);
-    const dirty = await commitPlan(c, `test(${l.lot}): acceptation scellée, empreintes des tests rouges (orchestrate ${c.wave.id})`);
+    sealAcceptation(wd(c), json);
+    const dirty = await commitPlan(c, `test(${l.lot}): acceptation scellée, empreintes des tests rouges (orchestrate ${c.wave.id})`, wd(c));
     if (dirty) {
         stop(c, 'handed-back', `scellé de ${json} : ${dirty}`);
         return;
     }
-    l.accept = { acceptation: json, rouge: git(l.repo, 'rev-parse', 'HEAD') };
+    l.accept = { acceptation: json, rouge: git(wd(c), 'rev-parse', 'HEAD') };
     l.next = 'implement';
     save(c);
 }
@@ -1528,10 +1791,10 @@ async function acceptGreen(c) {
     const l = c.lot;
     if (!c.config.accept)
         return null;
-    const json = l.accept?.acceptation ?? findAcceptation(l.repo, c.config.spec.dir, l.lot);
-    if (!json || !existsSync(join(l.repo, json)))
+    const json = l.accept?.acceptation ?? findAcceptation(wd(c), c.config.spec.dir, l.lot);
+    if (!json || !existsSync(join(wd(c), json)))
         return null;
-    const a = parseAcceptation(readFileSync(join(l.repo, json), 'utf8'));
+    const a = parseAcceptation(readFileSync(join(wd(c), json), 'utf8'));
     if (typeof a === 'string' || a.vert)
         return null;
     const { runs, orphans } = await runAccept(c, json);
@@ -1540,16 +1803,78 @@ async function acceptGreen(c) {
     const failed = runs.filter((r) => r.code !== 0);
     if (failed.length)
         return { source: 'tests', gravite: 'bloquant', texte: `tests d'acceptation encore rouges (${failed.map((r) => `${r.command}, code ${r.code}`).join(' ; ')}) : à rendre verts sans modifier les fichiers listés dans ${json} :\n${failed.map((r) => (failed.length > 1 ? `$ ${r.command}\n` : '') + tail(r.output)).join('\n')}` };
-    setVert(l.repo, json);
-    const dirty = await commitPlan(c, `chore(${l.lot}): acceptation verte, vert: true posé par le cycle (orchestrate ${c.wave.id})`);
+    setVert(wd(c), json);
+    const dirty = await commitPlan(c, `chore(${l.lot}): acceptation verte, vert: true posé par le cycle (orchestrate ${c.wave.id})`, wd(c));
     if (dirty)
         return { source: 'tests', gravite: 'bloquant', texte: `vert: true de ${json} : ${dirty}` };
     return null;
 }
+/**
+ * Les contrôles du programme (`orchestrate.build` puis `orchestrate.test`, L333 : les tests e2e lisent le `dist` que seul le build produit), joués dans `wd(c)` : chaque résultat est ajouté à `runs`, chaque rouge NOUVEAU à `red`
+ * (un test déjà rouge au sha de départ n'en est pas un, L213). S'arrête au premier rouge : un build rouge rend le lot sans lancer les tests. Après une écriture (work) et, au sommet rebasé, avant l'avance de la branche du dépôt (R7).
+ */
+async function programChecks(c, red, runs) {
+    const l = c.lot;
+    for (const [label, command] of [['build', c.config.build], ['tests', c.config.test]]) {
+        if (!command)
+            continue;
+        const r = await sh(c, command);
+        const run = { label, command, code: r.code };
+        runs.push(run);
+        if (r.code === 0)
+            continue;
+        const vs = label === 'tests' ? await againstBaseline(c, command, r.output) : { kind: 'unknown' };
+        if (vs.kind === 'existing') {
+            run.dejaRouges = vs.n;
+            const note = `${vs.n} test(s) déjà rouge(s) au sha de départ ${(l.baseline?.sha ?? '').slice(0, 7)}, pas un défaut du lot : listés à part, la revue a lieu`;
+            if (!l.warnings.includes(note))
+                l.warnings.push(note);
+            continue;
+        }
+        if (vs.kind === 'new') {
+            red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) : ${vs.nouveaux.length} test(s) rouge(s) qui ne l'étaient pas au sha de départ :\n${vs.nouveaux.map((t) => `- ${t}`).join('\n')}${vs.existants ? `\n(${vs.existants} autre(s) test(s) déjà rouge(s) au sha de départ : à ne pas corriger)` : ''}` });
+            return;
+        }
+        red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) :\n${r.output.trim().split('\n').slice(-40).join('\n')}` });
+        return;
+    }
+}
+/**
+ * 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.
+ */
+async function integratedChecks(c, key) {
+    const first = [];
+    let runs = [];
+    await programChecks(c, first, runs);
+    if (!first.length)
+        return { red: first, runs };
+    c.wave.log(`${key} tests rouges au sommet intégré, relancés une fois (${first.map(redExcerpt).join(' ; ')})`);
+    const red = [];
+    runs = [];
+    await programChecks(c, red, runs);
+    if (!red.length)
+        c.lot.warnings.push(`rouge au sommet intégré, vert à la relance (charge de la machine ?) : ${first.map(redExcerpt).join(' ; ')}`);
+    return { red, runs };
+}
+const EXCERPT_LINES = 10;
+/**
+ * Le constat rouge d'un contrôle, en une ligne pour le motif d'un refus (L328) : la commande, puis les tests rouges nommés quand le constat les liste (« - nom »),
+ * sinon la fin de la sortie. La première ligne seule laissait « npx vitest run en échec (code 1) : » sans un nom de test.
+ */
+export function redExcerpt(k) {
+    const [head, ...rest] = k.texte.split('\n');
+    const lines = rest.map((x) => x.trim()).filter(Boolean);
+    const named = lines.filter((x) => x.startsWith('- '));
+    const shown = named.length ? named.slice(0, EXCERPT_LINES) : lines.slice(-EXCERPT_LINES);
+    const more = named.length > EXCERPT_LINES ? [`… (+${named.length - EXCERPT_LINES})`] : [];
+    return [head.replace(/\s*:$/, ''), ...shown, ...more].join(' ; ');
+}
 /** Étape d'écriture (implémentation, correction) : contrôles, puis étape suivante décidée. */
 async function work(c, kind) {
     const l = c.lot;
     const minorsPass = kind === 'fix' && l.minorFix === true;
+    const docsPass = kind === 'fix' && l.docsFix === true;
     const done = await session(c, kind);
     if (!done)
         return;
@@ -1562,15 +1887,18 @@ async function work(c, kind) {
         badReport(c, done.step, e);
         return;
     }
+    // Le lot proposé du bibliothécaire (L306, document hors dépôt) est dans son resume : il devient une proposition du lot, donc une ligne du tableau de fin de vague.
+    if (docsPass && /^lot propos/i.test(rep.resume.trim()))
+        propose(c, rep.resume.trim());
     // L'écriture a changé le code (L221) : le verdict et les constats de la revue UX d'avant ne valent plus, l'UX est rejouée après la prochaine revue de code conforme.
     if (!l.small) {
         l.ux = undefined;
         l.uxVerdict = null;
         l.constats = l.constats.filter((k) => k.source !== 'ux');
     }
-    const plan = c.loadPlan();
+    const plan = histPlan(c);
     const range = done.step.headBefore ? `${done.step.headBefore}..HEAD` : undefined;
-    const commits = readCommits(l.repo, { range });
+    const commits = readCommits(wd(c), { range });
     // Commits de la session dans chaque dépôt voisin (L62) : de la tête d'avant la session à la tête d'après.
     const theirs = done.others.map((o) => ({ repo: o.repo, commits: o.before.head ? readCommits(o.repo.path, { range: `${o.before.head}..HEAD` }) : [] }));
     const made = commits.length + theirs.reduce((n, t) => n + t.commits.length, 0);
@@ -1581,13 +1909,13 @@ async function work(c, kind) {
         if ([...real].some((s) => s.startsWith(a.sha) || a.sha.startsWith(s.slice(0, 7))))
             continue;
         // Reprise : le rapport cite aussi les commits d'une session précédente du lot, hors de la plage de celle-ci.
-        const full = /^[0-9a-f]{4,40}$/i.test(a.sha) ? resolveCommit(l.repo, a.sha) : null;
-        if (full && lotCommits(plan, l.repo, l.lot).some((k) => k.sha === full))
+        const full = /^[0-9a-f]{4,40}$/i.test(a.sha) ? resolveCommit(wd(c), a.sha) : null;
+        if (full && lotCommits(plan, wd(c), l.lot).some((k) => k.sha === full))
             continue;
         l.warnings.push(full ? `commit annoncé n'appartient pas à ${l.lot} : ${a.sha} ${a.sujet}` : `commit annoncé absent de git : ${a.sha} ${a.sujet}`);
     }
     for (const k of commits) {
-        if (isPlanOnly(k.sha, plan, l.repo))
+        if (isPlanOnly(k.sha, plan, wd(c)))
             continue;
         if (!citedRefs(k, plan.refs).some((r) => r.lot === l.lot))
             l.warnings.push(`commit qui ne cite pas ${l.lot} : ${short(k)}`);
@@ -1604,7 +1932,7 @@ async function work(c, kind) {
     save(c);
     // Verrou des tests d'acceptation (L173) : ceux de TOUS les lots du dépôt, pas seulement du lot courant ; une modification est une question au lead. Contrôlé à CHAQUE fin de session, une question comprise (L200) :
     // une session qui remplace un test scellé puis pose une question ne passe pas par la reprise du lead pour se faire adopter.
-    const locked = done.step.headBefore ? lockViolations(l.repo, c.config.spec.dir, done.step.headBefore, { rouge: l.accept?.rouge ? { [l.accept.acceptation]: l.accept.rouge } : {}, lot: l.lot, lotBase: l.steps.find((s) => s.headBefore)?.headBefore, lotStart: lotStartHead(l.repo, lotWork(c.loadPlan(), l.repo, l.lot).map((k) => k.sha)), lotCommits: lotCommits(c.loadPlan(), l.repo, l.lot).map((k) => k.sha) }) : [];
+    const locked = done.step.headBefore ? lockViolations(wd(c), c.config.spec.dir, done.step.headBefore, { rouge: l.accept?.rouge ? { [l.accept.acceptation]: l.accept.rouge } : {}, lot: l.lot, lotBase: l.steps.find((s) => s.headBefore)?.headBefore, lotStart: lotStartHead(wd(c), lotWork(histPlan(c), wd(c), l.lot).map((k) => k.sha)), lotCommits: lotCommits(histPlan(c), wd(c), l.lot).map((k) => k.sha) }) : [];
     if (locked.length) {
         stop(c, 'handed-back', `verrou des tests d'acceptation : ${locked.join(' ; ')}`);
         return;
@@ -1624,6 +1952,7 @@ async function work(c, kind) {
         transition(c, 'question', questions[0]);
         return;
     }
+    l.docsFix = false; // la passe du bibliothécaire est jouée (une question la garde : la reprise rejoue son brief) : la suite se décide sur son rapport
     const dirt = dirtAfter(done);
     if (dirt.length) {
         stop(c, 'handed-back', `dépôt sale après ${kind} : ${dirt.join(', ')}`);
@@ -1631,13 +1960,13 @@ async function work(c, kind) {
     }
     // Reprise : une session précédente de l'étape (correction ordinaire ou passe des mineurs) a pu commiter avant d'être coupée ; la revue d'origine ne vaut alors plus.
     // Référence : le HEAD de départ de la première session coupée de la série qui précède celle-ci (pas la revue, qui peut ne pas exister encore).
-    let resumedFrom;
+    let interruptedAt;
     for (const s of l.steps.slice(0, -1).reverse()) {
         if (s.kind !== 'fix' || s.status !== 'interrupted')
             break;
-        resumedFrom = s.headBefore;
+        interruptedAt = s.headBefore;
     }
-    const headMoved = kind === 'fix' && made === 0 && !!resumedFrom && git(l.repo, 'rev-parse', 'HEAD') !== resumedFrom;
+    const headMoved = kind === 'fix' && made === 0 && !!interruptedAt && git(wd(c), 'rev-parse', 'HEAD') !== interruptedAt;
     if (minorsPass && made === 0 && !headMoved) {
         // Rien à corriger (mineurs jugés faux, listés en « choix ») : la revue conforme d'origine vaut, HEAD n'a pas bougé.
         for (const k of l.constats.filter((k) => k.gravite === 'mineur'))
@@ -1657,11 +1986,19 @@ async function work(c, kind) {
     }
     // La session peut n'avoir plus rien à commiter (réponse du lead, lot commité avant la vague) : le travail du lot est déjà dans git.
     // Même règle côté fix (L56) : la passe n'avait rien à ajouter, le lot a déjà ses commits de travail → revue neuve ; la passe reste consommée, MAX_PASSES borne la boucle.
-    const alreadyDone = hasWork(plan, l);
+    const alreadyDone = hasWork(plan, wd(c), l);
     if (made === 0 && !alreadyDone && !headMoved) {
         stop(c, 'handed-back', `${kind} sans commit`);
         return;
     }
+    // L317 : la passe du bibliothécaire qui laisse l'écart ouvert (rien commité, ou autre chose que la documentation) ne passe pas à la revue : le lot ne finirait pas prêt, `raf check` resterait rouge.
+    if (docsPass) {
+        const open = openDocGap(c);
+        if (open) {
+            stop(c, 'handed-back', open);
+            return;
+        }
+    }
     if (headMoved)
         l.warnings.push(`${minorsPass ? 'passe des mineurs' : 'correction'} reprise sans nouveau commit : un commit d'une session précédente est relu par la revue`);
     else if (made === 0)
@@ -1697,31 +2034,8 @@ async function work(c, kind) {
         if (green)
             red.push(green);
     }
-    if (red.length === 0) {
-        for (const [label, command] of [['tests', c.config.test], ['build', c.config.build]]) {
-            if (!command)
-                continue;
-            const r = await sh(c, command);
-            const run = { label, command, code: r.code };
-            runs.push(run);
-            if (r.code === 0)
-                continue;
-            const vs = label === 'tests' ? await againstBaseline(c, command, r.output) : { kind: 'unknown' };
-            if (vs.kind === 'existing') {
-                run.dejaRouges = vs.n;
-                const note = `${vs.n} test(s) déjà rouge(s) au sha de départ ${(l.baseline?.sha ?? '').slice(0, 7)}, pas un défaut du lot : listés à part, la revue a lieu`;
-                if (!l.warnings.includes(note))
-                    l.warnings.push(note);
-                continue;
-            }
-            if (vs.kind === 'new') {
-                red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) : ${vs.nouveaux.length} test(s) rouge(s) qui ne l'étaient pas au sha de départ :\n${vs.nouveaux.map((t) => `- ${t}`).join('\n')}${vs.existants ? `\n(${vs.existants} autre(s) test(s) déjà rouge(s) au sha de départ : à ne pas corriger)` : ''}` });
-                break;
-            }
-            red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) :\n${r.output.trim().split('\n').slice(-40).join('\n')}` });
-            break;
-        }
-    }
+    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))
         red.push(claimed);
@@ -1729,8 +2043,46 @@ async function work(c, kind) {
         toFix(c, red, 'tests rouges');
         return;
     }
+    // Porte « code modifié sans test » (L287) : le diff du lot (son dépôt et ses voisins, fichiers supprimés exclus), toutes sessions comprises, touche du code sans fichier de test → correction directe, sans session de revue. Une seule fois par lot, jamais pendant la passe des mineurs, ni quand la correction prendrait la dernière passe (la revue n'en aurait plus), ni quand le budget du lot ne paie plus la correction (la revue, elle, part toujours).
+    const gate = c.config.testGate;
+    if (gate && !l.testGate && !minorsPass) {
+        // Le diff du lot : son dépôt et ses dépôts voisins (comme hasWork), sans les fichiers que le lot supprime (du code mort supprimé n'a pas de test à écrire).
+        const touched = new Set([
+            ...filesOf(wd(c), lotWork(plan, wd(c), l.lot), { withoutDeleted: true }),
+            ...(l.repos ?? []).flatMap((r) => [...filesOf(r.path, repoWork(plan, r, l.lot), { withoutDeleted: true })]),
+        ]);
+        const missing = testGateMissing(gate, touched);
+        if (missing.length) {
+            l.testGate = true;
+            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(', ')})`);
+            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;
+            }
+        }
+    }
+    // Bibliothécaire (L306) : docs.sync signale un document en retard sur les commits du lot → une passe doc-keeper avant la revue, une seule fois par lot, aux mêmes conditions de passe et de budget que la porte ci-dessus. Si elle ne touche pas le document, la revue part et porte l'écart (brief docs.sync, constat majeur).
+    if (!l.docsGate && !minorsPass) {
+        const { gaps } = docGaps(c);
+        if (gaps.length) {
+            l.docsGate = true;
+            const late = gaps.flatMap((g) => g.touched).join(', ');
+            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})`);
+            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');
+                return;
+            }
+        }
+    }
     l.constats = [];
-    l.checks = runs.length ? { head: git(l.repo, 'rev-parse', 'HEAD'), runs } : undefined;
+    l.checks = runs.length ? { head: git(wd(c), 'rev-parse', 'HEAD'), runs } : undefined;
     l.next = firstReview(c);
     save(c);
 }
@@ -1780,7 +2132,7 @@ async function review(c, kind) {
     const l = c.lot;
     const ux = c.config.ux;
     // Un état repris, écrit avant L221, peut porter next = ux : l'UX ne part que sur une revue de code conforme du HEAD courant, sinon la revue de code passe d'abord (R9).
-    if (kind === 'ux' && !(l.code?.conforme && l.code.head === git(l.repo, 'rev-parse', 'HEAD'))) {
+    if (kind === 'ux' && !(l.code?.conforme && l.code.head === git(wd(c), 'rev-parse', 'HEAD'))) {
         l.next = codeReview(l);
         if (l.status === 'suspended')
             l.status = 'reviewing'; // reprise d'un lot suspendu : la boucle de runLot enchaîne sur la revue de code au lieu de rendre la main
@@ -1788,15 +2140,26 @@ async function review(c, kind) {
         return;
     }
     if (!ux?.command || !ux.url || !seesApp(l, kind))
-        return reviewStep(c, kind);
+        return (await reviewStep(c, kind))?.();
+    // Une seule application à la fois dans le dépôt (L279, R16) : l'étape qui la lance attend celle d'un autre lot du dépôt, sans retenir de créneau de session ; les autres étapes ne passent pas ici.
+    const appTurn = (await mutexFor(`app:${gitCommonDir(c.lot.repo)}`).acquire());
     const halt = halted(c.wave, l);
     if (halt) {
+        appTurn();
         suspend(c, halt); // la session n'aurait pas lieu : l'application ne se lance pas pour rien
         return;
     }
     let skipped = false;
+    let conclusion;
     c.wave.log(`${lotKey(l.project, l.lot)} · lancement de l'application (${ux.url})`);
-    const app = await startApp({ command: ux.command, url: ux.url, cwd: l.repo, nodeBin: l.node?.link, log: join(c.wave.store.lotDir(l.project, l.lot), 'ux-app.log'), timeoutMs: (ux.timeout ?? APP_TIMEOUT_S) * 1000 });
+    let app;
+    try {
+        app = await startApp({ command: ux.command, url: ux.url, cwd: wd(c), nodeBin: l.node?.link, log: join(c.wave.store.lotDir(l.project, l.lot), 'ux-app.log'), timeoutMs: (ux.timeout ?? APP_TIMEOUT_S) * 1000 });
+    }
+    catch (e) {
+        appTurn();
+        throw e;
+    }
     try {
         c.app = app.state;
         if (app.state.kind !== 'ready') {
@@ -1809,14 +2172,17 @@ async function review(c, kind) {
         }
         else if (l.uxNote?.startsWith('UX non vérifiée'))
             l.uxNote = undefined;
-        await reviewStep(c, kind);
+        conclusion = await reviewStep(c, kind);
     }
     finally {
         c.app = undefined;
         await app.stop();
+        appTurn();
+        // La conclusion (l'intégration d'un lot en worktree : verrou, rebase, tests rejoués) vient une fois l'application arrêtée et son tour rendu.
         if (skipped && l.code)
             await conclude(c, l.code, noCommitNote(l));
     }
+    await conclusion?.();
 }
 async function reviewStep(c, kind) {
     const l = c.lot;
@@ -1840,9 +2206,8 @@ async function reviewStep(c, kind) {
         save(c);
         // L'UX est la dernière étape (L221) : conforme, le lot conclut avec la revue de code ; sinon une correction (jamais une revue de code d'office), la revue de code et l'UX rejouée suivent.
         if (summary.conforme)
-            await conclude(c, l.code, noCommitNote(l));
-        else
-            toFix(c, l.constats, 'UX non conforme');
+            return () => conclude(c, l.code, noCommitNote(l));
+        toFix(c, l.constats, 'UX non conforme');
         return;
     }
     l.code = summary;
@@ -1898,64 +2263,298 @@ async function reviewStep(c, kind) {
             save(c);
         }
         else
-            await conclude(c, summary);
+            return () => conclude(c, summary);
         return;
     }
     const constats = blockingConstats(rep, 'code');
     (l.reviewCounts ??= []).push(constats.length);
     toFix(c, constats, 'revue non conforme');
 }
-/** Revue conforme : le verdict est enregistré avec le sha relu, puis le commit du plan. `raf done` reste au lead. */
+/**
+ * Revue conforme : le verdict est enregistré avec le sha relu, puis le commit du plan. `raf done` reste au lead.
+ * Un lot en worktree (L279) n'écrit rien au plan ici : le verdict et la clôture des sous-tâches attendent l'intégration, qui les écrit après l'avance de la branche
+ * du dépôt (R22, R23) ; le lot passe alors à l'étape `integrate`, la seule que `--resume --integrate` rejoue (R14, R27).
+ */
 async function conclude(c, code, minorNote = '') {
     const l = c.lot;
-    const plan = c.loadPlan();
+    const plan = histPlan(c);
     // Dépôts voisins du lot (L62) : le sha lu de chacun est enregistré avec le verdict, et dit dans son texte (un plan en lecture seule n'a que le texte).
     const neighbours = l.repos ?? [];
     const shas = repoShas(plan, neighbours, l.lot);
     const read = neighbours.length ? ` ; dépôts relus : ${neighbours.map((r) => `${r.rel}@${shas[r.rel]?.slice(0, 7) ?? 'aucun commit du lot'}`).join(', ')}` : '';
     const verdict = `${code.verdict} — orchestré (vague ${c.wave.id}, ${l.pass} passe(s) de correction${l.minorPass ? ` + passe des mineurs${minorNote}` : ''}${read})`;
     l.verdict = verdict;
-    const newer = lotWork(plan, l.repo, l.lot)[0]?.sha ?? null;
-    const moved = (code.head && newer !== null && git(l.repo, 'rev-parse', 'HEAD') !== code.head ? [''] : []).concat(neighbours.filter((r) => shas[r.rel] !== null && code.repoHeads?.[r.rel] && git(r.path, 'rev-parse', 'HEAD') !== code.repoHeads[r.rel]).map((r) => ` dans ${r.rel}`));
+    const newer = lotWork(plan, wd(c), l.lot)[0]?.sha ?? null;
+    // L317 : la porte du bibliothécaire peut ne pas avoir été jouée (passes ou budget épuisés) ; un écart docs.sync ouvert ne finit jamais prêt.
+    const gap = openDocGap(c);
+    if (gap) {
+        stop(c, 'handed-back', gap);
+        return;
+    }
+    const moved = (code.head && newer !== null && git(wd(c), 'rev-parse', 'HEAD') !== code.head ? [''] : []).concat(neighbours.filter((r) => shas[r.rel] !== null && code.repoHeads?.[r.rel] && git(r.path, 'rev-parse', 'HEAD') !== code.repoHeads[r.rel]).map((r) => ` dans ${r.rel}`));
     if (moved.length) {
         stop(c, 'handed-back', `un commit est postérieur à la revue${moved.join(',')} : verdict non enregistré`);
         return;
     }
     l.constats = [];
+    if (c.tree?.active) {
+        l.next = 'integrate';
+        save(c);
+        await integrateLot(c);
+        return;
+    }
+    const dirty = await writeVerdict(c, verdict, newer);
+    if (dirty) {
+        stop(c, 'handed-back', dirty);
+        return;
+    }
+    l.next = null;
+    transition(c, 'ready', 'prêt à livrer');
+}
+/**
+ * Écrit au plan, dans le dépôt du projet, l'entrée du lot : verdict (au sha `commit`, avec la trace `reporte` d'un verdict reporté), sous-tâches couvertes
+ * passées à done, puis le commit du plan seul ; pour un plan en lecture seule, l'outil `orchestrate.verdict` du projet, lancé dans ce dépôt (R21, R23).
+ * Rend la cause d'un refus (arbre sale hors plan), null sinon. Un verdict déjà écrit et commité au même sha n'est pas écrit deux fois (reprise de l'intégration, R23).
+ */
+async function writeVerdict(c, verdict, commit, reporte) {
+    const l = c.lot;
+    const plan = c.loadPlan();
+    const neighbours = l.repos ?? [];
+    const shas = repoShas(plan, neighbours, l.lot);
     // Sous-tâches ouvertes que des commits du lot citent (L82) : la revue conforme vaut pour elles, sinon `raf done` refuserait le lot.
     const covered = coveredTasks(plan, l.repo, l.lot, neighbours.flatMap((r) => repoWork(plan, r, l.lot)));
+    // En worktree, rien n'est écrit (ni plan, ni outil du projet) si le dépôt du lead a déjà un fichier suivi modifié hors plan : le refus ne laisse pas un plan modifié non commité (R26).
+    const foreign = c.tree ? foreignDirty(c) : [];
+    if (foreign.length)
+        return `arbre du dépôt modifié (${foreign.join(', ')})`;
+    // Le commit de plan va sur la branche courante du dépôt : en worktree, elle doit être encore la branche de départ (R24), même si le lead a bougé depuis l'avance.
+    if (c.tree) {
+        const cur = repoBranch(l.repo);
+        if (cur !== c.tree.base)
+            return `dépôt sur ${cur ?? 'HEAD détaché'} et non ${c.tree.base}`;
+    }
     if (!plan.readonly) {
-        plan.recordReview(l.lot, verdict, c.wave.today, newer, neighbours.length ? shas : undefined);
+        // 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;
+        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})`);
-        if (dirty) {
-            stop(c, 'handed-back', dirty);
-            return;
-        }
+        if (dirty)
+            return dirty;
     }
     else {
         for (const k of covered)
             propose(c, `[sous-tâche clore] ${l.lot}/${k.task} — couverte par ${k.sha.slice(0, 7)}, revue conforme : à clore avant raf done`);
     }
     if (plan.readonly && c.config.verdict) {
-        const r = await sh(c, c.config.verdict.replaceAll('{lot}', l.lot).replaceAll('{verdict}', shEscape(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 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})`);
-            if (dirty) {
-                stop(c, 'handed-back', dirty);
-                return;
+            if (dirty)
+                return dirty;
+        }
+    }
+    return null;
+}
+/**
+ * Les fichiers que le cycle a le droit de commiter dans `repo` : le plan, ce qui est tenu avec lui, et les acceptation.json (L173), où il pose le scellé et `vert: true`.
+ * Source commune de `commitPlan` et de `foreignDirty`.
+ */
+function planOwnFile(c, repo) {
+    const plan = c.loadPlan();
+    const own = new Set([relative(repo, plan.path), ...plan.maintained]);
+    const specDir = `${c.config.spec.dir.replace(/\/+$/, '')}/`;
+    return (f) => own.has(f) || (f.startsWith(specDir) && isAcceptationFile(f));
+}
+/** Les fichiers suivis modifiés du dépôt du projet qui ne sont ni le plan, ni ce qui est tenu avec lui, ni une acceptation : ce que `commitPlan` refuserait (R26). */
+function foreignDirty(c) {
+    const ownFile = planOwnFile(c, c.lot.repo);
+    return trackedDirty(c.lot.repo).filter((f) => !ownFile(f));
+}
+/** Pourquoi le dépôt du lead n'est plus celui que l'intégration a vu au départ : branche changée ou HEAD détaché (R24), fichier suivi modifié (R8). Null s'il est intact. */
+function leadMoved(repo, base) {
+    const cur = repoBranch(repo);
+    if (cur !== base)
+        return `le dépôt est sur ${cur ?? 'HEAD détaché'} et non sur ${base}`;
+    const dirty = trackedDirty(repo);
+    return dirty.length ? `arbre du dépôt modifié (${dirty.join(', ')})` : null;
+}
+/** 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) {
+    if (!c.tree)
+        return write();
+    const l = c.lot;
+    const grant = await takeRepoWrite(l.repo, { wave: c.wave.id }, c.wave.integrate);
+    if (!grant.ok)
+        return `écriture du plan refusée : verrou tenu par ${grant.holder.wave} (pid ${grant.holder.pid})`;
+    try {
+        const cur = repoBranch(l.repo);
+        if (cur !== c.tree.base)
+            return `écriture du plan refusée : dépôt sur ${cur ?? 'HEAD détaché'} et non ${c.tree.base}`;
+        const foreign = foreignDirty(c);
+        if (foreign.length)
+            return `écriture du plan refusée : arbre du dépôt modifié (${foreign.join(', ')})`;
+        return await write();
+    }
+    finally {
+        grant.release();
+    }
+}
+/** Début de la cause d'un lot rendu sur le refus d'écrire les notes d'hypothèses de sa fiche, et des mineurs de la revue de sa fiche (handBackPlan). */
+export const HYPOTHESES_HANDBACK = 'notes des hypothèses de la fiche : ';
+const MINORS_HANDBACK = 'notes des mineurs de la revue de ';
+/**
+ * Lot rendu sur une écriture de plan refusée hors intégration (R26) : en worktree il garde l'étape atteinte (`next`), et `--resume --replay` le rejoue à cette étape
+ * (décision du lead du 24-10). Aucun champ d'état : la cause rendue le désigne.
+ */
+export const planNoteHandBack = (l) => l.status === 'handed-back' && l.next !== null && l.next !== undefined && !!l.outcome && (l.outcome.startsWith(HYPOTHESES_HANDBACK) || l.outcome.startsWith(MINORS_HANDBACK));
+/** Une écriture de plan refusée rend le lot au lead ; en worktree, il garde l'étape atteinte pour la reprise (R26), sinon `stop` la vide comme avant. */
+function handBackPlan(c, why) {
+    if (c.tree)
+        transition(c, 'handed-back', why);
+    else
+        stop(c, 'handed-back', why);
+}
+/** Ce qui sépare le verdict de la revue du lot de celui de sa revue courte du diff rebasé (R17). */
+const SHORT_REVIEW_TRACE = ' ; revue courte du diff rebasé (patch-id différent) : ';
+const minutesText = (ms) => (ms % 60_000 === 0 ? `${ms / 60_000} minute${ms === 60_000 ? '' : 's'}` : `${Math.round(ms / 1000)} s`);
+/**
+ * Intégration d'un lot en worktree à la branche du dépôt (L279, C2), AVANT sa transition à ready (R22). Sous le verrou d'intégration : branche du dépôt encore
+ * celle de départ (R24), aucun fichier suivi modifié (R8), rebase sur le sommet courant (conflit : abandonné, rendu au lead, R6), contrôles rejoués au sommet
+ * rebasé (R7), report du verdict si le patch-id est le même (R9) ou revue courte du diff rebasé sinon (R17), avance en fast-forward, puis écriture du plan dans le
+ * dépôt du projet (R23). Tout rendu garde `next: integrate` et le worktree : seul `--resume --integrate` le rejoue (R14, R27).
+ */
+async function integrateLot(c) {
+    const l = c.lot;
+    const key = lotKey(l.project, l.lot);
+    const refuse = (why) => {
+        l.next = 'integrate';
+        transition(c, 'handed-back', why);
+    };
+    // Un lot repris à l'intégration dont le worktree a été retiré entre-temps (`--remove-worktree`) n'a plus rien à intégrer.
+    if (!c.tree?.active) {
+        // Une branche encore là mais sans sa clé `branch.<nom>.cadence-base` (supprimée à la main, config perdue) n'est pas une branche retirée : elle n'est pas rejouée, et rien n'est dit « abandonné ».
+        const br = lotBranch(c.wave.id, l.project, l.lot);
+        if (branchExists(l.repo, br))
+            return refuse(`intégration impossible : la branche ${br} existe mais n'est plus marquée comme worktree de cadence (branch.${br}.cadence-base absente) : rien n'est intégré ni retiré, à vérifier à la main`);
+        return refuse("intégration impossible : le worktree du lot n'existe plus (retiré par --remove-worktree ?) : commits abandonnés, sa branche n'est plus là pour être intégrée");
+    }
+    const t = c.tree;
+    const kept = `worktree conservé : ${t.dir}`;
+    const waitMs = c.wave.integrate?.waitMs ?? INTEGRATE_WAIT_MS;
+    const grant = await takeRepoWrite(l.repo, { wave: c.wave.id }, c.wave.integrate);
+    if (!grant.ok)
+        return refuse(`intégration refusée : verrou d'intégration tenu par ${grant.holder.wave} (pid ${grant.holder.pid}) depuis plus de ${minutesText(waitMs)} ; ${kept}`);
+    // Un refus tardif garde `l.verdict` avec la trace de la revue courte déjà jouée : reprise, elle est rejouée et remplace l'ancienne trace au lieu de s'y ajouter.
+    let verdict = (l.verdict ?? '').split(SHORT_REVIEW_TRACE)[0];
+    let reporte;
+    let start = '';
+    try {
+        const moved = leadMoved(l.repo, t.base);
+        if (moved)
+            return refuse(`intégration refusée : ${moved} ; branche conservée : ${t.branch}`);
+        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)) {
+            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 };
+                }
+                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}`);
+            advance(l.repo, t.branch);
         }
+        const end = git(l.repo, 'rev-parse', `refs/heads/${t.base}`);
+        if (end !== start)
+            c.wave.log(`${key} intégré : ${start.slice(0, 7)}..${end.slice(0, 7)}`);
+        if (reporte)
+            c.wave.log(`${key} verdict reporté : ${reporte.de.slice(0, 7)} → ${reporte.vers.slice(0, 7)} (patch-id identique)`);
+        // Le plan, sous le même verrou, après l'avance : un commit de plan seul au sommet de la branche du dépôt, `commit` = dernier commit de travail intégré (R23).
+        const commit = lotWork(c.loadPlan(), l.repo, l.lot)[0]?.sha ?? null;
+        // Aucun commit de travail au sommet : il n'y a rien d'intégré, donc rien qu'un verdict conforme puisse couvrir.
+        if (commit === null)
+            return refuse(`intégration impossible : aucun commit du lot dans ${t.base} (commits abandonnés ?) ; ${kept}`);
+        const refusal = await writeVerdict(c, verdict, commit, reporte);
+        if (refusal)
+            return refuse(`écriture du plan refusée : ${refusal}`);
     }
+    catch (e) {
+        return refuse(`intégration impossible : ${gitFailure(e)} ; ${kept}`);
+    }
+    finally {
+        grant.release();
+    }
+    // Intégré : le worktree et la branche, propres et fusionnés, sont retirés (R12) ; sinon ils restent et le journal le dit.
+    const removed = removeTree({ repo: l.repo, dir: t.dir, branch: t.branch, base: t.base });
+    if (!removed.ok)
+        c.wave.log(`orchestrate : ${key} : worktree conservé : ${t.dir} (branche ${t.branch})`);
+    else
+        t.active = false;
     l.next = null;
     transition(c, 'ready', 'prêt à livrer');
 }
+/**
+ * Revue courte (`review-small`) du diff rebasé (R17), jouée sous le verrou d'intégration. `refused` : le nombre de constats bloquants ou majeurs, dit en clair ;
+ * `null` : la session n'a pas eu lieu (budget, quota, arrêt) et le lot est suspendu ou rendu par `session`.
+ */
+async function shortReview(c) {
+    c.integration = { base: c.tree.base };
+    try {
+        const done = await session(c, 'review-small');
+        if (!done)
+            return null;
+        const rep = checkShape(done.report, REVIEW_SCHEMA);
+        const n = rep.bloquants + rep.majeurs;
+        if (n > 0)
+            return { refused: `${n} constat(s) bloquant(s) ou majeur(s)` };
+        return { verdict: rep.verdict };
+    }
+    catch (e) {
+        return { refused: `rapport illisible (${e.message})` };
+    }
+    finally {
+        c.integration = undefined;
+    }
+}
 /** Formes connues de « pas de question » : l'entrée entière, normalisée, doit en égaler une (liste fermée, L52). */
 const NON_QUESTIONS = new Set([
     '', 'vide', '(vide)', 'n/a', 'na', 'none', 'nothing', 'nil', 'rien', 'néant', 'neant', 'aucune', 'aucun',
@@ -2024,6 +2623,23 @@ function waveCommits(c, repo) {
     }
     return (sha) => known.has(sha) || prefixes.some((p) => sha.startsWith(p));
 }
+/** Crée le worktree du lot à la prise de son créneau, ou le retrouve à la reprise (R3, R11). Faux quand il est impossible : le lot seul est rendu avec la cause git, les autres continuent (R5). */
+async function ensureTree(c) {
+    const t = c.tree;
+    if (!t || t.active)
+        return true;
+    const l = c.lot;
+    const key = lotKey(l.project, l.lot);
+    const made = prepareTree({ repo: l.repo, dir: t.dir, branch: t.branch, base: t.base, lot: key });
+    if (!made.ok) {
+        c.wave.log(`orchestrate : ${key} : worktree impossible : ${made.cause}`);
+        stop(c, 'handed-back', `worktree impossible : ${made.cause}`);
+        return false;
+    }
+    t.active = true;
+    c.wave.log(`${key} · worktree ${made.reused ? 'retrouvé' : 'créé'} : ${t.dir} (branche ${t.branch})`);
+    return true;
+}
 /** Joue le cycle d'un lot jusqu'à son terme, ou jusqu'à l'arrêt (question, budget, quota). Ne lève jamais. */
 export async function runLot(c) {
     const l = c.lot;
@@ -2037,9 +2653,12 @@ export async function runLot(c) {
         }
         if (l.status === 'question' && !l.pendingAnswer)
             return;
+        // Un lot déjà commencé retrouve son worktree (R11) ; un lot neuf n'en a un qu'une fois son raf start fait, dans le dépôt du projet (R21).
+        if ((l.next !== null || l.steps.length > 0) && !(await ensureTree(c)))
+            return;
         // Un test rescellé par le lead pendant la question (L200) a déplacé le commit rouge : l'ancre suit, le verrou garde le reste.
         if (l.status === 'question' && l.accept?.rouge)
-            l.accept.rouge = resealedRouge(l.repo, l.accept.acceptation, l.accept.rouge, waveCommits(c, l.repo)) ?? l.accept.rouge;
+            l.accept.rouge = resealedRouge(wd(c), l.accept.acceptation, l.accept.rouge, waveCommits(c, l.repo)) ?? l.accept.rouge;
         if (l.next === null && l.steps.length === 0) {
             if (dropped(c)) {
                 stop(c, 'handed-back', DROPPED);
@@ -2051,19 +2670,28 @@ export async function runLot(c) {
                 suspend(c, halt);
                 return;
             }
-            const before = await snapshot(l.repo, { remote: false });
-            if (before.tracked.length) {
-                stop(c, 'handed-back', `dépôt sale avant le lot : ${trackedPaths(before).join(', ')}`);
-                return;
-            }
-            const why = await startLot(c);
+            // Le raf start et son commit de plan sont une écriture du dépôt du projet : sous le verrou du dépôt quand le lot a un worktree (R21, R26).
+            const why = await planWrite(c, async () => {
+                const before = await snapshot(l.repo, { remote: false });
+                if (before.tracked.length)
+                    return `dépôt sale avant le lot : ${trackedPaths(before).join(', ')}`;
+                return startLot(c);
+            });
             if (why) {
                 stop(c, 'handed-back', why);
                 return;
             }
-            l.startedSha = (await snapshot(l.repo, { remote: false })).head ?? undefined;
-            l.next = needsPrecheck(c.config, c.loadPlan(), l.repo, l.lot, l.repos) ? 'precheck' : firstWrite(c);
-            save(c);
+            if (!(await ensureTree(c)))
+                return;
+            l.startedSha = (await snapshot(wd(c), { remote: false })).head ?? undefined;
+            // Un lot repris de sa branche conservée (L311) n'a rien à faire contrôler : ses commits sont les siens. Il repart à la correction des constats de sa dernière revue, à la revue s'il en a passé une sans constat, à l'écriture s'il n'a jamais été revu.
+            // La correction de départ est une passe comme les autres (toFix : l.pass, verdict, tableau, MAX_PASSES bornent le total, reprise comprise).
+            if (l.resumedFrom && l.constats.length)
+                toFix(c, l.constats, 'reprise de la branche');
+            else {
+                l.next = l.resumedFrom ? (l.resumedReviewed ? firstReview(c) : firstWrite(c)) : precheckOrSkip(c) ? 'precheck' : firstWrite(c);
+                save(c);
+            }
         }
         while (l.next && !TERMINAL.has(l.status)) {
             const kind = l.next;
@@ -2081,6 +2709,8 @@ export async function runLot(c) {
                 await acceptStep(c);
             else if (kind === 'implement' || kind === 'fix')
                 await work(c, kind);
+            else if (kind === 'integrate')
+                await integrateLot(c);
             else
                 await review(c, kind);
             if (l.status === 'suspended' || l.status === 'question')
@@ -2092,9 +2722,16 @@ export async function runLot(c) {
         transition(c, 'failed', `erreur : ${e.message}`);
     }
     finally {
+        // TMPDIR court des sessions (L243) : jetable, retiré à la fin de chaque passage du lot ; la session suivante (reprise, réponse) le recrée.
+        try {
+            c.wave.store.removeTmpDir(l.project, l.lot);
+        }
+        catch {
+            // nettoyage de confort : jamais une cause d'échec du lot
+        }
         // Sorties du MCP Playwright qu'une session a écrites dans le dépôt (L50) : jetables, retirées à la fin de chaque passage du lot.
         try {
-            cleanPlaywrightOutput(l.repo);
+            cleanPlaywrightOutput(wd(c));
         }
         catch {
             // nettoyage de confort : jamais une cause d'échec du lot