@sylad/cadence 1.42.1 → 1.43.0

package/dist/orchestrate/command.js

@@ -1,347 +1,31 @@
-import { gateProgress, gateText } from '../audit.js';
 import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { availableParallelism, tmpdir } from 'node:os';
-import { testWorkersFrom } from './workers.js';
-import { basename, join, resolve } from 'node:path';
-import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readOrchestrateConfig, readPlanConfig } from '../config.js';
-import { PLAN_ACTIONS, commitMsgHook, leadAnswerMessage, commitMsgRefusal, planCommitMessage } from '../plan-commit.js';
+import { existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
 import { isDay, toDay } from '../dates.js';
-import { gitRoot } from '../git.js';
-import { heldRefusal, localLotRefusal, localOverdueLines } from '../local-task.js';
-import { onTermination } from '../proc.js';
-import { stopApps } from './app.js';
-import { RafError, isOpen } from '../plan.js';
+import { RafError } from '../plan.js';
 import { AGENTS_DIR } from '../skills.js';
-import { pidAlive, sharedStateDir } from '../state.js';
-import { findProjects, isProject as isLeadProject } from '../lead.js';
-import { freeLine, readyFree } from '../ready-free.js';
-import { acquireSlot, cadenceHome, expiredHolds, freeSlots, liveHolds, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
-import { decisionsText, humanDecisions } from './decisions.js';
-import { headline, loadTemplates, newsText, objective, renderBrief } from './briefs.js';
 import { readWaits, renderWaits } from './waits.js';
-import { acceptationFile, acceptText, redAcceptations } from './accept.js';
-import { noTestGate, noTestText } from './no-test.js';
-import { ficheReviewText } from './fiche.js';
-import { maquetteText } from './maquette.js';
-import { budgetStage, costlyHypotheses, lightLot, specText, stageScreen } from './spec.js';
-import { fichesDuDossier } from '../spec.js';
-import { candidates, fillTargets, handedBackStreak, parsePriority, parseUntil, drawSettingsReport, readPriority, stopReason } from './continue.js';
-import { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, leadReviewedHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
-import { installPrePush, keepGateGuard, longDuration, removePrePush } from './guard.js';
-import { buildArgs, buildLocalArgs, claudeConfigDir, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude, enabledPlugins, settingsFiles } from './launch.js';
-import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
-import { groupLots, runPool } from './pool.js';
-import { slotPlace } from './attente.js';
-import { AddFeed, addNotAlone, addToLive, openInRepo, projectName } from './ajout.js';
-import { repoRefusals, trackedDirty } from './depot.js';
-import { adoptLeadReview, depositIntegrations, depositsOnly, integrationText, runsElsewhere, takeIntegrations } from './integration-vivante.js';
+import { parseUntil } from './continue.js';
+import { claudeConfigDir, realClaude } from './launch.js';
+import { addNotAlone } from './ajout.js';
 import { removeWorktree } from './retrait.js';
-import { repoBranch } from './integrate.js';
-import { baseBranchOf, keptLines, lotBranch, lotTreeDir, planFileSet, recoverTree } from './worktree.js';
-import { effortKey, schemaFor, stepAgent } from './schemas.js';
-import { resolveLotRepos } from '../repos.js';
-import { excludeState, lotFinished, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
-import { isExpress } from './express.js';
-import { linkNodeBin, nvmVersionsDir, resolveNode } from './node-env.js';
-import { estimateLines, launchPrices, quotaText, renderDetail, renderTable, resumeCommand } from './table.js';
-import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, repairSnapshotModules, snapshotExists, waveReadsAnswerQueue, waveReadsControl, waveReadsIntegrate, waveReadsLotBudget, waveReadsReplay, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
-const REPO_WAIT_MS = 3 * 60 * 60_000;
-const REPO_WAIT_POLL_MS = 5_000;
+import { lotKey, RunStore } from './state.js';
+import { linkNodeBin } from './node-env.js';
+import { estimateLines, resumeCommand } from './table.js';
+import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, withoutLaunchVars, spawnReexec, takeSnapshot } from './snapshot.js';
+import { preflight, resolveTargets } from './preflight.js';
+export { preflight, projectEnv, resolveTargets } from './preflight.js';
+import { continueDryRun, dryRun } from './dry-run.js';
+import { draw, priorityOf } from './draw.js';
+import { answerOnly, control, freeLines, maxSessions, onceAuth, statusCommand, waveExists } from './status.js';
+export { configuredCap, expiredHoldLines, liveLines, slotsLine } from './status.js';
+import { addOnlyLive, continueRounds, execute } from './execute.js';
+import { resume } from './resume.js';
+export { resumeArgv } from './resume.js';
 export const DEFAULT_BUDGET = 2_000_000;
 export { lotBudget, lotBudgetBasis, SPEC_STAGE_ALLOCATION } from './lot-budget.js';
-import { lotBudget, lotBudgetBasis } from './lot-budget.js';
-/** Sessions simultanées, toutes vagues confondues (`--max-sessions`, ou CADENCE_MAX_SESSIONS). */
-export const DEFAULT_MAX_SESSIONS = 2;
-/** `1500000`, `1.5M`, `800k`. */
-export function parseBudget(text) {
-    const m = /^(\d+(?:[.,]\d+)?)\s*([kKmM]?)$/.exec(text.trim());
-    if (!m)
-        throw new RafError(`--budget invalide : ${text} (1500000, 1.5M, 800k)`);
-    const n = Number(m[1].replace(',', '.')) * ({ '': 1, k: 1e3, m: 1e6 }[m[2].toLowerCase()]);
-    if (!(n > 0))
-        throw new RafError(`--budget invalide : ${text}`);
-    return Math.round(n);
-}
-export function parseMaxSessions(text, what = '--max-sessions') {
-    if (!/^\d+$/.test(text.trim()) || Number(text) < 1)
-        throw new RafError(`${what} invalide : ${text} (entier ≥ 1)`);
-    return Number(text);
-}
-// une vague (2026-10-04-1412) n'a ni « : » ni « / » : leur présence désigne un lot, quel que soit son motif (R-M7/ux-1)
-const LOT_LIKE = /^(?:[\w.-]+(?:\/[\w.-]+)*:[\w.-][\w./-]*|[\w.-]+\/[\w./-]*|[A-Za-z]+\d+)(?:@[\w.-]+)?$/;
-function lotArg(text) {
-    // le premier « : » sépare le projet du lot, un « @ » final le modèle ; le lot garde ses « / » (L120), le projet peut être un chemin depuis le dossier (`groupe/gamma`, projet imbriqué de lead tour --depth, L201)
-    const m = /^(?:([\w.-]+(?:\/[\w.-]+)*):)?([\w.-][\w./-]*?)(?:@([\w.-]+))?$/.exec(text);
-    if (!m)
-        throw new RafError(`lot invalide : ${text} (projet:lot, lot, projet:lot@haiku ; @ suivi d'un alias ou d'un nom de modèle)`);
-    return { project: m[1], lot: m[2], model: m[3] };
-}
-/** `projet:lot=+200k`, `lot=+0.3M` (L223) : le « = » distingue le relèvement d'un lot du budget de la vague. */
-function lotBudgetArg(text) {
-    const bad = () => new RafError(`--budget invalide : ${text} (projet:lot=+500k)`);
-    const m = /^([^=]+)=\+(.+)$/.exec(text);
-    if (!m)
-        throw bad();
-    let target;
-    let raise;
-    try {
-        target = lotArg(m[1]);
-        raise = parseBudget(m[2]);
-    }
-    catch {
-        throw bad();
-    }
-    if (target.model)
-        throw bad();
-    return { project: target.project, lot: target.lot, raise, text: m[2] };
-}
-export function parseOrchestrateArgs(argv) {
-    const a = { lots: [], lotBudgets: [], dryRun: false, waits: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false, add: [], integrate: [], abandonCommits: false };
-    const optional = (i) => (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-') && !LOT_LIKE.test(argv[i + 1]) ? argv[i + 1] : undefined);
-    for (let i = 0; i < argv.length; i++) {
-        const t = argv[i];
-        const value = (flag) => {
-            if (argv[i + 1] === undefined)
-                throw new RafError(`${flag} attend une valeur`);
-            return argv[++i];
-        };
-        if (t === '--dry-run')
-            a.dryRun = true;
-        else if (t === '--status' || t === '--resume') {
-            const v = optional(i);
-            if (v !== undefined)
-                i++;
-            a[t === '--status' ? 'status' : 'resume'] = v ?? true;
-        }
-        else if (t === '--waits')
-            a.waits = true;
-        else if (t === '--since') {
-            a.since = value(t);
-            if (!isDay(a.since))
-                throw new RafError(`--since invalide : ${a.since} (AAAA-MM-JJ)`);
-        }
-        else if (t === '--detail')
-            a.detail = value(t);
-        else if (t === '--watch')
-            a.watch = true;
-        else if (t === '--interval')
-            a.interval = parseMaxSessions(value(t), '--interval');
-        else if (t === '--budget') {
-            const v = value(t);
-            if (v.includes('='))
-                a.lotBudgets.push(lotBudgetArg(v));
-            else
-                a.budget = parseBudget(v);
-        }
-        else if (t === '--max-sessions')
-            a.maxSessions = parseMaxSessions(value(t));
-        else if (t === '--goal') {
-            // Un texte oublié ne doit pas avaler l'option suivante (`--goal --dry-run` lancerait une vraie vague payante).
-            const next = argv[i + 1];
-            if (next?.startsWith('--'))
-                throw new RafError(`--goal attend un texte, pas l'option ${next}`);
-            a.goal = value(t).trim();
-            if (a.goal === '')
-                throw new RafError('--goal attend un texte non vide');
-        }
-        else if (t === '--wave')
-            a.wave = value(t);
-        else if (t === '--drop')
-            a.drop.push(lotArg(value(t)));
-        else if (t === '--stop-after-current')
-            a.stopAfterCurrent = true;
-        else if (t === '--add')
-            a.add.push(lotArg(value(t)));
-        else if (t === '--integrate')
-            a.integrate.push(lotArg(value(t)));
-        else if (t === '--replay')
-            a.integrate.push({ ...lotArg(value(t)), replay: true });
-        else if (t === '--remove-worktree')
-            a.removeWorktree = lotArg(value(t));
-        else if (t === '--abandon-commits')
-            a.abandonCommits = true;
-        else if (t === '--continue')
-            a.continue = true;
-        else if (t === '--until')
-            a.until = value(t);
-        else if (t === '--priority')
-            a.priority = parsePriority(value(t));
-        else if (t === '--answer') {
-            const target = lotArg(value(t));
-            a.answers.push({ project: target.project, lot: target.lot, text: value(t) });
-        }
-        else if (t.startsWith('-'))
-            throw new RafError(`option inconnue : ${t}`);
-        else
-            a.lots.push(lotArg(t));
-    }
-    // L309 : --wave <id> après un --resume sans valeur désigne la vague à reprendre ; sans cela le --resume reprenait en silence une AUTRE vague.
-    if (a.resume !== undefined && a.wave !== undefined) {
-        if (a.resume === true)
-            a.resume = a.wave;
-        else if (a.resume !== a.wave)
-            throw new RafError(`--resume ${a.resume} et --wave ${a.wave} désignent deux vagues : une seule (${resumeCommand('<vague>')})`);
-    }
-    return a;
-}
-/** Ce qu'un projet fournit à l'orchestrateur : sa configuration et la lecture de son plan (comme le CLI). */
-export function projectEnv(repo) {
-    const configPath = join(repo, 'cadence.yaml');
-    const loadPlan = planLoader(repo);
-    return { config: readOrchestrateConfig(configPath), loadPlan, configPath };
-}
-const isProject = (dir) => existsSync(join(dir, PLAN_DEFAULT)) || existsSync(join(dir, PLAN_LEGACY)) || (existsSync(join(dir, 'cadence.yaml')) && /^plan\s*:/m.test(readFileSync(join(dir, 'cadence.yaml'), 'utf8')));
-export function resolveTargets(args, io, refusals) {
-    const out = [];
-    const seen = new Set();
-    for (const l of args.lots) {
-        const projectDir = l.project ? resolve(io.cwd, l.project) : io.cwd;
-        const project = projectName(io.cwd, l.project); // L421 : `.:L2` depuis le dépôt et `L2` désignent le même projet que les lots de la vague
-        const key = lotKey(project, l.lot);
-        if (seen.has(key)) {
-            refusals.push(`${key} : lot donné deux fois`);
-            continue;
-        }
-        seen.add(key);
-        if (!existsSync(projectDir) || !statSync(projectDir).isDirectory()) {
-            refusals.push(`${key} : ${l.project ? `dossier ${projectDir} introuvable (le projet est un sous-dossier du dossier courant ; dans un dépôt, \`.:${l.lot}\`)` : 'dossier courant illisible'}`);
-            continue;
-        }
-        if (!isProject(projectDir)) {
-            refusals.push(`${key} : ${projectDir} n'est pas un projet cadence (${PLAN_DEFAULT}, ${PLAN_LEGACY}, ou cadence.yaml avec une clé plan:)`);
-            continue;
-        }
-        const repo = gitRoot(projectDir);
-        if (!repo) {
-            refusals.push(`${key} : ${projectDir} n'est pas dans un dépôt git`);
-            continue;
-        }
-        out.push({ project, projectDir, repo, lot: l.lot, model: l.model ?? 'sonnet' });
-    }
-    return out;
-}
-/** `--effort` date de claude 2.1.284 (L137). Une version illisible n'est pas refusée. */
-function olderThanEffort(version) {
-    const m = /(\d+)\.(\d+)\.(\d+)/.exec(version);
-    if (!m)
-        return false;
-    const [a, b, c] = [Number(m[1]), Number(m[2]), Number(m[3])];
-    return a < 2 || (a === 2 && (b < 1 || (b === 1 && c < 284)));
-}
-/** L378 : claude installé mais non connecté échoue à la première session, après le démarrage du lot dans le plan. Null si connecté ou état illisible. */
-function notLoggedIn(deps) {
-    return deps.claudeAuth?.()?.loggedIn === false ? "claude n'est pas connecté : lancer `claude` puis /login (état : `claude auth status`)" : null;
-}
-/** Préconditions : tout ce qui peut être refusé l'est ici, avant d'agir, sans verrou ni écriture. */
-export async function preflight(args, targets, io, deps, launch, opts = {}) {
-    const refusals = [];
-    if (io.env.CADENCE_ORCHESTRATED)
-        refusals.push(`orchestrate ne se lance pas depuis une session orchestrée (vague ${io.env.CADENCE_ORCHESTRATED})`);
-    const info = deps.claudeInfo();
-    if (!info)
-        refusals.push('claude introuvable (CADENCE_CLAUDE_BIN, ou claude dans le PATH)');
-    else if (!info.jsonSchema)
-        refusals.push(`claude ${info.version} n'a pas --json-schema : mettre claude à jour`);
-    const login = info && !args.dryRun ? notLoggedIn(deps) : null; // la simulation n'ouvre pas de session : elle le signale (dryRun) sans refuser
-    if (login)
-        refusals.push(login);
-    const lots = [];
-    const repoChecked = new Set();
-    const byProject = new Map();
-    // L421 : les lots déjà portés par la vague qui reçoit l'ajout comptent comme « plus tôt dans la vague » pour les dépendances.
-    for (const l of opts.addTo?.lots ?? [])
-        byProject.set(l.project, [...(byProject.get(l.project) ?? []), l.lot]);
-    for (const t of targets) {
-        const key = lotKey(t.project, t.lot);
-        const already = opts.addTo?.lots.find((l) => l.project === t.project && l.lot === t.lot);
-        if (already) {
-            refusals.push(`${key} : lot déjà ${already.queued ? "en file d'ajout dans" : 'dans'} la vague ${opts.addTo.wave}`);
-            continue;
-        }
-        let env;
-        let plan;
-        try {
-            env = projectEnv(t.repo);
-            plan = env.loadPlan();
-        }
-        catch (e) {
-            refusals.push(`${key} : ${e.message}`);
-            continue;
-        }
-        if (info && olderThanEffort(info.version) && Object.entries(env.config.effort).some(([step, e]) => e !== 'default' && (step !== 'probe' || env.config.probe))) {
-            refusals.push(`${key} : claude ${info.version} n'a pas --effort (2.1.284 requise) : mettre claude à jour, ou orchestrate.effort à « default » pour chaque passe`);
-            continue;
-        }
-        const lot = plan.lots().find((l) => l.id === t.lot);
-        if (!lot) {
-            refusals.push(`${key} : lot inconnu`);
-            continue;
-        }
-        const shut = !isOpen(lot.status) ? `le lot est ${lot.status}` : localLotRefusal(lot); // un lot local (L519) est au lead, jamais à une vague
-        if (shut) {
-            refusals.push(`${key} : ${shut}`);
-            continue;
-        }
-        if (plan.readonly && lot.status === 'todo' && !env.config.start) {
-            refusals.push(`${key} : plan en lecture seule : démarrer le lot avec l'outil du projet (ou déclarer orchestrate.start dans cadence.yaml)`);
-            continue;
-        }
-        const earlier = byProject.get(t.project) ?? [];
-        const open = lot.after.filter((d) => {
-            const dep = plan.lots().find((x) => x.id === d);
-            return dep && isOpen(dep.status) && !earlier.includes(d);
-        });
-        if (open.length) {
-            refusals.push(`${key} : dépendance(s) ni terminée(s) ni plus tôt dans la vague : ${open.join(', ')}`);
-            continue;
-        }
-        // Condition de tirage (L219) : seuls les lots done du plan la lèvent, jamais un lot de la même vague ; un lot déjà doing n'est pas refusé pour elle.
-        const gate = lot.status === 'todo' ? gateProgress(plan.lots(), lot) : undefined;
-        if (gate && !gate.met) {
-            refusals.push(`${key} : condition de tirage non remplie : ${gate.n === 0 ? 'gate invalide (raf check)' : gateText(gate)}`);
-            continue;
-        }
-        // Dépôts voisins du lot (L62) : chacun doit exister et être un dépôt git, sinon refus avant d'agir comme pour le dépôt du projet.
-        const neighbours = resolveLotRepos(t.repo, lot);
-        if (neighbours.problems.length) {
-            refusals.push(...neighbours.problems.map((p) => `${key} : ${p}`));
-            continue;
-        }
-        byProject.set(t.project, [...earlier, t.lot]);
-        for (const repo of [t.repo, ...neighbours.repos.map((r) => r.path)]) {
-            if (repoChecked.has(repo))
-                continue;
-            repoChecked.add(repo);
-            refusals.push(...(await repoRefusals(repo, t, { io, deps, launch }, opts)));
-        }
-        const node = resolveNode(t.repo, nvmVersionsDir(io.env));
-        if (node.kind === 'missing') {
-            refusals.push(`${key} : ${node.message}`);
-            continue;
-        }
-        const small = lot.estimate <= 0.5 || lot.quickwin;
-        const goal = args.goal ?? lot.goal;
-        const screen = stageScreen(t.repo, env.config.spec.dir, lot, env.config.maquette);
-        const state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, ...(goal ? { goal } : {}), visible: lot.visible, small, ...(screen ? { screen } : {}), ...(lot.spec && !screen ? { specLot: true } : {}), model: t.model, readOnlyPlan: plan.readonly });
-        if (neighbours.repos.length)
-            state.repos = neighbours.repos;
-        state.estimate = lot.estimate;
-        if (isExpress({ estimate: lot.estimate, screen, specLot: state.specLot }))
-            state.express = true;
-        state.light = lot.estimate <= env.config.review.threshold;
-        const escalating = !!env.config.escalation;
-        state.budget = lotBudget(lot.estimate, budgetStage(lot, screen, env.config.maquette, t.repo, env.config.spec.dir), escalating);
-        if (escalating)
-            state.escalationReserve = ESCALATION_RESERVE;
-        state.dependsOn = lot.after.filter((d) => earlier.includes(d));
-        if (node.kind === 'ok')
-            state.node = { version: node.version, wanted: node.wanted, bin: node.bin, ...(node.skipped ? { skipped: node.skipped } : {}) };
-        lots.push(state);
-    }
-    return { refusals, lots };
-}
-const agentsOf = (deps) => readAgents(deps.agentsDir);
+export { DEFAULT_MAX_SESSIONS, parseBudget, parseMaxSessions, parseOrchestrateArgs } from './command-args.js';
+import { parseOrchestrateArgs } from './command-args.js';
 const WAVE_ID_RE = /^[\w.-]+$/;
 /** Identifiant par défaut : jour et minute de lancement ; le suffixe qui départage deux vagues vient de `RunStore.reserve`. */
 function defaultWaveBase(io) {
@@ -358,321 +42,6 @@ function waveId(io, requested, launch) {
         id = `${base}-${i}`;
     return id;
 }
-/** Version du `node` que le PATH donné résout (`node --version`), null s'il n'y en a pas ou s'il ne répond pas. */
-function pathNodeVersion(env) {
-    try {
-        return execFileSync('node', ['--version'], { env: { ...process.env, ...env }, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10_000 }).trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-/** La version (`v24.1.0`) commence-t-elle par ce que demande le .nvmrc (`24`, `v24`, `24.1`) ? */
-function matchesNvmrc(version, wanted) {
-    const v = version.replace(/^v/, '');
-    const w = wanted.replace(/^v/, '');
-    return v === w || v.startsWith(`${w}.`);
-}
-/**
- * Ce avec quoi le dry-run mesure les messages de la fiche d'un lot à étape spec (L343) : la fiche du lot quand elle est déjà écrite (son sujet pour les hypothèses
- * notées, ses hypothèses coûteuses pour la réponse du lead, qui ne source que les règles posées en question — `costlyHypotheses` — et n'est pas commitée sans elles),
- * sinon le sujet le plus long du dossier des fiches et autant de règles coûteuses que la fiche du dossier qui en porte le plus (1 au moins). Un sujet de 7 caractères
- * (« <sujet> ») faisait accepter un message que `header-max-length` refuse avec un sujet réel ; toutes les hypothèses d'une fiche (13) faisaient refuser une réponse qui n'en cite que les coûteuses.
- */
-function ficheMeasure(repo, dir, lot) {
-    const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-    const costly = (doc) => costlyHypotheses(doc).map((x) => x.id);
-    const fiches = fichesDuDossier(repo, dir);
-    const mine = fiches.find(({ doc }) => (isObj(doc.sujet) && doc.sujet.lot === lot) || (isObj(doc.ecran) && doc.ecran.lot === lot));
-    if (mine) {
-        const sujet = isObj(mine.doc.sujet) && typeof mine.doc.sujet.id === 'string' ? mine.doc.sujet.id : mine.name;
-        const regles = costly(mine.doc);
-        const about = regles.length ? `réponse du lead mesurée avec ${regles.length > 1 ? 'les règles coûteuses' : 'la règle coûteuse'} ${regles.join(', ')}` : 'aucune hypothèse coûteuse : pas de réponse du lead à commiter';
-        return { sujet, regles, line: `  fiche du lot : ${dir}/${mine.name}/fiche.yaml (${about})` };
-    }
-    if (!fiches.length)
-        return { sujet: '<sujet>', regles: ['R1'], line: `  aucune fiche dans ${dir} : les messages de la fiche sont mesurés avec « <sujet> » (7 caractères) et 1 règle ; un sujet réel plus long peut dépasser une limite du hook` };
-    const sujet = fiches.map((f) => f.name).reduce((a, b) => (b.length > a.length ? b : a));
-    const n = Math.max(1, ...fiches.map((f) => costly(f.doc).length));
-    return { sujet, regles: Array.from({ length: n }, (_, i) => `R${i + 1}`), line: `  fiche du lot pas encore écrite : mesure avec le sujet le plus long de ${dir} (${sujet}) et ${n} règle(s) coûteuse(s) pour la réponse du lead` };
-}
-/**
- * Les messages de commit de plan que la vague écrirait pour ce lot, passés au hook commit-msg réel du dépôt : un refus se lit ici, avant une vague payante (L343).
- * Les messages de la fiche (hypothèses, mineurs de sa revue, réponse du lead) ne sont joués que pour un lot à étape spec, avec un sujet de longueur réelle (`ficheMeasure`) ;
- * les hypothèses ne sont notées que pour un lot `spec: true` sans écran (`settleHypotheses`), la réponse du lead n'est commitée que pour une hypothèse coûteuse (`sourceAnsweredRules`).
- */
-function planMessageLines(repo, l, wave, dir) {
-    const template = readPlanConfig(join(repo, 'cadence.yaml'), repo)?.commit;
-    const specStage = !!(l.screen || l.specLot);
-    const measure = specStage ? ficheMeasure(repo, dir, l.lot) : null;
-    const actions = [PLAN_ACTIONS.started, PLAN_ACTIONS.reviewRecorded, PLAN_ACTIONS.reviewNoted];
-    if (measure) {
-        if (l.specLot && !l.screen)
-            actions.push(PLAN_ACTIONS.hypotheses(measure.sujet));
-        actions.push(PLAN_ACTIONS.minors('la fiche'));
-    }
-    const planMessages = actions.map((action) => planCommitMessage(template, { lot: l.lot, action, wave }));
-    const messages = [...new Set(measure?.regles.length ? planMessages.concat(leadAnswerMessage(template, l.lot, measure.regles, wave)) : planMessages)];
-    const hook = commitMsgHook(repo);
-    if (!hook)
-        return template ? [`  messages de plan : « ${messages[0]} » (gabarit plan.commit ; aucun hook commit-msg dans ce dépôt)`] : [];
-    const refused = messages.map((m) => ({ m, why: commitMsgRefusal(repo, m) })).filter((r) => r.why !== null);
-    const about = measure ? [measure.line] : [];
-    if (!refused.length)
-        return [`  messages de plan : ${messages.length} message(s) acceptés par le hook commit-msg du dépôt (${hook})${template ? ' — gabarit plan.commit' : ''}`, ...about];
-    return [
-        ...refused.map((r) => `  ✗ message de plan refusé par le hook commit-msg : « ${r.m} » — ${r.why}`),
-        ...about,
-        `  ✗ le lot échouerait au premier commit de plan refusé, avant ou pendant ses sessions : régler plan.commit dans cadence.yaml (gabarit avec {lot}, {action}, {vague})`,
-    ];
-}
-/** `wave` : la vague simulée — son identifiant, son budget et si elle a plus d'un créneau (L527 : tout lot d'un dépôt en worktrees y joue alors dans le sien). */
-function dryRun(lots, io, deps, { budget, id, multiSlot }) {
-    const tmp = mkdtempSync(join(tmpdir(), 'cadence-orchestrate-'));
-    const agents = agentsOf(deps);
-    io.out(`vague ${id} — simulation, rien n'est lancé (budget ${budget} tokens comptés)`);
-    const login = notLoggedIn(deps);
-    if (login)
-        io.out(`⚠ ${login} — sans cela le vrai lancement est refusé`);
-    const repos = [...new Set(lots.map((l) => l.repo))];
-    const noTestSaid = new Set();
-    const redSaid = new Set();
-    for (const l of lots) {
-        const env = projectEnv(l.repo);
-        const lot = env.loadPlan().lot(l.lot);
-        const slot = repos.indexOf(l.repo);
-        io.out(`${lotKey(l.project, l.lot)} — ${l.title}`);
-        if (l.goal)
-            io.out(`  objectif donné : ${l.goal} (à la place du titre dans les briefs)`);
-        io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, budgetStage(lot, l.screen, env.config.maquette, l.repo, env.config.spec.dir), l.escalationReserve ? env.config.escalation?.model : undefined)})`);
-        const mine = lots.filter((o) => o.repo === l.repo);
-        const together = env.config.worktrees && (mine.length > 1 || multiSlot) && !mine.some((o) => o.repos?.length) && !!repoBranch(l.repo);
-        io.out(together ? `  file ${basename(l.repo)} · en parallèle des autres lots du dépôt, dans son worktree (cadence/${id}/${lotSlug(l.project, l.lot)}, créé à la prise du créneau)` : `  file ${basename(l.repo)} · ${slot < 2 ? `créneau ${slot + 1}` : 'en attente d\'un créneau'}`);
-        if (l.repos?.length)
-            io.out(`  dépôts voisins : ${l.repos.map((r) => r.rel).join(', ')} (verrou, garde de push et --add-dir ; leurs commits citent ${l.lot})`);
-        if (l.node) {
-            const sk = l.node.skipped;
-            const skipped = sk?.length ? ` ; ${sk.join(', ')} ${sk.length > 1 ? 'écartées' : 'écartée'} : pas de node exécutable` : '';
-            io.out(`  node : ${l.node.version} (.nvmrc ${l.node.wanted}${skipped})`);
-            const gate = env.config.test || env.config.build;
-            const onPath = gate ? (deps.pathNode ?? (() => pathNodeVersion(io.env)))() : null;
-            if (onPath && !matchesNvmrc(onPath, l.node.wanted))
-                io.out(`  ⚠ .nvmrc ${l.node.wanted} ≠ node du PATH ${onPath} : la porte et les autres commandes du programme tournent sous ${l.node.version} (lien node-bin en tête du PATH), pas sous ${onPath}`);
-        }
-        const steps = [{ kind: 'implement', model: l.model }];
-        const specStage = !!(l.screen || l.specLot);
-        if (specStage && env.config.accept && !lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir))
-            steps.unshift({ kind: 'accept', model: 'sonnet' });
-        if (l.screen && env.config.maquette)
-            steps.unshift({ kind: 'maquette', model: env.config.review.full });
-        if (l.specLot && env.config.fiche)
-            steps.unshift({ kind: 'fiche', model: 'sonnet' });
-        if (specStage)
-            steps.unshift({ kind: 'spec', model: 'sonnet' });
-        if (!l.express && needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot, l.repos, l.goal)) {
-            const nothingToFind = precheckNothingToFind(env.loadPlan(), l.repo, l.lot, l.repos, l.goal);
-            if (nothingToFind)
-                io.out(`  contrôle préalable sauté : ${nothingToFind}`);
-            else
-                steps.unshift({ kind: 'precheck', model: env.config.precheckLocal ? 'local' : 'sonnet' });
-        }
-        steps.push(...(env.config.probe && !l.express ? [{ kind: 'probe', model: 'sonnet' }] : [])); // L497 : entre l'écriture et la revue
-        const { light, full } = env.config.review;
-        if (l.express) {
-            // L519 : une seule session, le lead lit le diff
-        }
-        else if (l.small)
-            steps.push({ kind: l.visible ? 'review-small' : 'review', model: l.light ? light : full });
-        else {
-            steps.push({ kind: 'review', model: l.light ? light : full });
-            if (l.visible && env.config.ux)
-                steps.push({ kind: 'ux', model: full }); // L221 : l'UX est jouée une fois, après la revue de code conforme
-        }
-        io.out(`  étapes : ${steps.map((s) => `${s.kind} (${s.model})`).join(' → ')}${l.small ? ' — petit lot' : ''}${l.express ? ' — voie express (pas de précheck, de sonde ni de revue séparée : le lead lit le diff)' : ''}${l.light && !l.express ? ` — revue légère (${light}, pas de passe des mineurs ; un bloquant ou un majeur → correction puis revue ${full})` : ''}${l.visible && !env.config.ux ? ' — UX à faire par le lead (orchestrate.ux absent)' : ''}`);
-        for (const m of new Set(steps.map((s) => s.model))) {
-            if (m !== 'local' && !MODEL_ALIASES.includes(m))
-                io.out(`  ⚠ modèle « ${m} » hors des alias ${MODEL_ALIASES.join(', ')} : passé tel quel à claude --model (un nom que le compte ne connaît pas fait échouer la session)`);
-        }
-        for (const line of planMessageLines(l.repo, l, id, env.config.spec.dir))
-            io.out(line);
-        const noTest = noTestSaid.has(l.repo) ? null : noTestGate(l.repo);
-        noTestSaid.add(l.repo);
-        if (noTest)
-            io.out(`  ${basename(l.repo)} · ${noTestText(noTest)}`);
-        if (!redSaid.has(l.repo)) {
-            redSaid.add(l.repo);
-            // L366 : l'acceptation à vert: false d'un lot clos à la main verrouille ses tests pour tous les lots du dépôt, sans que ce lot y ait touché.
-            const closed = new Set(env.loadPlan().lots().filter((x) => x.status === 'done').map((x) => x.id));
-            for (const red of redAcceptations(l.repo, env.config.spec.dir)) {
-                if (closed.has(red.lot))
-                    io.out(`  ⚠ ${basename(l.repo)} · acceptation rouge d'un lot clos : ${red.lot} (${red.path}, vert: false) — le verrou des tests d'acceptation peut bloquer les lots de la vague ; cadence spec green ${red.lot}`);
-            }
-        }
-        io.out(`  corrections : ${MAX_PASSES} passe(s) au plus (${MAX_PASSES_CONVERGING} si la revue converge), en session neuve`);
-        io.out(l.light ? '  revue conforme avec mineurs : pas de passe des mineurs, ils sont rendus en notes' : '  revue conforme avec mineurs : une passe de correction des mineurs (session neuve), puis une revue courte ; les mineurs refusés sont rendus en « choix »');
-        const pwDir = join(resolve(RunStore.runsDir(io.cwd)), id, lotSlug(l.project, l.lot), 'playwright');
-        // brief écrit par --dry-run = base d'une délégation à la main : aucun dossier de vague (il n'existe pas)
-        const vars = { chemin: l.repo, lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '', diff: 'git diff <sha de départ>..HEAD' };
-        vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? env.loadPlan().lots().find((x) => x.id === lot.parent) : undefined));
-        if (specStage)
-            vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, light: lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir), back: !!l.specLot });
-        if (l.screen && env.config.maquette)
-            vars.maquette = maquetteText({ fiche: `${env.config.spec.dir}/<écran>/fiche.yaml`, passes: 0, max: env.config.maquetteReviews, light: lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir) });
-        if (l.specLot && env.config.fiche)
-            vars.fiche = ficheReviewText({ fiche: `${env.config.spec.dir}/<sujet>/fiche.yaml`, passes: 0 });
-        if (specStage && env.config.accept && !lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir)) {
-            const folder = `${env.config.spec.dir}/${l.screen ? '<écran>' : '<sujet>'}`;
-            vars.accept = acceptText({ fiche: `${folder}/fiche.yaml`, maquette: `${folder}/maquette.html`, screen: !!l.screen, back: false, acceptation: acceptationFile(`${folder}/fiche.yaml`, l.lot), command: env.config.accept ?? '', test: env.config.test });
-        }
-        for (const s of steps) {
-            const file = join(tmp, `${lotSlug(l.project, l.lot)}--${s.kind}.md`);
-            writeFileSync(file, renderBrief(briefName(l, s.kind), s.kind === 'fiche' || vars.fiche === undefined ? vars : { ...vars, fiche: '' }, deps.templatesDir)); // la consigne de revue de fiche ne sert qu'au brief de la fiche : implement et review en sont la base d'une délégation à la main
-            const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen).playwright;
-            const local = s.model === 'local';
-            const args = (local ? buildLocalArgs : buildArgs)({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model === 'local' ? 'sonnet' : s.model, local, effort: env.config.effort[effortKey(s.kind)], schema: schemaFor(s.kind), agent: stepAgent(s.kind), cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && (s.kind === 'implement' || s.kind === 'spec') ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright, disablePlugins: enabledPlugins(settingsFiles(deps.claudeHome, l.repo)) }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
-            io.out(`  ${s.kind} : ${local ? 'claude-local' : 'claude'} ${args.join(' ')}`);
-            io.out(`    brief : ${file}`);
-            const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen));
-            io.out(`    mcp : ${servers.length ? `${servers.join(', ')} (captures dans le dossier de la vague : <vague>/${lotSlug(l.project, l.lot)}/playwright)` : 'aucun'}`);
-        }
-    }
-}
-function maxSessions(args, io) {
-    if (args.maxSessions !== undefined)
-        return args.maxSessions;
-    const env = io.env.CADENCE_MAX_SESSIONS;
-    return env ? parseMaxSessions(env, 'CADENCE_MAX_SESSIONS') : DEFAULT_MAX_SESSIONS;
-}
-/** Plafond à AFFICHER (`--status`, `lead tour`) : le réglage de l'humain, jamais 2 en dur. Un réglage invalide ne casse pas l'affichage (le lancement, lui, le refuse) : retour au défaut. */
-export function configuredCap(env, flag) {
-    if (flag !== undefined)
-        return flag;
-    try {
-        return env.CADENCE_MAX_SESSIONS ? parseMaxSessions(env.CADENCE_MAX_SESSIONS, 'CADENCE_MAX_SESSIONS') : DEFAULT_MAX_SESSIONS;
-    }
-    catch {
-        return DEFAULT_MAX_SESSIONS;
-    }
-}
-function duration(ms) {
-    const s = Math.round(ms / 1000);
-    return s < 60 ? `${s} s` : `${Math.floor(s / 60)} min ${String(s % 60).padStart(2, '0')} s`;
-}
-/** La ligne des créneaux (L141, L255) et leur nombre libre : toujours, même sans vague ni session du lead (L416 : « libres : 3 sur 3 » se lit, il ne se déduit pas d'une absence de ligne). */
-export function slotsLine(cap = DEFAULT_MAX_SESSIONS, now = new Date()) {
-    const home = cadenceHome();
-    const holds = liveHolds(home, now);
-    const free = freeSlots(liveWaves(home), cap, holds.length);
-    const lead = holds.length ? ` · sessions du lead : ${holds.length} (${holds.map((h) => h.label).join(', ')})` : '';
-    return { line: `vagues en cours : ${liveWaves(home).length} · sessions en cours : ${liveSlots(home).length}${lead} · créneaux libres : ${free} sur ${cap}`, free };
-}
-/** Vagues vivantes (toutes, quel que soit leur dossier de départ), sessions du lead (L255), créneaux libres et dépôts qu'elles tiennent. Rien sans vague ni session du lead. */
-export function liveLines(cap = DEFAULT_MAX_SESSIONS, now = new Date()) {
-    const home = cadenceHome();
-    const waves = liveWaves(home);
-    if (waves.length === 0 && liveHolds(home, now).length === 0)
-        return [];
-    const lines = [slotsLine(cap, now).line];
-    for (const w of waves)
-        lines.push(`  ${w.wave} (pid ${w.pid}, depuis ${w.started}) lancée depuis ${w.cwd} · plafond ${w.cap ?? '?'} · dépôts : ${w.repos.join(', ')}`);
-    return lines;
-}
-/** Une ligne ⚠ par session du lead dont le TTL est échu et qui n'a pas été rendue (L278) : vide sans session échue. */
-export function expiredHoldLines(now = new Date()) {
-    return expiredHolds(cadenceHome(), now).map((h) => {
-        const since = Date.parse(h.since);
-        const age = Number.isFinite(since) ? `inscrite depuis ${longDuration(now.getTime() - since)}, ` : '';
-        return `⚠ session du lead échue : ${h.label} (${age}échue depuis ${longDuration(now.getTime() - Date.parse(h.expires))}) — la reprendre (cadence lead hold ${h.label} --ttl <minutes>) ou l'arrêter (cadence lead release ${h.label})`;
-    });
-}
-/** `--continue` (L252) : la ligne des lots prêts dont aucune ressource n'est prise par un lot en cours ni par une vague, sans les lots du premier tirage `drawn` ni les ressources qu'ils tiennent. Vide si aucun. */
-function freeLines(launch, drawn) {
-    const dirs = isLeadProject(launch) ? [launch] : findProjects(launch);
-    const free = readyFree(dirs, cadenceHome(), drawn);
-    const line = freeLine(dirs.filter((d) => free.has(d)).map((d) => ({ project: basename(d), free: free.get(d) })), 60);
-    return line ? [line] : [];
-}
-/** Efface l'écran et replace le curseur en haut : l'entrée d'un rendu de `--status --watch`. */
-const CLEAR_SCREEN = '\x1b[H\x1b[2J';
-const DEFAULT_WATCH_INTERVAL = 10;
-/** Attente (ms) entre deux lectures de la file de réponses d'une vague vivante (L407) quand aucune file de lots ne finit. */
-const ANSWER_POLL_MS = 2000;
-/** Ce que `--status` montre à un instant : les vagues vivantes, puis le tableau (absent si seules les vagues vivantes comptent). */
-function statusView(args, launch, cap, now) {
-    const id = statusWave(args);
-    const store = id !== undefined ? RunStore.find(launch, id) : RunStore.last(launch);
-    const live = [...liveLines(cap, now), ...expiredHoldLines(now), ...localOverdueLines((isLeadProject(launch) ? [launch] : findProjects(launch)).map((d) => gitRoot(d) ?? d), now)];
-    const waveLive = liveWaves(cadenceHome()).length > 0;
-    if (!store && live.length && id === undefined)
-        return { live, running: waveLive };
-    if (!store)
-        throw new RafError(id !== undefined ? `vague inconnue : ${id}` : 'aucune vague dans ce dossier');
-    // `running` : la vague suivie tourne — pour un <id> explicite, elle seule compte, pas les autres vagues de la machine
-    const running = id !== undefined ? liveWaves(cadenceHome()).some((w) => w.wave === store.readWave().id) : waveLive;
-    const lots = store.lots();
-    if (args.detail !== undefined) {
-        try {
-            return { live: [], table: renderDetail(lots, args.detail), running };
-        }
-        catch (e) {
-            throw new RafError(e.message);
-        }
-    }
-    return { live, table: [...renderTable(store.readWave(), lots, { compact: true, prices: launchPrices(launch, (w) => live.push(`⚠ ${w}`)) }), ...keptLines(lots.map((l) => l.repo), now.getTime())], running };
-}
-/** La vague que `--status` suit (L395) : `--status <id>` ou `--status --wave <id>` ; aucune : la dernière du dossier. Deux ids différents : refus. */
-function statusWave(args) {
-    if (typeof args.status === 'string' && args.wave !== undefined && args.status !== args.wave)
-        throw new RafError(`--status ${args.status} et --wave ${args.wave} désignent deux vagues : une seule`);
-    return typeof args.status === 'string' ? args.status : args.status === true ? args.wave : undefined;
-}
-/** Refus d'une `--wave` déjà existante, identique en simulation et au vrai lancement. */
-function waveExists(wave, io) {
-    io.err(`orchestrate : --wave ${wave} : cette vague existe déjà`);
-    return 2;
-}
-/** L382 : `claude auth status` peut durer jusqu'à 20 s ; en --continue, preflight() le relancerait pour chaque lot candidat de chaque tour. Une seule lecture par lancement (une vague). */
-function onceAuth(deps) {
-    const read = deps.claudeAuth;
-    if (!read)
-        return deps;
-    let cached;
-    return { ...deps, claudeAuth: () => (cached ??= { value: read() }).value };
-}
-/** `--status` (L395) : le tableau des vagues vivantes et de la vague suivie, une fois ou rafraîchi avec `--watch` jusqu'à ce que plus rien ne tourne. */
-async function statusCommand(args, io, deps, launch) {
-    maxSessions(args, io); // une valeur invalide est refusée ici aussi
-    const view = () => statusView(args, launch, configuredCap(io.env, args.maxSessions), io.now());
-    if (!args.watch) {
-        const { live, table } = view();
-        printStatus(io, live, table); // sans identifiant (pas de tableau) : les vagues vivantes suffisent
-        return 0;
-    }
-    // --watch : le même tableau, rafraîchi ; il s'arrête seul quand plus aucune vague ne tourne (le dernier rendu reste affiché)
-    const sleep = deps.watchSleep ?? ((ms) => new Promise((res) => setTimeout(res, ms)));
-    const seconds = args.interval ?? DEFAULT_WATCH_INTERVAL;
-    for (;;) {
-        const { live, table, running } = view();
-        io.out(CLEAR_SCREEN);
-        printStatus(io, live, table);
-        if (!running)
-            return 0;
-        io.out('');
-        io.out(`rafraîchi toutes les ${seconds} s — Ctrl-C pour quitter`);
-        await sleep(seconds * 1000);
-    }
-}
-/** Les vagues vivantes, puis (s'il y en a un) le tableau de la vague suivie, séparés d'une ligne vide. */
-function printStatus(io, live, table) {
-    for (const line of live)
-        io.out(line);
-    if (!table)
-        return;
-    if (live.length)
-        io.out('');
-    for (const line of table)
-        io.out(line);
-}
 /** Point d'entrée de `cadence orchestrate`. 0 prêts · 1 rendus au lead · 2 refus avant d'agir · 3 suspendue (budget, quota). */
 export async function orchestrate(argv, io, deps) {
     deps = onceAuth(deps);
@@ -842,972 +211,6 @@ export async function orchestrate(argv, io, deps) {
         throw e;
     }
 }
-const priorityOf = (args, launch) => args.priority ?? readPriority(launch);
-/**
- * Tire jusqu'à `n` lots prêts du plan (L147), dans l'ordre de priorité, et les passe au contrôle préalable comme un lot donné :
- * un lot refusé est sauté, sa cause rendue dans `skipped`. `exclude` reçoit chaque lot tiré ou refusé pour lui-même, pas ceux d'un
- * dépôt refusé ni un lot qui ne tient pas dans le reste du budget (il tiendra peut-être au tour suivant).
- * Un tour tire au plus UN lot par dépôt (le pool joue à la suite les lots d'un même dépôt, `--max-sessions` ne servirait à rien) ;
- * les lots écartés pour cela complètent le tour, dans l'ordre, quand aucun autre dépôt n'a de lot prêt.
- */
-async function draw(args, io, deps, launch, exclude, remaining, n) {
-    const lots = [];
-    const skipped = [];
-    const badRepos = new Set();
-    const used = new Set();
-    const deferred = [];
-    /** `spread` : premier passage, un dépôt déjà pris ce tour renvoie le lot au second ; sinon (second passage) le lot complète le tour. */
-    const attempt = async (c, repo, spread, checked) => {
-        const key = lotKey(c.project, c.lot.id);
-        if (badRepos.has(repo))
-            return;
-        if (spread && used.has(repo))
-            return void deferred.push({ c, repo });
-        const pre = checked ?? (await preflight(args, [{ project: c.project, projectDir: c.dir, repo, lot: c.lot.id, model: 'sonnet' }], io, deps, launch));
-        if (pre.refusals.length) {
-            // Un refus propre au lot l'écarte pour la vague ; celui d'un dépôt (arbre sale, orchestration en cours, pre-push) est passager :
-            // le dépôt est sauté pour ce tirage seulement, une ligne, et ses lots restent tirables au suivant.
-            const own = pre.refusals.filter((r) => r.startsWith(`${key} : `));
-            if (own.length)
-                exclude.add(key);
-            if (own.length < pre.refusals.length)
-                badRepos.add(repo);
-            skipped.push(...pre.refusals.filter((r) => !skipped.includes(r)));
-            return;
-        }
-        const lot = pre.lots[0];
-        if (lot.budget > remaining)
-            return; // pas exclu : le budget du tour suivant le permettra peut-être
-        if (spread && lotRepoPaths(lot).some((r) => used.has(r)))
-            return void deferred.push({ c, repo, pre }); // un dépôt voisin déjà pris ce tour
-        exclude.add(key);
-        remaining -= lot.budget;
-        lots.push(lot);
-        for (const r of lotRepoPaths(lot))
-            used.add(r);
-    };
-    for (const c of candidates(launch, { priority: priorityOf(args, launch), exclude, remaining })) {
-        if (lots.length >= n)
-            break;
-        const repo = gitRoot(c.dir);
-        if (repo)
-            await attempt(c, repo, true);
-    }
-    for (const d of deferred) {
-        if (lots.length >= n)
-            break;
-        await attempt(d.c, d.repo, false, d.pre);
-    }
-    return { lots, skipped };
-}
-/** Nombre de tours que la simulation de `--dry-run --continue` déroule au plus. */
-/** Le plus de lots que `--dry-run --continue` liste après le premier tirage. */
-const DRY_RUN_LOTS = 10;
-/**
- * `--dry-run --continue` : ce que le remplissage des créneaux libres tirerait ensuite (L527), avec la même fonction `draw` que la vague, un lot à la fois
- * (`n = 1` : le premier lot prêt dans l'ordre de priorité, contrôle préalable, budget), comme la vague remplit chaque créneau libre ; les lots sautés disent pourquoi.
- * Le budget est décompté sur l'estimation des lots tirés (la consommation réelle n'est pas connue) et la simulation ne sait pas quel dépôt sera occupé à chaque
- * regard : elle liste les lots dans l'ordre où le remplissage les prendrait si chaque dépôt était libre. `firstSkipped` : causes écartées au premier tirage, quand il a fourni les lots donnés.
- */
-async function continueDryRun(args, io, deps, launch, given, budget, firstSkipped) {
-    io.out(`--continue : priorité ${priorityOf(args, launch).join(' > ') || '(aucune déclarée : ordre alphabétique)'}${args.until ? ` · jusqu'à ${args.until}` : ''}`);
-    const said = new Set();
-    const skip = (causes) => {
-        for (const s of causes) {
-            if (said.has(s))
-                continue;
-            said.add(s);
-            io.out(`  lot sauté — ${s}`);
-        }
-    };
-    skip(firstSkipped);
-    const exclude = new Set(given.map((l) => lotKey(l.project, l.lot)));
-    for (const line of drawSettingsReport(launch, exclude))
-        io.out(`  ${line}`);
-    let remaining = budget - given.reduce((sum, l) => sum + (l.budget ?? 0), 0);
-    const next = [];
-    while (next.length < DRY_RUN_LOTS && remaining > 0) {
-        const drawn = await draw(args, io, deps, launch, exclude, remaining, 1);
-        skip(drawn.skipped);
-        const lot = drawn.lots[0];
-        if (!lot)
-            break;
-        next.push(lotKey(lot.project, lot.lot));
-        remaining -= lot.budget ?? 0;
-    }
-    io.out(next.length ? `  tirés ensuite, un par un au fil des créneaux libres, dans l'ordre de priorité (budget décompté sur les estimations) : ${next.join(', ')}${next.length === DRY_RUN_LOTS ? ' · …' : ''}` : '  aucun autre lot prêt à tirer');
-}
-/**
- * `--continue` (L147) : tant qu'aucune borne ne joue, tire jusqu'à `cap` lots prêts du plan et les joue dans la même vague
- * (même budget, même dossier d'état). Sans `--continue`, rend le code tel quel. Bornes : budget, `--until`, limite d'usage,
- * question posée, deux lots rendus de suite, vague interrompue, plus de lot prêt dont l'estimation tient dans le budget restant.
- */
-async function continueRounds(first, wave, all, store, io, deps, today, args, launch) {
-    if (!args.continue || first === 2)
-        return first; // 2 : refus au verrou, rien n'a tourné
-    const say = (line) => {
-        io.out(line);
-        store.journal(line);
-    };
-    const exclude = new Set(all.map((l) => lotKey(l.project, l.lot)));
-    const cap = maxSessions(args, io);
-    let code = first;
-    for (;;) {
-        for (const l of all)
-            exclude.add(lotKey(l.project, l.lot)); // L421 : les lots ajoutés à la main pendant la vague ne sont pas tirés une seconde fois
-        const questions = all.filter((l) => l.status === 'question').length;
-        const remaining = wave.status === 'suspended-budget' ? 0 : wave.budget - wave.consumed;
-        const why = stopReason({ now: io.now(), until: args.untilAt, quotaHit: wave.status === 'suspended-quota', questions, streak: handedBackStreak(all), interrupted: wave.status === 'interrupted' && questions === 0, stopRequested: store.control().stopAfterCurrent, remaining });
-        if (why) {
-            say(`continue : arrêt — ${why}`);
-            return code;
-        }
-        const drawn = await draw(args, io, deps, launch, exclude, remaining, cap);
-        for (const s of drawn.skipped)
-            say(`continue : lot sauté — ${s}`);
-        if (drawn.lots.length === 0) {
-            say("continue : arrêt — plus aucun lot prêt dont l'estimation tient dans le budget restant");
-            return code;
-        }
-        for (const l of drawn.lots) {
-            if (l.node)
-                l.node.link = (deps.linkNode ?? linkNodeBin)(store.dir, l.node.version, l.node.bin);
-            store.writeLot(l);
-            wave.lots.push(lotKey(l.project, l.lot));
-        }
-        store.writeWave(wave);
-        all.push(...drawn.lots);
-        say(`continue : tire ${drawn.lots.map((l) => lotKey(l.project, l.lot)).join(', ')}`);
-        code = await execute(wave, drawn.lots, store, io, deps, today, args, all);
-        if (code === 2)
-            return code;
-    }
-}
-function contexts(lots, envs, wctx) {
-    return lots.map((lot, i) => ({ wave: wctx, lot, config: envs[i].config, loadPlan: envs[i].loadPlan }));
-}
-/**
- * Quels lots jouent dans un worktree (L279). Un groupe de lots du même dépôt (`groupLots`) y joue si `orchestrate.worktrees` est vrai, s'il a au moins deux lots
- * ou si la vague a plus d'un créneau (`multiSlot`, L527 : tout lot d'un tel dépôt reçoit son worktree — donné seul, tiré par le remplissage ou apporté par `--add`, avec ou sans `--continue` — pour qu'un créneau libre reçoive le lot suivant du même dépôt), si le dépôt est sur une branche et si aucun de ses lots n'a de dépôt voisin (`repos:`, R2) ; sinon les lots restent à la suite, avec un avertissement qui dit pourquoi.
- * Un lot dont la branche existe déjà (reprise, R11) retrouve son worktree quel que soit le groupe ; un lot rendu à l'intégration dont la branche a disparu n'en reçoit pas. La branche de départ est celle du dépôt du lead à cet instant,
- * ou celle que la branche du lot a notée à sa création.
- */
-function planTrees(ctxs, store, wave, log, multiSlot) {
-    for (const group of groupLots(ctxs)) {
-        const repo = group[0].lot.repo;
-        const branch = repoBranch(repo);
-        const requested = (group.length > 1 || multiSlot) && group.every((c) => c.config.worktrees);
-        const why = !requested ? null : group.some((c) => c.lot.repos?.length) ? 'des lots du groupe ont des dépôts voisins (repos:)' : !branch ? 'le dépôt est en HEAD détaché' : null;
-        if (why)
-            log(`orchestrate : ${basename(repo)} : worktrees demandés mais ${why} : lots joués à la suite`);
-        for (const c of group) {
-            if (c.tree)
-                continue; // L421 : un lot ajouté en cours de vague replanifie son groupe ; les arbres déjà posés (et leur état actif) ne sont pas refaits
-            const lotBr = lotBranch(wave, c.lot.project, c.lot.lot);
-            // Chemin de reprise d'un lot rendu hors intégration : sa branche d'une vague passée devient celle de cette vague (recoverTree), puis se retrouve comme une reprise (R11).
-            const dir = lotTreeDir(store.dir, c.lot.project, c.lot.lot, repo);
-            const recovered = !baseBranchOf(repo, lotBr) && c.lot.next !== 'integrate' && branch && c.config.worktrees ? recoverTree(repo, lotBr, dir, branch, planFileSet(c.loadPlan(), repo)) : null;
-            if (recovered && 'refused' in recovered)
-                log(`orchestrate : ${lotKey(c.lot.project, c.lot.lot)} : branche ${recovered.from} d'une vague précédente non reprise : ${recovered.refused} ; le lot repart de zéro (à nettoyer à la main, ou intégration à la main documentée)`);
-            else if (recovered) {
-                log(`orchestrate : ${lotKey(c.lot.project, c.lot.lot)} : branche ${recovered.from} d'une vague précédente reprise (${recovered.unintegrated} commit(s) non intégré(s)) : le lot repart de son travail`);
-                // L311 : le lot repris ne repasse pas par le contrôle préalable. Il reprend les constats de sa dernière revue (état de la vague qui l'a rendu) et repart à leur correction, ou à la revue quand il en a déjà passé une sans constat ; rendu avant sa première revue (ou état illisible ; les constats `tests` d'un lot rendu pour tests rouges ne font pas une revue, L318), il repart à l'écriture.
-                const old = new RunStore(store.launchDir, recovered.from.split('/')[1]).readLot(c.lot.project, c.lot.lot);
-                c.lot.resumedFrom = recovered.from.split('/')[1];
-                c.lot.constats = old?.constats ?? [];
-                c.lot.resumedReviewed = !!old && (old.constats.some((k) => k.source === 'code') || old.steps.some((s) => s.kind.startsWith('review')));
-            }
-            const known = baseBranchOf(repo, lotBr);
-            const base = known ?? branch;
-            // Un lot repris à l'intégration dont la branche n'existe plus (retirée par --remove-worktree --abandon-commits) n'a plus de commits à intégrer : pas de worktree recréé au sommet, `integrateLot` le rend.
-            if (c.lot.next === 'integrate' && !known)
-                continue;
-            if (((requested && !why) || known) && base)
-                c.tree = { dir, branch: lotBr, base, active: false };
-        }
-    }
-}
-/** Pose les verrous et les hooks, joue la vague, range l'état, rend le tableau et le code de sortie. */
-async function execute(wave, lots, store, io, deps, today, args, all = lots) {
-    const cap = maxSessions(args, io);
-    const launch = store.launchDir;
-    // La configuration des projets est lue avant de poser quoi que ce soit : un cadence.yaml illisible ne laisse ni verrou ni hook.
-    const envs = lots.map((lot) => projectEnv(lot.repo));
-    // Les gabarits aussi : lus une fois, rendus depuis cet instantané jusqu'à la fin de la vague (ou jusqu'à sa reprise).
-    const templates = loadTemplates(deps.templatesDir);
-    mkdirSync(join(launch, '.cadence'), { recursive: true });
-    excludeState(launch);
-    const home = cadenceHome();
-    const held = [];
-    const repos = [...new Set(lots.flatMap(lotRepoPaths))];
-    /** Libère un dépôt : son verrou et sa garde de push (L132 : dès que ses lots sont finis, pas à la fin de la vague). */
-    const freed = new Set();
-    /** Lots dont la vague a fini de jouer (prêts, rendus, en échec ou suspendus) : ils ne tiennent plus de créneau. */
-    const settled = new Set();
-    /** Lots que la vague a encore à jouer, en cours ou en attente, sur les dépôts qu'elle tient encore (un par dépôt, un par lot en worktree) : ce que le registre compte pour les créneaux libres (L433 : un lot fini ne garde plus de créneau, 0 quand plus rien n'est à jouer). Absent (undefined) tant qu'aucun lot ne joue dans un worktree : le calcul reste celui des dépôts tenus. */
-    const lanes = () => ctxs.some((c) => c.tree) ? groupLots(ctxs).filter((g) => g.every((c) => lotRepoPaths(c.lot).every((r) => !freed.has(r)))).reduce((n, g) => { const todo = g.filter((c) => !settled.has(c)).length; return n + (g.every((c) => c.tree) ? todo : Math.min(1, todo)); }, 0) : undefined; // hors mode worktree, rien n'est écrit : le registre compte les dépôts tenus, comme avant L279
-    const freeRepo = (r) => {
-        freed.add(r);
-        const file = join(sharedStateDir(r), REPO_LOCK);
-        releaseLock(file, process.pid);
-        held.splice(0, held.length, ...held.filter((f) => f !== file));
-        removePrePush(r, wave.id);
-        keepGateGuard(r);
-        try {
-            updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)), lanes());
-        }
-        catch {
-            // registre illisible : `--status` garde la liste de départ, le verrou est bien tombé
-        }
-    };
-    const release = () => {
-        for (const f of held)
-            releaseLock(f, process.pid);
-        held.length = 0;
-        for (const r of repos) {
-            if (freed.has(r))
-                continue;
-            removePrePush(r, wave.id);
-            keepGateGuard(r);
-        }
-        try {
-            unregisterWave(home, process.pid);
-        }
-        catch {
-            // registre illisible : l'entrée d'un processus mort est écartée à la prochaine inscription
-        }
-    };
-    for (const r of repos) {
-        const file = join(sharedStateDir(r), REPO_LOCK);
-        const l = takeLock(file, { pid: process.pid, wave: wave.id, started: new Date().toISOString() });
-        // Le verrou déjà à ce pid : pris par la reprise qui a attendu l'autre vague (L443).
-        if (!l.ok && l.held.pid !== process.pid) {
-            io.err(`orchestrate : ${heldRefusal(r, l.held)}`);
-            release();
-            return 2;
-        }
-        held.push(file);
-        if (l.ok && l.stale)
-            io.err(`orchestrate : verrou de dépôt périmé retiré (${basename(r)}, pid ${l.stale.pid} mort)`);
-        const hook = installPrePush(r, wave.id);
-        if (!hook.ok) {
-            io.err(`orchestrate : ${basename(r)} : ${hook.reason}`);
-            release();
-            return 2;
-        }
-    }
-    try {
-        registerWave(home, { pid: process.pid, wave: wave.id, started: new Date().toISOString(), cwd: launch, repos, cap });
-    }
-    catch (e) {
-        release(); // verrous et hooks ne restent pas posés si le démarrage échoue
-        throw e;
-    }
-    // Plafond de sessions simultanées, toutes vagues confondues : chaque session attend un créneau libre avant de partir.
-    const claude = async (argv, o) => {
-        const free = await acquireSlot(home, cap, { wave: wave.id, ...slotPlace(all, launch, args.priority, o.lot), // L531 : place dans la file des créneaux, commune aux vagues
-            pollMs: deps.slotPollMs,
-            // L332 : une demande écrite pendant l'attente (`--drop` de ce lot, `--stop-after-current`) l'interrompt ; la session ne part pas.
-            abandon: () => {
-                const ctl = store.control();
-                if (o.lot && ctl.drops.includes(o.lot))
-                    return DROPPED;
-                return ctl.stopAfterCurrent ? STOP_REQUESTED : null;
-            },
-            onWait: (h, ms, limit, lead) => {
-                const who = [...new Set(h.map((x) => x.wave)), ...lead.map((x) => `session du lead ${x.label}`)];
-                wctx.log(`${o.lot ? `${o.lot} · ` : ''}en attente d'un créneau de session depuis ${duration(ms)} (${h.length + lead.length}/${limit} en cours : ${who.join(', ')})`);
-            },
-            onGot: (ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}créneau de session obtenu après ${duration(ms)} d'attente`),
-        });
-        try {
-            return await deps.claude(argv, o);
-        }
-        finally {
-            free();
-        }
-    };
-    const budget = new Budget(wave.budget);
-    budget.consumed = wave.consumed;
-    budget.cacheRead = wave.cacheRead;
-    const saveWave = () => {
-        wave.consumed = budget.consumed;
-        wave.cacheRead = budget.cacheRead;
-        wave.budget = budget.limit;
-        store.writeWave(wave);
-    };
-    // Part de la machine de chaque session (L350) : recalculée à chaque (re)prise, le plafond peut avoir changé.
-    wave.testWorkers = testWorkersFrom(io.env, (deps.cores ?? availableParallelism)(), cap);
-    const wctx = {
-        id: wave.id,
-        store,
-        budget,
-        claude,
-        agents: agentsOf(deps),
-        today,
-        claudeHome: deps.claudeHome,
-        templates,
-        testWorkers: wave.testWorkers,
-        quota: { hit: false },
-        incident: null,
-        log: (line) => {
-            io.out(line);
-            store.journal(line);
-        },
-        saveWave,
-        integrate: deps.integrate,
-    };
-    wave.status = 'running';
-    wave.pid = process.pid;
-    saveWave();
-    const ctxs = contexts(lots, envs, wctx);
-    planTrees(ctxs, store, wave.id, wctx.log, cap > 1);
-    try {
-        updateWaveRepos(home, process.pid, repos, lanes());
-    }
-    catch {
-        // registre illisible : le décompte des créneaux libres reste celui des dépôts
-    }
-    const adds = new AddFeed({
-        store, wave, wctx, io, deps, launch, ctxs, all, lots, held, freed, repos, freeRepo, saveWave, checks: LAUNCH_CHECKS,
-        stopCause: () => (wctx.incident ? 'incident' : wctx.quota.hit ? "limite d'usage atteinte" : budget.exhausted ? 'budget de la vague épuisé' : store.control().stopAfterCurrent ? "la vague s'arrête" : null),
-        budgetLeft: () => budget.limit - budget.consumed,
-        planState: (c) => {
-            try {
-                const lot = projectEnv(c.lot.repo).loadPlan().lots().find((l) => l.id === c.lot.lot);
-                return !lot ? 'lot inconnu' : !isOpen(lot.status) ? `le lot est ${lot.status}` : null;
-            }
-            catch (e) {
-                return e.message;
-            }
-        },
-        announce: () => updateWaveReposSafe(home, repos.filter((x) => !freed.has(x)), lanes()),
-        build: (t, known) => buildAdd(t, known, { wave: wave.id, ctxs, wctx, store, io, deps, launch, multiSlot: cap > 1 }),
-    });
-    // Ctrl-C, SIGTERM : les sessions sont tuées en bloc, les étapes marquées interrompues, les verrous et hooks libérés.
-    const forget = onTermination(async () => {
-        killSessions();
-        await stopApps(); // les applications de la revue UX : SIGTERM, SIGKILL après 10 s
-        for (const c of ctxs) {
-            for (const s of c.lot.steps) {
-                if (s.status === 'running')
-                    s.status = 'interrupted';
-                // Les tokens d'une session tuée comptent : relus dans son journal.
-                if (s.status === 'interrupted')
-                    countInterrupted(deps.claudeHome, workDir(c), s, budget);
-            }
-            if (c.lot.status === 'implementing' || c.lot.status === 'reviewing' || c.lot.status === 'fixing')
-                c.lot.status = 'suspended';
-            store.writeLot(c.lot);
-            // Le TMPDIR court de la session tuée (L243) est hors de la vague : sans cela il resterait dans /tmp.
-            try {
-                store.removeTmpDir(c.lot.project, c.lot.lot);
-            }
-            catch {
-                // nettoyage de confort
-            }
-        }
-        wave.status = 'interrupted';
-        saveWave();
-        release();
-    });
-    const finished = lotFinished;
-    /** L527 : les lots prêts du plan que le créneau libre peut recevoir (rien sans `--continue`) ; `adds.fill` les contrôle et les prend. */
-    const refill = async (canRun, free) => args.continue && free > 0 ? adds.fill(fillTargets({ args, io, launch, home, store, all, budget, quotaHit: wctx.quota.hit, incident: !!wctx.incident }), free, canRun) : [];
-    try {
-        await runPool(ctxs, cap, all, (c) => {
-            // Un lot rendu ou en échec garde son worktree et sa branche (R12) : le journal en donne le chemin.
-            if (c.tree?.active && c.lot.status !== 'ready')
-                wctx.log(`orchestrate : ${lotKey(c.lot.project, c.lot.lot)} : worktree conservé : ${c.tree.dir} (branche ${c.tree.branch})`);
-            // Un lot rendu à l'étape d'intégration (`next: integrate`) : la ligne donne la commande qui le reprend (L279, R27).
-            if (c.tree?.active && c.lot.status === 'handed-back' && c.lot.next === 'integrate')
-                wctx.log(`orchestrate : ${lotKey(c.lot.project, c.lot.lot)} : rendu à l'intégration : reprise par ${resumeCommand(wctx.id, '--integrate', lotKey(c.lot.project, c.lot.lot))}`);
-            // Un dépôt dont tous les lots de la vague (reprise comprise) sont prêts ou rendus peut être livré pendant que la vague continue ailleurs.
-            settled.add(c);
-            try {
-                updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)), lanes());
-            }
-            catch {
-                // registre illisible : le décompte reste celui du dernier écrit
-            }
-            if (wctx.incident)
-                return;
-            for (const r of lotRepoPaths(c.lot)) {
-                if (held.includes(join(sharedStateDir(r), REPO_LOCK)) && all.filter((l) => lotRepoPaths(l).includes(r)).every(finished))
-                    freeRepo(r);
-            }
-        }, (lots) => lots.every((c) => c.tree), {
-            pollMs: deps.slotPollMs ?? ANSWER_POLL_MS,
-            // L407 : les réponses déposées par `--answer` pendant la vague sont prises entre deux étapes ; un lot qui n'est plus en question ne rejoue rien.
-            take: async (canRun, free) => {
-                const taken = [];
-                for (const e of store.answerQueue()) {
-                    const c = ctxs.find((x) => lotKey(x.lot.project, x.lot.lot) === e.lot);
-                    const why = !c ? 'lot inconnu' : c.lot.status !== 'question' ? `le lot n'attend plus de réponse (${c.lot.status})` : c.lot.pendingAnswer ? 'une réponse est déjà en cours de jeu' : null;
-                    if (why) {
-                        wctx.log(`${e.lot} : réponse écartée (${why})`);
-                        store.markAnswerTaken(e.id);
-                    }
-                    else if (c && canRun(c)) {
-                        c.lot.pendingAnswer = e.text;
-                        c.lot.answers.push(e.text);
-                        c.lot.questions = [];
-                        store.writeLot(c.lot);
-                        store.markAnswerTaken(e.id);
-                        wctx.log(`${e.lot} : réponse du lead prise, le lot repart`);
-                        // Le lot avait fini de jouer à sa question (`settled`) : il rejoue, il tient de nouveau un créneau — sans cela `lanes()` le sous-compte et le registre annonce un créneau libre de trop (L433).
-                        settled.delete(c);
-                        taken.push(c);
-                    }
-                }
-                // L532 : les intégrations déposées par `--resume --integrate` pendant la vague sont reprises de la même façon, au tour où le lot peut jouer.
-                taken.push(...(await takeIntegrations({ store, ctxs, wctx, settled }, canRun)));
-                if (taken.length) {
-                    try {
-                        updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)), lanes());
-                    }
-                    catch {
-                        // registre illisible : le décompte reste celui du dernier écrit
-                    }
-                }
-                const added = await adds.take(canRun);
-                return [...taken, ...added, ...(await refill(canRun, free - taken.length - added.length))];
-            },
-        });
-        // L421 : un ajout encore en file quand plus rien ne joue ne sera plus lu : écarté et dit.
-        adds.drain('la vague a fini de jouer');
-        handBackDroppedQuestions(ctxs); // un lot en question retiré pendant la vague : rendu avant de fixer le statut de la vague
-    }
-    finally {
-        forget();
-        // « done » = plus rien à reprendre : une question en attente ou un lot suspendu garde la vague reprenable. Des lots suspendus parce qu'une revue a sali leur dépôt (L133), budget intact, ne sont pas un manque de budget : « interrupted », le lead nettoie puis reprend.
-        wave.status = wctx.incident ? 'interrupted' : wctx.quota.hit ? 'suspended-quota' : lots.some((l) => l.status === 'suspended') && (budget.exhausted || !wctx.dirtyRepos?.size) && (budget.exhausted || !store.control().stopAfterCurrent) ? 'suspended-budget' : all.every(finished) ? 'done' : 'interrupted';
-        saveWave();
-        release();
-    }
-    if (wctx.incident)
-        io.err(`orchestrate : incident — ${wctx.incident}`);
-    if (wctx.quota.hit)
-        io.err(`orchestrate : quota atteint — ${quotaText(wctx.quota.message ?? '')}`.trim());
-    for (const line of renderTable(wave, all, { prices: launchPrices(launch, (w) => io.err(`orchestrate : ${w}`)) }))
-        io.out(line);
-    for (const line of keptLines(all.map((l) => l.repo)))
-        io.out(line); // les worktrees conservés, avec leur chemin (R19)
-    if (wave.status === 'suspended-budget' || wave.status === 'suspended-quota')
-        return 3;
-    return all.every((l) => l.status === 'ready') ? 0 : 1;
-}
-/**
- * `--answer` sur une vague VIVANTE (L407) : la réponse est déposée dans la file de la vague (`answers.log`), qui la prend entre deux étapes et rejoue le lot dès qu'un créneau est libre.
- * Sans cela le lead attendait la fin de la vague (15 min d'un lot bloqué le 28-10). Les lots visés sont contrôlés comme à la reprise : connus, en question.
- */
-function answerLive(args, io, store) {
-    const lots = store.lots();
-    const refusals = [];
-    const keys = [];
-    for (const a of args.answers) {
-        const matches = lots.filter((l) => l.lot === a.lot && (a.project ? l.project === a.project : true));
-        const where = `${a.project ? `${a.project}:` : ''}${a.lot}`;
-        if (matches.length !== 1)
-            refusals.push(matches.length ? `--answer ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--answer ${where} : lot inconnu dans la vague ${store.id}`);
-        else if (matches[0].status !== 'question')
-            refusals.push(`--answer ${lotKey(matches[0].project, matches[0].lot)} : le lot n'attend pas de réponse (${matches[0].status})`);
-        else
-            keys.push({ key: lotKey(matches[0].project, matches[0].lot), text: a.text });
-    }
-    if (!waveReadsAnswerQueue(store.dir))
-        refusals.push(`la vague ${store.id} ne lit pas la file de réponses (lancée avec une version de cadence d'avant L407) : attendre sa fin, puis ${resumeCommand(store.id, '--answer', '<projet>:<lot>', '"…"')}`);
-    if (refusals.length) {
-        for (const r of refusals)
-            io.err(`orchestrate : ${r}`);
-        return 2;
-    }
-    for (const { key, text } of keys) {
-        const id = store.requestAnswer(key, text);
-        // La vague a pu finir entre le contrôle et le dépôt : sa file ne sera plus lue, la réponse est retirée et le lead reprend à la main.
-        if (!liveWaves(cadenceHome()).some((w) => w.wave === store.id)) {
-            store.markAnswerTaken(id);
-            io.err(`orchestrate : ${key} : la vague ${store.id} vient de finir, réponse non prise : ${resumeCommand(store.id, '--answer', key, '"…"')}`);
-            return 2;
-        }
-        store.journal(`demande : réponse du lead pour ${key}`);
-        io.out(`${key} : réponse déposée — la vague ${store.id} la prend entre deux étapes et rejoue le lot dès qu'un créneau est libre`);
-    }
-    return 0;
-}
-const LAUNCH_CHECKS = { resolveTargets, preflight: (targets, run, addTo) => preflight({ dryRun: false }, targets, run.io, run.deps, run.launch, { addTo }) };
-/** `--add` (L421) : la vague vivante de ce dossier reçoit les lots (le travail est dans `ajout.ts`). */
-async function addOnlyLive(args, io, deps, launch) {
-    const store = liveStore('--add', args, io);
-    return typeof store === 'number' ? store : addToLive(args, { io, deps, launch }, store, LAUNCH_CHECKS);
-}
-/**
- * Le contexte d'un lot ajouté en cours de vague (L421) ou tiré par le remplissage d'un créneau libre (L527) : le contrôle préalable d'un lot de lancement (les lots de la vague comptent pour les dépendances), le lien du Node,
- * puis un worktree si son dépôt est en `worktrees: true` et la vague a plus d'un créneau (`multiSlot`), ou si tous les lots encore à jouer de son dépôt y sont ; sinon il attend la fin de ceux qui jouent dans l'arbre du dépôt.
- */
-async function buildAdd(t, known, w) {
-    const pre = await LAUNCH_CHECKS.preflight([t], w, { wave: w.wave, lots: known });
-    const lot = pre.lots[0];
-    if (pre.refusals.length || !lot)
-        return { refusals: pre.refusals };
-    if (lot.node)
-        lot.node.link = (w.deps.linkNode ?? linkNodeBin)(w.store.dir, lot.node.version, lot.node.bin);
-    const ctx = contexts([lot], [projectEnv(lot.repo)], w.wctx)[0];
-    const open = openInRepo(w.ctxs, ctx);
-    planTrees(open.every((o) => o.tree) ? [...open, ctx] : [ctx], w.store, w.wave, w.wctx.log, w.multiSlot);
-    return { ctx };
-}
-/** Le registre des vagues vivantes : dépôts tenus et créneaux occupés ; illisible, le décompte reste celui du dernier écrit. */
-function updateWaveReposSafe(home, repos, lanes) {
-    try {
-        updateWaveRepos(home, process.pid, repos, lanes);
-    }
-    catch {
-        // registre illisible : le décompte reste celui du dernier écrit
-    }
-}
-/** La vague vivante, pour `--answer` seul (sans --resume) : la même recherche que `--drop`. */
-function answerOnly(args, io) {
-    if (args.drop.length || args.stopAfterCurrent || args.budget !== undefined || args.dryRun || args.continue || args.lots.length)
-        throw new RafError("--answer ne se combine pas avec --drop, --stop-after-current, --budget, --dry-run, --continue ni des lots à lancer (sur une vague arrêtée : --resume --answer)");
-    const store = liveStore('--answer', args, io);
-    if (typeof store === 'number') {
-        io.err(`orchestrate : --answer : une vague arrêtée se reprend avec ${resumeCommand('<vague>', '--answer', '<projet>:<lot>', '"…"')}`);
-        return store;
-    }
-    return answerLive(args, io, store);
-}
-/** La vague vivante lancée depuis ce dossier que vise `--wave` (ou la seule) ; sinon le refus (code 2) déjà écrit. */
-function liveStore(flags, args, io) {
-    const live = liveWaves(cadenceHome()).filter((w) => w.cwd === io.cwd && (args.wave === undefined || w.wave === args.wave));
-    if (live.length === 0) {
-        io.err(`orchestrate : ${flags} : aucune vague en cours${args.wave ? ` (${args.wave})` : ''} lancée depuis ce dossier`);
-        return 2;
-    }
-    if (live.length > 1) {
-        io.err(`orchestrate : ${flags} : plusieurs vagues tournent depuis ce dossier (${live.map((w) => w.wave).join(', ')}) : précisez --wave`);
-        return 2;
-    }
-    const store = RunStore.find(io.cwd, live[0].wave);
-    if (!store) {
-        io.err(`orchestrate : ${flags} : dossier d'état de la vague ${live[0].wave} introuvable`);
-        return 2;
-    }
-    return store;
-}
-/** `--drop` / `--stop-after-current` (L79) : une demande écrite dans le dossier d'état de la vague vivante ; c'est elle qui la lit avant sa prochaine session. */
-function control(args, io) {
-    const flags = '--drop / --stop-after-current';
-    if (args.lots.length || args.continue || args.dryRun || args.budget !== undefined || args.answers.length)
-        throw new RafError(`${flags} ne se combinent pas avec des lots à lancer, --continue, --dry-run, --budget ou --answer`);
-    const store = liveStore(flags, args, io);
-    if (typeof store === 'number')
-        return store;
-    const lots = store.lots();
-    const refusals = [];
-    const keys = [];
-    for (const d of args.drop) {
-        const matches = lots.filter((l) => l.lot === d.lot && (d.project ? l.project === d.project : true));
-        const where = `${d.project ? `${d.project}:` : ''}${d.lot}`;
-        if (matches.length !== 1)
-            refusals.push(matches.length ? `--drop ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--drop ${where} : lot inconnu dans la vague ${store.id}`);
-        else if (lotFinished(matches[0]))
-            refusals.push(`--drop ${lotKey(matches[0].project, matches[0].lot)} : le lot est déjà fini (${matches[0].status})`);
-        else
-            keys.push(lotKey(matches[0].project, matches[0].lot));
-    }
-    if (refusals.length) {
-        for (const r of refusals)
-            io.err(`orchestrate : ${r}`);
-        return 2;
-    }
-    // La demande est écrite quoi qu'il arrive (le fichier est inoffensif) ; mais une vague d'avant L79 ne le lira jamais : on le dit.
-    if (!waveReadsControl(store.dir))
-        io.err(`orchestrate : ${flags} : la vague ${store.id} ne lit pas les demandes de contrôle (lancée avec une version de cadence d'avant L79) : la demande est écrite dans control.log mais cette vague ne la lira pas`);
-    for (const k of keys) {
-        store.requestDrop(k);
-        store.journal(`demande : retirer ${k} de la vague`);
-        io.out(`${k} : retrait demandé — la vague ${store.id} l'écarte avant sa prochaine session (la session en cours finit)`);
-    }
-    if (args.stopAfterCurrent) {
-        store.requestStopAfterCurrent();
-        store.journal('demande : arrêt après les sessions en cours');
-        io.out(`vague ${store.id} : arrêt demandé — les sessions en cours finissent, aucune autre ne part ; reprise par « ${resumeCommand(store.id)} »`);
-    }
-    return 0;
-}
-/** La seule vague non terminée du dossier (L309) ; plusieurs : refus qui les liste, aucune : refus (jamais le choix silencieux de la plus récente). */
-function singleUnfinished(launch) {
-    const open = RunStore.unfinished(launch);
-    if (open.length === 0)
-        throw new RafError('aucune vague à reprendre dans ce dossier');
-    if (open.length > 1)
-        throw new RafError(`plusieurs vagues non terminées dans ce dossier, laquelle reprendre ?\n${open.map((s) => `  ${s.id} (${s.readWave()?.status ?? 'illisible'}, lancée ${s.readWave()?.created ?? '?'})`).join('\n')}\nreprise : ${resumeCommand('<vague>')}`);
-    return open[0];
-}
-/**
- * L309 : l'instantané d'une vague antérieure relit `--wave <id>` comme un simple nom et `--resume` seul comme « la dernière vague non terminée » :
- * on lui transmet la vague choisie en clair (`--resume <id>`, sans `--wave`), quel que soit le parseur qui la lira.
- */
-export function resumeArgv(argv, id) {
-    const out = [];
-    for (let i = 0; i < argv.length; i++) {
-        const t = argv[i];
-        if (t === '--wave')
-            i++;
-        else if (t === '--resume') {
-            out.push(t, id);
-            const next = argv[i + 1];
-            if (next !== undefined && !next.startsWith('-') && !LOT_LIKE.test(next))
-                i++;
-        }
-        else if (t === '--answer')
-            out.push(t, argv[++i] ?? '', argv[++i] ?? '');
-        else
-            out.push(t);
-    }
-    return out;
-}
-async function resume(args, argv, io, deps, launch, today) {
-    const store = typeof args.resume === 'string' ? RunStore.find(launch, args.resume) : singleUnfinished(launch);
-    if (!store)
-        throw new RafError(`vague inconnue : ${args.resume}`);
-    // L532 : `--integrate` seul sur une vague qui tourne encore dépose l'intégration dans sa file au lieu de refuser ; dit avant l'instantané (le dépôt ne demande rien à son code) ; une reprise qui attend le dépôt (L443) est inscrite vivante mais ne joue pas encore : la vague doit être « running ». Avec une autre option de reprise ou --replay, le refus ci-dessous reste.
-    if (depositsOnly(args, runsElsewhere(store, launch)))
-        return depositIntegrations(args.integrate, io, store);
-    if (deps.snapshot) {
-        // La reprise tourne sur l'instantané de la vague, jamais sur le dist/ courant ; une vague d'avant L61 n'en a pas.
-        if (LOT_LIKE.test(store.id) && snapshotExists(store.dir)) {
-            // L309 : `--resume suite2` serait relu par n'importe quel parseur comme un lot à lancer ; `--wave suite2`, un instantané d'avant L309 le prendrait pour un simple nom et reprendrait une autre vague.
-            io.err(`orchestrate : vague ${store.id} : son nom ressemble à un lot, l'instantané ne saurait pas le relire comme une vague : reprise avec le dist/ et les gabarits courants`);
-        }
-        else if (snapshotExists(store.dir)) {
-            // Une vague d'avant L223 refuserait « projet:lot=+N » comme budget invalide : seul le lot visé justifie de la rejouer avec le dist/ courant.
-            if ((!args.lotBudgets.length || waveReadsLotBudget(store.dir)) && (!args.integrate.length || waveReadsIntegrate(store.dir)) && (!args.integrate.some((t) => t.replay) || waveReadsReplay(store.dir))) {
-                // L330 : la copie dont l'instantané lie le node_modules a pu être purgée par une mise en service ; on relie, on le journalise, ou on refuse proprement.
-                try {
-                    const healed = repairSnapshotModules(store.dir, deps.snapshot.packageRoot);
-                    if (healed) {
-                        store.journal(healed);
-                        io.err(`orchestrate : vague ${store.id} : ${healed}`);
-                    }
-                }
-                catch (e) {
-                    if (!(e instanceof SnapshotRefusal))
-                        throw e;
-                    io.err(`orchestrate : vague ${store.id} : ${e.message}`);
-                    return 2;
-                }
-                return deps.snapshot.reexec(toolDirOf(store.dir), resumeArgv(argv, store.id), io.env, io);
-            }
-            io.err(`orchestrate : vague ${store.id} : son instantané ne connaît pas ${args.lotBudgets.length && !waveReadsLotBudget(store.dir) ? '--budget projet:lot=+N (antérieur à L223)' : `${args.integrate.some((t) => t.replay) && waveReadsIntegrate(store.dir) ? '--replay' : '--integrate'} (antérieur à L279)`} : reprise avec le dist/ et les gabarits courants`);
-        }
-        else {
-            io.err(`orchestrate : vague ${store.id} sans instantané (antérieure à L61) : reprise avec le dist/ et les gabarits courants`);
-        }
-    }
-    // L407 : la forme documentée sur une vague qui tourne encore dépose la réponse dans sa file au lieu de refuser ; avec une autre option de reprise, le refus ci-dessous reste.
-    if (args.answers.length && !args.lotBudgets.length && !args.drop.length && !args.integrate.length && args.budget === undefined && !args.continue && liveWaves(cadenceHome()).some((w) => w.wave === store.id && w.cwd === launch && w.pid !== process.pid))
-        return answerLive(args, io, store);
-    const wave = store.readWave();
-    const refusals = [];
-    const info = deps.claudeInfo();
-    if (!info)
-        refusals.push('claude introuvable (CADENCE_CLAUDE_BIN, ou claude dans le PATH)');
-    const alive = liveWaves(cadenceHome()).find((w) => w.wave === wave.id && w.cwd === launch && w.pid !== process.pid);
-    if (alive)
-        refusals.push(`la vague ${alive.wave} tourne encore (pid ${alive.pid})`);
-    // Une vague terminée ne se reprend que pour rejouer un lot visé par --budget projet:lot=+N (L223) ; ce lot est vérifié plus bas.
-    if (wave.status === 'done' && !args.lotBudgets.length && !args.integrate.length)
-        refusals.push(`la vague ${wave.id} est terminée`);
-    const lots = store.lots();
-    for (const a of args.answers) {
-        const l = lots.find((x) => x.lot === a.lot && (a.project ? x.project === a.project : true));
-        if (!l)
-            refusals.push(`--answer ${a.project ? `${a.project}:` : ''}${a.lot} : lot inconnu dans la vague ${wave.id}`);
-        else if (l.status !== 'question')
-            refusals.push(`--answer ${lotKey(l.project, l.lot)} : le lot n'attend pas de réponse (${l.status})`);
-        else {
-            l.pendingAnswer = a.text;
-            l.answers.push(a.text);
-            l.questions = [];
-        }
-    }
-    // --resume --drop projet:lot (L79) : le lot est retiré avant d'être rejoué — le seul moyen de retirer un lot d'une vague arrêtée, --drop seul refusant une vague qui ne tourne plus.
-    const drops = [];
-    for (const d of args.drop) {
-        const matches = lots.filter((x) => x.lot === d.lot && (d.project ? x.project === d.project : true));
-        const where = `${d.project ? `${d.project}:` : ''}${d.lot}`;
-        if (matches.length !== 1)
-            refusals.push(matches.length ? `--drop ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--drop ${where} : lot inconnu dans la vague ${wave.id}`);
-        else if (lotFinished(matches[0]))
-            refusals.push(`--drop ${lotKey(matches[0].project, matches[0].lot)} : le lot est déjà fini (${matches[0].status})`);
-        else
-            drops.push(lotKey(matches[0].project, matches[0].lot));
-    }
-    // --resume --budget projet:lot=+N (L223) : un lot rendu sur budget est remis en jeu avec son budget relevé (N reste la marge des passes ordinaires : la part de l'escalade encore retenue, L349, s'y ajoute). Il subit ensuite les gardes d'un lot vivant.
-    const raised = new Map();
-    const answered = args.answers.map((a) => lots.filter((x) => x.lot === a.lot && (a.project ? x.project === a.project : true))).filter((m) => m.length === 1).map((m) => m[0]);
-    const dropped = args.drop.map((d) => lots.filter((x) => x.lot === d.lot && (d.project ? x.project === d.project : true))).filter((m) => m.length === 1).map((m) => m[0]);
-    for (const b of args.lotBudgets) {
-        const matches = lots.filter((x) => x.lot === b.lot && (b.project ? x.project === b.project : true));
-        const where = `${b.project ? `${b.project}:` : ''}${b.lot}`;
-        if (matches.length !== 1) {
-            refusals.push(matches.length ? `--budget ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--budget ${where} : lot inconnu dans la vague ${wave.id}`);
-            continue;
-        }
-        const l = matches[0];
-        const key = lotKey(l.project, l.lot);
-        if (raised.has(l))
-            refusals.push(`--budget ${key} : lot visé deux fois`);
-        else if (dropped.includes(l))
-            refusals.push(`--budget ${key} : lot aussi retiré par --drop`);
-        else if (answered.includes(l))
-            refusals.push(`--budget ${key} : lot aussi visé par --answer`);
-        else if (!budgetStep(l))
-            refusals.push(`--budget ${key} : le lot n'est pas rendu sur budget avec une étape d'écriture à rejouer (${l.status}${l.status === 'handed-back' ? `, étape ${l.next ?? 'aucune'} : ${l.outcome ?? 'sans cause'}` : ''})`);
-        else if (budgetStep(l) === 'fix' && b.raise <= REVIEW_RESERVE)
-            refusals.push(`--budget ${key}=+${b.text} : un fix ne part qu'au-dessus de ${REVIEW_RESERVE} tokens de réserve`);
-        else
-            raised.set(l, { from: l.budget ?? lotSpent(l), to: lotSpent(l) + b.raise + heldForEscalation(l), step: budgetStep(l) });
-    }
-    // --resume --integrate projet:lot (L279, R27) : un lot rendu à l'étape d'intégration (next: integrate) n'est rejoué que si le lead le nomme. Ni --resume seul, ni --drop, --answer ou --budget ne le rejouent.
-    const integ = [];
-    // L370 : un lot rendu hors de l'intégration que le lead a fait corriger puis revoir hors vague (revue conforme au dernier commit du worktree) est repris à l'intégration avec ce verdict.
-    const leadReviewed = new Map();
-    const budgeted = args.lotBudgets.map((b) => lots.filter((x) => x.lot === b.lot && (b.project ? x.project === b.project : true))).filter((m) => m.length === 1).map((m) => m[0]);
-    for (const t of args.integrate) {
-        const matches = lots.filter((x) => x.lot === t.lot && (t.project ? x.project === t.project : true));
-        const opt = t.replay ? '--replay' : '--integrate';
-        const where = `${t.project ? `${t.project}:` : ''}${t.lot}`;
-        if (matches.length !== 1) {
-            refusals.push(matches.length ? `${opt} ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `${opt} ${where} : lot inconnu dans la vague ${wave.id}`);
-            continue;
-        }
-        const l = matches[0];
-        const key = lotKey(l.project, l.lot);
-        if (integ.includes(l))
-            refusals.push(`${opt} ${key} : lot visé deux fois`);
-        else if (dropped.includes(l))
-            refusals.push(`${opt} ${key} : lot aussi retiré par --drop`);
-        else if (answered.includes(l))
-            refusals.push(`${opt} ${key} : lot aussi visé par --answer`);
-        else if (budgeted.includes(l))
-            refusals.push(`${opt} ${key} : lot aussi visé par --budget`);
-        else if (!t.replay && l.next !== 'integrate' && (() => {
-            // La revue du lead est écrite par `raf review` lancé dans le worktree : c'est le plan du worktree qui la porte, pas celui du dépôt principal.
-            const tree = lotTreeDir(store.dir, l.project, l.lot, l.repo);
-            const r = existsSync(join(tree, '.git')) ? leadReviewedHandBack(l, planLoader(tree)(), tree) : null;
-            if (r)
-                leadReviewed.set(l, r);
-            return r;
-        })())
-            integ.push(l);
-        else if (l.status !== 'handed-back' || (l.next !== 'integrate' && !(t.replay && planNoteHandBack(l))))
-            refusals.push(`${opt} ${key} : le lot n'est pas rendu ${t.replay ? "à l'étape d'intégration ni sur une écriture de plan refusée" : "à l'étape d'intégration"} (${l.status}, étape ${l.next ?? 'aucune'} : ${l.outcome ?? 'sans cause'})`);
-        else
-            integ.push(l);
-    }
-    // Un lot retiré ne jouera rien : il ne subit ni le verrou du dépôt, ni le .nvmrc, ni l'arbre sale — un refus pour LUI ne doit pas faire échouer la reprise des autres.
-    const live = [];
-    const removed = [];
-    for (const l of lots) {
-        if (lotFinished(l) && !raised.has(l) && !integ.includes(l))
-            continue;
-        for (const s of l.steps) {
-            if (s.status !== 'running')
-                continue;
-            if (s.pid && pidAlive(s.pid))
-                refusals.push(`${lotKey(l.project, l.lot)} : session encore en vie, pid ${s.pid}`);
-            else
-                s.status = 'interrupted';
-        }
-        (drops.includes(lotKey(l.project, l.lot)) ? removed : live).push(l);
-    }
-    // Comme au départ : un dépôt tenu par une autre orchestration vivante est refusé avant toute écriture.
-    // L443 : une reprise d'intégration (--integrate, --replay) attend la fin de l'autre vague au lieu de sortir en 2 ; toute autre reprise refuse comme avant.
-    // Un refus déjà connu (vague qui tourne encore, claude introuvable, session en vie…) sort en 2 tout de suite : attendre 3 h ne le lèverait pas.
-    const waitFor = integ.length && !refusals.length ? { waitMs: deps.repoWait?.waitMs ?? REPO_WAIT_MS, pollMs: deps.repoWait?.pollMs ?? REPO_WAIT_POLL_MS } : null;
-    const deadline = Date.now() + (waitFor?.waitMs ?? 0);
-    // Pendant l'attente (jusqu'à 3 h) la reprise est inscrite parmi les vagues vivantes : le garde « la vague tourne encore » d'une seconde reprise la voit, et ne vient pas attendre à son tour.
-    let waiting = false;
-    // Verrous pris à la fin de l'attente : tenus jusqu'à `execute` (qui les retrouve à son pid), pour qu'une autre reprise qui attendait le même dépôt ne le voie pas libre pendant le .nvmrc, l'arbre et l'écriture des lots.
-    const taken = [];
-    const stopBefore = store.control().stopAfterCurrent;
-    try {
-        for (const repo of new Set(live.flatMap(lotRepoPaths))) {
-            const file = join(sharedStateDir(repo), REPO_LOCK);
-            let announced = null;
-            for (;;) {
-                let busy = activeLock(file);
-                if (waitFor && (!busy || busy.pid === process.pid)) {
-                    const t = takeLock(file, { pid: process.pid, wave: wave.id, started: new Date().toISOString() });
-                    if (t.ok) {
-                        taken.push(file);
-                        if (t.stale)
-                            io.err(`orchestrate : verrou de dépôt périmé retiré (${basename(repo)}, pid ${t.stale.pid} mort)`);
-                        break;
-                    }
-                    busy = t.held;
-                }
-                if (!busy || busy.pid === process.pid)
-                    break;
-                // Le verrou porte l'id de la vague : tenu par un processus vivant de CETTE vague, c'est une autre reprise de la même vague,
-                // entre son verrou et son inscription par `execute` (le garde « tourne encore » ci-dessus ne la voit pas encore) : refus, pas d'attente.
-                if (busy.wave === wave.id) {
-                    refusals.push(`la vague ${wave.id} tourne encore (pid ${busy.pid}, verrou de ${basename(repo)})`);
-                    break;
-                }
-                // Un refus déjà posé sur un dépôt précédent (même vague, attente échue) : les suivants ne font plus attendre, la reprise sort en 2.
-                if (!waitFor || refusals.length || Date.now() >= deadline) {
-                    refusals.push(heldRefusal(repo, busy));
-                    break;
-                }
-                if (!waiting) {
-                    registerWave(cadenceHome(), { pid: process.pid, wave: wave.id, started: new Date().toISOString(), cwd: launch, repos: [] });
-                    waiting = true;
-                }
-                if (announced !== busy.wave)
-                    io.out(`orchestrate : ${basename(repo)} : tenu par la vague ${busy.wave} (pid ${busy.pid}) : attente de sa fin avant de reprendre l'intégration`);
-                announced = busy.wave;
-                await new Promise((res) => setTimeout(res, Math.min(waitFor.pollMs, Math.max(1, deadline - Date.now()))));
-            }
-        }
-    }
-    finally {
-        if (waiting)
-            unregisterWave(cadenceHome(), process.pid);
-    }
-    // Avant `execute`, tout refus ou échec rend les verrous pris ; `execute` les garde ensuite et les rend à sa fin.
-    let played = false;
-    try {
-        // Comme au départ : le .nvmrc est relu à chaque reprise (version désinstallée, .nvmrc changé, vague d'avant L80),
-        // et un Node introuvable refuse le lot — jamais de repli silencieux sur le Node par défaut.
-        const nodes = new Map();
-        for (const l of live) {
-            const node = resolveNode(l.repo, nvmVersionsDir(io.env));
-            if (node.kind === 'missing')
-                refusals.push(`${lotKey(l.project, l.lot)} : ${node.message}`);
-            else
-                nodes.set(l, node);
-        }
-        // Tous les refus avant la moindre écriture (l'arbre sale compris) : une reprise refusée ne change pas l'état de la vague.
-        const dirty = new Set();
-        for (const repo of live.flatMap(lotRepoPaths))
-            if (!dirty.has(repo)) {
-                dirty.add(repo);
-                const d = await trackedDirty(repo);
-                if (d.length)
-                    refusals.push(`${basename(repo)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
-            }
-        // Les worktrees des lots repris suivent les mêmes gardes qu'un dépôt (R11) : un fichier suivi modifié refuse la reprise.
-        for (const l of live) {
-            const dir = lotTreeDir(store.dir, l.project, l.lot, l.repo);
-            if (!existsSync(join(dir, '.git')))
-                continue;
-            const d = await trackedDirty(dir);
-            if (d.length)
-                refusals.push(`${basename(dir)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
-        }
-        if (refusals.length) {
-            for (const r of refusals)
-                io.err(`orchestrate : ${r}`);
-            return 2;
-        }
-        for (const [l, node] of nodes) {
-            if (node.kind === 'ok')
-                l.node = { version: node.version, wanted: node.wanted, bin: node.bin, link: (deps.linkNode ?? linkNodeBin)(store.dir, node.version, node.bin) };
-            else
-                delete l.node;
-        }
-        // Une étape interrompue (signal, crash) dont les tokens n'ont pas été comptés : relue dans le journal de sa session.
-        const recovered = new Budget(0);
-        // La session d'un lot en worktree a travaillé dans son worktree : c'est là que son journal se range.
-        const workdirOf = (l) => {
-            const dir = lotTreeDir(store.dir, l.project, l.lot, l.repo);
-            return existsSync(join(dir, '.git')) ? dir : l.repo;
-        };
-        for (const l of [...live, ...removed])
-            for (const s of l.steps)
-                if (s.status === 'interrupted')
-                    countInterrupted(deps.claudeHome, workdirOf(l), s, recovered);
-        wave.consumed += recovered.consumed;
-        wave.cacheRead += recovered.cacheRead;
-        if (recovered.consumed || recovered.cacheRead)
-            store.writeWave(wave);
-        for (const [l, r] of raised) {
-            const k = lotKey(l.project, l.lot);
-            const text = `budget relevé de ${r.from} à ${r.to} (--resume --budget)`;
-            l.budget = r.to;
-            l.status = 'suspended';
-            l.next = r.step;
-            l.outcome = null;
-            l.warnings.push(text);
-            store.journal(`${k} → suspended — ${text}`);
-            io.out(`${k} → suspended — ${text}`);
-        }
-        for (const l of integ) {
-            const k = lotKey(l.project, l.lot);
-            const lead = leadReviewed.get(l);
-            if (lead)
-                adoptLeadReview(l, lead);
-            const planNote = l.next !== 'integrate'; // rendu sur une écriture de plan refusée (--replay) : le lot repart de l'étape gardée
-            if (planNote && l.outcome?.startsWith(HYPOTHESES_HANDBACK))
-                l.hypotheses = undefined; // les notes d'hypothèses se posent de nouveau (sans doublon) à l'entrée de l'étape
-            l.status = 'suspended';
-            l.outcome = null;
-            const text = planNote ? `écriture du plan reprise à l'étape ${l.next} (--resume --replay)` : integrationText(lead ?? null);
-            store.journal(`${k} → suspended — ${text}`);
-            io.out(`${k} → suspended — ${text}`);
-        }
-        for (const l of live) {
-            if (l.status === 'implementing' || l.status === 'reviewing' || l.status === 'fixing')
-                l.status = 'suspended';
-            store.writeLot(l);
-        }
-        if (args.budget !== undefined)
-            wave.budget = wave.consumed + args.budget;
-        // Un arrêt demandé à la vague d'avant ne doit pas arrêter celle-ci ; celui demandé pendant l'attente (la reprise est alors visible de --stop-after-current) est gardé.
-        if (!(waiting && !stopBefore && store.control().stopAfterCurrent))
-            store.clearStopRequest();
-        for (const l of removed) {
-            const k = lotKey(l.project, l.lot);
-            store.requestDrop(k);
-            store.journal(`demande : retirer ${k} de la vague (--resume --drop)`);
-            io.out(`${k} : retrait demandé — le lot est rendu au lead sans être rejoué`);
-            l.next = null;
-            l.status = 'handed-back';
-            l.outcome = DROPPED;
-            store.writeLot(l);
-            store.journal(`${k} → handed-back — ${DROPPED}`);
-            // Un lot retiré garde son worktree et sa branche (R12) : le journal en donne le chemin.
-            const branch = lotBranch(wave.id, l.project, l.lot);
-            if (baseBranchOf(l.repo, branch)) {
-                const line = `orchestrate : ${k} : worktree conservé : ${lotTreeDir(store.dir, l.project, l.lot, l.repo)} (branche ${branch})`;
-                io.out(line);
-                store.journal(line);
-            }
-        }
-        if (live.length === 0) {
-            if (lots.every(lotFinished)) {
-                wave.status = 'done';
-                store.writeWave(wave);
-            }
-            for (const line of renderTable(wave, lots, { prices: launchPrices(launch, (w) => io.err(`orchestrate : ${w}`)) }))
-                io.out(line);
-            for (const line of keptLines(lots.map((l) => l.repo)))
-                io.out(line);
-            return removed.length && !lots.every((l) => l.status === 'ready') ? 1 : 0;
-        }
-        played = true;
-        return continueRounds(await execute(wave, live, store, io, deps, today, args, lots), wave, lots, store, io, deps, today, args, launch);
-    }
-    finally {
-        if (!played)
-            for (const f of taken)
-                releaseLock(f, process.pid);
-    }
-}
 /** `loggedIn` de la sortie JSON de `claude auth status` ; null si elle n'est pas lisible (versions sans cette commande : pas de refus). */
 export function parseAuthStatus(text) {
     try {