@sylad/cadence 0.10.1 → 0.12.0

package/dist/orchestrate/command.js

@@ -1,24 +1,35 @@
 import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
 import { readOrchestrateConfig, readPlanConfig } from '../config.js';
 import { isDay, toDay } from '../dates.js';
 import { gitRoot } from '../git.js';
 import { onTermination } from '../proc.js';
+import { stopApps } from './app.js';
 import { Plan, RafError, isOpen } from '../plan.js';
 import { AGENTS_DIR } from '../skills.js';
 import { pidAlive, sharedStateDir } from '../state.js';
-import { loadTemplates, objective, renderBrief } from './briefs.js';
-import { Budget, MAX_PASSES, countInterrupted } from './cycle.js';
+import { acquireSlot, cadenceHome, liveSlots, liveWaves, registerWave, unregisterWave } from './registry.js';
+import { loadTemplates, newsText, objective, renderBrief } from './briefs.js';
+import { Budget, MAX_PASSES, countInterrupted, needsPrecheck } from './cycle.js';
 import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
-import { buildArgs, killSessions, readAgents, realClaude } from './launch.js';
+import { buildArgs, killSessions, mcpServersFor, readAgents, realClaude } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { runPool } from './pool.js';
 import { schemaFor } from './schemas.js';
 import { excludeState, lotKey, newLot, RunStore } from './state.js';
+import { linkNodeBin, nvmVersionsDir, resolveNode } from './node-env.js';
 import { quotaText, renderTable } from './table.js';
+import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, snapshotExists, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
 export const DEFAULT_BUDGET = 2_000_000;
+/** Tokens comptés par jour d'estimate (L78) ; mesuré le 06-10 : des lots de 0,5 j ont mangé 192 à 531 k, des lots de 1 j 455 à 468 k (2 M pour 6 lots) ; le plafond est posé sous ces mesures pour arrêter vraiment. */
+const LOT_BUDGET_PER_DAY = 400_000;
+const LOT_BUDGET_FLOOR = 200_000;
+/** Budget d'un lot, dérivé de son estimate : empêche quelques lots d'avaler le budget de la vague au détriment des autres. */
+export const lotBudget = (estimate) => Math.max(LOT_BUDGET_FLOOR, Math.round(estimate * LOT_BUDGET_PER_DAY));
+/** 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());
@@ -29,6 +40,11 @@ export function parseBudget(text) {
         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);
+}
 const LOT_LIKE = /^(?:[\w.-]+:)?[A-Za-z]+\d+(?:@\w+)?$/;
 const MODELS = ['sonnet', 'opus', 'haiku'];
 function lotArg(text) {
@@ -59,6 +75,8 @@ export function parseOrchestrateArgs(argv) {
         }
         else if (t === '--budget')
             a.budget = parseBudget(value(t));
+        else if (t === '--max-sessions')
+            a.maxSessions = parseMaxSessions(value(t));
         else if (t === '--wave')
             a.wave = value(t);
         else if (t === '--answer') {
@@ -75,7 +93,7 @@ export function parseOrchestrateArgs(argv) {
 /** 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 planConfig = readPlanConfig(configPath);
+    const planConfig = readPlanConfig(configPath, repo);
     const planPath = resolve(repo, planConfig?.path ?? 'docs/plan/raf.yaml');
     return { config: readOrchestrateConfig(configPath), loadPlan: () => Plan.load(planPath, { ...planConfig?.settings, config: configPath }), configPath };
 }
@@ -122,9 +140,6 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
         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 held = activeLock(join(launch, '.cadence', 'orchestrate.lock'));
-    if (held && !opts.resume)
-        refusals.push(`une vague est déjà en cours dans ${launch} (${held.wave}, pid ${held.pid})`);
     const lots = [];
     const repoChecked = new Set();
     const byProject = new Map();
@@ -175,9 +190,18 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             if (busy && !opts.resume)
                 refusals.push(`${basename(t.repo)} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})`);
         }
+        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 state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, visible: lot.visible, small, model: t.model, readOnlyPlan: plan.readonly });
+        state.light = lot.estimate <= env.config.review.threshold;
+        state.budget = lotBudget(lot.estimate);
         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 };
@@ -185,14 +209,17 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
 function agentsOf(deps) {
     return readAgents(deps.agentsDir);
 }
+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) {
+    const n = io.now();
+    return `${toDay(n)}-${String(n.getHours()).padStart(2, '0')}${String(n.getMinutes()).padStart(2, '0')}`;
+}
+/** Identifiant d'une simulation : le premier libre, sans rien réserver ni écrire. */
 function waveId(io, requested, launch) {
-    if (requested) {
-        if (!/^[\w.-]+$/.test(requested))
-            throw new RafError(`--wave invalide : ${requested}`);
+    if (requested)
         return requested;
-    }
-    const n = io.now();
-    const base = `${toDay(n)}-${String(n.getHours()).padStart(2, '0')}${String(n.getMinutes()).padStart(2, '0')}`;
+    const base = defaultWaveBase(io);
     let id = base;
     for (let i = 2; existsSync(join(RunStore.runsDir(launch), id)); i++)
         id = `${base}-${i}`;
@@ -208,29 +235,70 @@ function dryRun(lots, io, deps, budget, id) {
         const lot = env.loadPlan().lot(l.lot);
         const slot = repos.indexOf(l.repo);
         io.out(`${lotKey(l.project, l.lot)} — ${l.title}`);
+        io.out(`  budget du lot : ${l.budget} tokens comptés (dérivé de l'estimate)`);
         io.out(`  file ${basename(l.repo)} · ${slot < 2 ? `créneau ${slot + 1}` : 'en attente d\'un créneau'}`);
+        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 steps = [{ kind: 'implement', model: l.model }];
+        if (needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot))
+            steps.unshift({ kind: 'precheck', model: 'sonnet' });
+        const { light, full } = env.config.review;
         if (l.small)
-            steps.push({ kind: l.visible ? 'review-small' : 'review', model: 'opus' });
+            steps.push({ kind: l.visible ? 'review-small' : 'review', model: l.light ? light : full });
         else {
             if (l.visible && env.config.ux)
-                steps.push({ kind: 'ux', model: 'opus' });
-            steps.push({ kind: 'review', model: 'opus' });
+                steps.push({ kind: 'ux', model: full });
+            steps.push({ kind: 'review', model: l.light ? light : full });
         }
-        io.out(`  étapes : ${steps.map((s) => `${s.kind} (${s.model})`).join(' → ')}${l.small ? ' — petit lot' : ''}${l.visible && !env.config.ux ? ' — UX à faire par le lead (orchestrate.ux absent)' : ''}`);
+        io.out(`  étapes : ${steps.map((s) => `${s.kind} (${s.model})`).join(' → ')}${l.small ? ' — petit lot' : ''}${l.light ? ` — 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)' : ''}`);
         io.out(`  corrections : ${MAX_PASSES} passe(s) au plus, en session neuve`);
-        io.out('  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 vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: '', choix: '' };
+        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, `${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: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '' };
         for (const s of steps) {
             const file = join(tmp, `${l.project}--${l.lot}--${s.kind}.md`);
             const brief = renderBrief(s.kind, vars, deps.templatesDir);
             writeFileSync(file, brief);
-            const args = buildArgs({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model, schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'ux' ? 'ux-reviewer' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: env.config.addDirs, timeoutMs: 0 }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
+            const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small).playwright;
+            const args = buildArgs({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model, schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'ux' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: playwright && (s.kind === 'implement') ? [...env.config.addDirs, pwDir] : env.config.addDirs, timeoutMs: 0, mcpConfig: '<mcp>', playwright }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
             io.out(`  ${s.kind} : claude ${args.join(' ')}`);
             io.out(`    brief : ${file}`);
+            const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small));
+            io.out(`    mcp : ${servers.length ? `${servers.join(', ')} (captures dans le dossier de la vague : <vague>/${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;
+}
+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`;
+}
+/** Vagues vivantes (toutes, quel que soit leur dossier de départ) et dépôts qu'elles tiennent. */
+function liveLines() {
+    const home = cadenceHome();
+    const waves = liveWaves(home);
+    if (waves.length === 0)
+        return [];
+    const slots = liveSlots(home).length;
+    const lines = [`vagues en cours : ${waves.length} · sessions en cours : ${slots}`];
+    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;
+}
+/** 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;
+}
 /** 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) {
     const args = parseOrchestrateArgs(argv);
@@ -238,16 +306,24 @@ export async function orchestrate(argv, io, deps) {
     const today = io.env.RAF_TODAY && isDay(io.env.RAF_TODAY) ? io.env.RAF_TODAY : toDay(io.now());
     if (args.status !== undefined) {
         const store = typeof args.status === 'string' ? RunStore.find(launch, args.status) : RunStore.last(launch);
+        maxSessions(args, io); // une valeur invalide est refusée ici aussi
+        const live = liveLines();
+        for (const line of live)
+            io.out(line);
+        if (!store && live.length && args.status === true)
+            return 0; // sans identifiant : les vagues vivantes suffisent
         if (!store)
             throw new RafError(typeof args.status === 'string' ? `vague inconnue : ${args.status}` : 'aucune vague dans ce dossier');
+        if (live.length)
+            io.out('');
         for (const line of renderTable(store.readWave(), store.lots()))
             io.out(line);
         return 0;
     }
     if (args.resume !== undefined)
-        return resume(args, io, deps, launch, today);
+        return resume(args, argv, io, deps, launch, today);
     if (args.lots.length === 0)
-        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--dry-run] | --status [vague] | --resume [vague] [--answer projet:lot "réponse"]');
+        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] | --status [vague] | --resume [vague] [--answer projet:lot "réponse"]');
     const refusals = [];
     const targets = resolveTargets(args, io, refusals);
     const pre = await preflight(args, targets, io, deps, launch);
@@ -258,22 +334,78 @@ export async function orchestrate(argv, io, deps) {
             io.err(`orchestrate : ${r}`);
         return 2;
     }
-    const id = waveId(io, args.wave, launch);
+    if (args.wave !== undefined && !WAVE_ID_RE.test(args.wave))
+        throw new RafError(`--wave invalide : ${args.wave}`);
     if (args.dryRun) {
+        const id = waveId(io, args.wave, launch);
+        if (args.wave && existsSync(join(RunStore.runsDir(launch), id)))
+            return waveExists(args.wave, io);
         dryRun(pre.lots, io, deps, budget, id);
         return 0;
     }
-    const store = new RunStore(launch, id);
+    if (deps.snapshot) {
+        // Refus avant de réserver la vague : rien n'est créé si les dépendances ne se résolvent pas.
+        try {
+            resolveModulesDir(deps.snapshot.packageRoot);
+        }
+        catch (e) {
+            if (!(e instanceof SnapshotRefusal))
+                throw e;
+            io.err(`orchestrate : ${e.message}`);
+            return 2;
+        }
+    }
+    // Processus relancé depuis l'instantané : la vague a déjà été réservée par le processus d'origine.
+    const reserved = deps.snapshot ? undefined : io.env[RESERVED_ENV];
+    const store = reserved ? new RunStore(launch, reserved) : RunStore.reserve(launch, args.wave ?? defaultWaveBase(io), { exact: args.wave !== undefined });
+    if (!store)
+        return waveExists(args.wave, io);
+    if (deps.snapshot) {
+        try {
+            const tool = takeSnapshot(store.dir, deps.snapshot.packageRoot);
+            const code = await deps.snapshot.reexec(tool, argv, { ...io.env, [RESERVED_ENV]: store.id }, io);
+            if (!existsSync(join(store.dir, 'wave.json')))
+                rmSync(store.dir, { recursive: true, force: true });
+            return code;
+        }
+        catch (e) {
+            rmSync(store.dir, { recursive: true, force: true });
+            if (e instanceof SnapshotRefusal) {
+                io.err(`orchestrate : ${e.message}`);
+                return 2;
+            }
+            throw e;
+        }
+    }
+    const id = store.id;
     const wave = { id, created: io.now().toISOString(), cwd: launch, budget, consumed: 0, cacheRead: 0, status: 'running', pid: process.pid, lots: pre.lots.map((l) => lotKey(l.project, l.lot)) };
-    for (const l of pre.lots)
-        store.writeLot(l);
-    return execute(wave, pre.lots, store, io, deps, today);
+    // Une vague qui n'a pas atteint `wave.json` (refus au verrou, démarrage en échec) ne laisse pas son dossier réservé :
+    // le même `--wave` se relance, et `reserve` ne le prend pas pour une vague existante.
+    const abandon = () => {
+        if (!existsSync(join(store.dir, 'wave.json')))
+            rmSync(store.dir, { recursive: true, force: true });
+    };
+    try {
+        // Dans la section gardée : un lien ou une écriture qui échoue ne laisse pas la vague réservée sans wave.json.
+        for (const l of pre.lots) {
+            if (l.node)
+                l.node.link = (deps.linkNode ?? linkNodeBin)(store.dir, l.node.version, l.node.bin);
+            store.writeLot(l);
+        }
+        const code = await execute(wave, pre.lots, store, io, deps, today, maxSessions(args, io));
+        abandon();
+        return code;
+    }
+    catch (e) {
+        abandon();
+        throw e;
+    }
 }
 function contexts(lots, envs, wctx) {
     return lots.map((lot, i) => ({ wave: wctx, lot, config: envs[i].config, loadPlan: envs[i].loadPlan }));
 }
 /** 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, all = lots) {
+async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     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));
@@ -281,7 +413,7 @@ async function execute(wave, lots, store, io, deps, today, all = lots) {
     const templates = loadTemplates(deps.templatesDir);
     mkdirSync(join(launch, '.cadence'), { recursive: true });
     excludeState(launch);
-    const waveLock = join(launch, '.cadence', 'orchestrate.lock');
+    const home = cadenceHome();
     const held = [];
     const repos = [...new Set(lots.map((l) => l.repo))];
     const release = () => {
@@ -290,15 +422,13 @@ async function execute(wave, lots, store, io, deps, today, all = lots) {
         held.length = 0;
         for (const r of repos)
             removePrePush(r, wave.id);
+        try {
+            unregisterWave(home, process.pid);
+        }
+        catch {
+            // registre illisible : l'entrée d'un processus mort est écartée à la prochaine inscription
+        }
     };
-    const got = takeLock(waveLock, { pid: process.pid, wave: wave.id, started: new Date().toISOString() });
-    if (!got.ok) {
-        io.err(`orchestrate : une vague est déjà en cours dans ${launch} (${got.held.wave}, pid ${got.held.pid})`);
-        return 2;
-    }
-    held.push(waveLock);
-    if (got.stale)
-        io.err(`orchestrate : verrou de vague périmé retiré (${got.stale.wave}, pid ${got.stale.pid} mort)`);
     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() });
@@ -317,6 +447,28 @@ async function execute(wave, lots, store, io, deps, today, all = lots) {
             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 (args, o) => {
+        const free = await acquireSlot(home, cap, {
+            wave: wave.id,
+            pollMs: deps.slotPollMs,
+            onWait: (h, ms) => wctx.log(`en attente d'un créneau de session depuis ${duration(ms)} (${h.length}/${cap} en cours : ${[...new Set(h.map((x) => x.wave))].join(', ')})`),
+            onGot: (ms) => wctx.log(`créneau de session obtenu après ${duration(ms)} d'attente`),
+        });
+        try {
+            return await deps.claude(args, o);
+        }
+        finally {
+            free();
+        }
+    };
     const budget = new Budget(wave.budget);
     budget.consumed = wave.consumed;
     budget.cacheRead = wave.cacheRead;
@@ -330,7 +482,7 @@ async function execute(wave, lots, store, io, deps, today, all = lots) {
         id: wave.id,
         store,
         budget,
-        claude: deps.claude,
+        claude,
         agents: agentsOf(deps),
         today,
         claudeHome: deps.claudeHome,
@@ -348,8 +500,9 @@ async function execute(wave, lots, store, io, deps, today, all = lots) {
     saveWave();
     const ctxs = contexts(lots, envs, wctx);
     // 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(() => {
+    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')
@@ -367,7 +520,7 @@ async function execute(wave, lots, store, io, deps, today, all = lots) {
         release();
     });
     try {
-        await runPool(ctxs, undefined, all);
+        await runPool(ctxs, cap, all);
     }
     finally {
         forget();
@@ -387,17 +540,23 @@ async function execute(wave, lots, store, io, deps, today, all = lots) {
         return 3;
     return all.every((l) => l.status === 'ready') ? 0 : 1;
 }
-async function resume(args, io, deps, launch, today) {
+async function resume(args, argv, io, deps, launch, today) {
     const store = typeof args.resume === 'string' ? RunStore.find(launch, args.resume) : RunStore.last(launch, { unfinished: true });
     if (!store)
         throw new RafError(typeof args.resume === 'string' ? `vague inconnue : ${args.resume}` : 'aucune vague à reprendre dans ce dossier');
+    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 (snapshotExists(store.dir))
+            return deps.snapshot.reexec(toolDirOf(store.dir), argv, io.env, io);
+        io.err(`orchestrate : vague ${store.id} sans instantané (antérieure à L61) : reprise avec le dist/ et les gabarits courants`);
+    }
     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 = activeLock(join(launch, '.cadence', 'orchestrate.lock'));
-    if (alive && alive.pid !== process.pid)
+    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})`);
     if (wave.status === 'done')
         refusals.push(`la vague ${wave.id} est terminée`);
@@ -435,11 +594,27 @@ async function resume(args, io, deps, launch, today) {
         if (busy && busy.pid !== process.pid)
             refusals.push(`${basename(repo)} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})`);
     }
+    // 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);
+    }
     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);
     for (const l of live)
@@ -475,11 +650,14 @@ async function resume(args, io, deps, launch, today) {
             io.out(line);
         return 0;
     }
-    return execute(wave, live, store, io, deps, today, lots);
+    return execute(wave, live, store, io, deps, today, maxSessions(args, io), lots);
 }
 /** Dépendances réelles : `claude` (ou CADENCE_CLAUDE_BIN), agents et gabarits du paquet, journaux de ~/.claude. */
 export function realOrchestrateDeps(env) {
     const bin = env.CADENCE_CLAUDE_BIN || 'claude';
+    const child = isSnapshotChild(env);
+    // Lues ici, une fois : ni les sessions ni les commandes du projet ne reçoivent les variables de relance.
+    env = withoutLaunchVars({ ...env });
     return {
         claude: realClaude(bin, env),
         claudeInfo: () => {
@@ -493,6 +671,7 @@ export function realOrchestrateDeps(env) {
             }
         },
         agentsDir: AGENTS_DIR,
+        snapshot: child ? undefined : { packageRoot: PACKAGE_ROOT, reexec: spawnReexec },
         claudeHome: env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'),
     };
 }