@sylad/cadence 0.11.0 → 0.13.0

package/dist/orchestrate/app.js

@@ -0,0 +1,189 @@
+import { spawn } from 'node:child_process';
+import { closeSync, openSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { linkNewFile, lockFault, pidAlive, removeStaleFile } from '../state.js';
+import { withoutLaunchVars } from './snapshot.js';
+/** Défaut de `orchestrate.ux.timeout` : secondes d'attente de la réponse de l'application. */
+export const APP_TIMEOUT_S = 300;
+/** Délai entre le SIGTERM et le SIGKILL du groupe de l'application. */
+export const APP_KILL_AFTER_MS = 10_000;
+/** L'environnement de l'application : celui de l'orchestrateur, avec le Node du projet en tête du PATH quand il y en a un (sans préfixe nvm, qui sort en code 3 sous sh). */
+function appEnv(nodeBin) {
+    const env = withoutLaunchVars(process.env);
+    return nodeBin ? { ...env, PATH: [nodeBin, env.PATH ?? ''].filter(Boolean).join(delimiter) } : env;
+}
+const live = new Set();
+/** Au signal de la vague : arrête les applications lancées (SIGTERM, puis SIGKILL après le délai). L'appelant l'attend avant de mourir. */
+export async function stopApps() {
+    await Promise.all([...live].map((stop) => stop()));
+}
+function signal(pid, sig) {
+    try {
+        process.kill(-pid, sig);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Vrai quand l'URL répond en HTTP avec un statut inférieur à 500. */
+export async function responds(url) {
+    try {
+        const r = await fetch(url, { signal: AbortSignal.timeout(2_000), redirect: 'manual' });
+        await r.body?.cancel();
+        return r.status < 500;
+    }
+    catch {
+        return false;
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function tail(file) {
+    try {
+        const lines = readFileSync(file, 'utf8').trimEnd().split('\n').slice(-15).join('\n');
+        return lines.slice(-1500) || '(journal vide)';
+    }
+    catch {
+        return '(journal illisible)';
+    }
+}
+/** Verrou inter-processus de l'URL (nom : le port seul pour la machine locale, sinon hôte:port) : deux vagues (deux processus) qui déclarent la même URL ne lancent pas deux applications sur le même port. */
+export function uxLockFile(url) {
+    const u = new URL(url);
+    const port = u.port || (u.protocol === 'https:' ? '443' : '80');
+    // localhost, 127.0.0.1 et ::1 désignent la même machine : même port, même verrou
+    const local = ['localhost', '127.0.0.1', '[::1]'].includes(u.hostname);
+    return join(tmpdir(), `cadence-ux-${local ? '' : `${u.hostname.replace(/[^\w.-]/g, '_')}-`}${port}.lock`);
+}
+/** Contenu du verrou : un pid, ou null quand le fichier est vide, illisible, ou rendu entre-temps. */
+function readUrlLock(file) {
+    try {
+        return { text: readFileSync(file, 'utf8').trim(), age: Date.now() - statSync(file).mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Pose du verrou : lien vers un fichier complet (le verrou n'existe jamais à moitié écrit, comme `writeLock` de state.ts).
+ * Un verrou d'un pid mort est écarté par renommage, puis retiré seulement s'il est encore celui qu'on a lu — sinon
+ * il est rendu à son nouveau porteur (comme `removeStaleLock`) : deux vagues ne se volent pas le verrou.
+ * Faux quand un processus vivant le tient. `pid` : celui du porteur (le nôtre, sauf test).
+ */
+export function takeUrlLock(file, pid = process.pid) {
+    for (let attempt = 0; attempt < 3; attempt++) {
+        if (linkNewFile(file, String(pid), `${pid}.${attempt}`))
+            return true;
+        const seen = readUrlLock(file);
+        if (!seen)
+            continue; // rendu entre-temps
+        // Un fichier vide est un verrou posé par une version qui l'écrivait en deux temps : on ne le vole qu'au bout de 5 s.
+        if (seen.text === '' ? seen.age < 5_000 : pidAlive(Number(seen.text)))
+            return false;
+        removeStaleFile(file, (aside) => readUrlLock(aside)?.text === seen.text);
+    }
+    return false;
+}
+function releaseUrlLock(file) {
+    try {
+        if (Number(readFileSync(file, 'utf8').trim()) === process.pid)
+            rmSync(file, { force: true });
+    }
+    catch {
+        /* déjà rendu */
+    }
+}
+/**
+ * Lance l'application de la revue UX : prend le verrou de l'URL (attente comptée dans le délai), sonde l'URL (qui répond
+ * déjà : rien n'est lancé), lance la commande depuis `cwd` dans son propre groupe de processus (sortie dans `log`),
+ * puis sonde jusqu'à une réponse HTTP < 500 — le groupe lancé encore vivant — ou au délai. Le verrou est rendu à `stop`.
+ */
+export async function startApp(o) {
+    const none = async () => { };
+    const deadline = Date.now() + o.timeoutMs;
+    const lock = uxLockFile(o.url);
+    const held = { state: { kind: 'unverified', cause: `url tenue par une autre vague (${o.url})` }, stop: none };
+    try {
+        while (!takeUrlLock(lock)) {
+            if (Date.now() >= deadline)
+                return held;
+            await sleep(o.every ?? 500);
+        }
+    }
+    catch (e) {
+        // Verrou impossible à poser (pas de liens physiques…) : comme un journal illisible, la revue UX n'a pas lieu, la cause est dite.
+        return { state: { kind: 'unverified', cause: lockFault(lock, e) }, stop: none };
+    }
+    const release = () => releaseUrlLock(lock);
+    if (Date.now() >= deadline) {
+        release(); // obtenu après le délai : toute l'attente a été passée à celle du verrou, il ne reste rien pour lancer l'application
+        return held;
+    }
+    try {
+        return await launch(o, deadline, release);
+    }
+    catch (e) {
+        release();
+        throw e;
+    }
+}
+/** `release` rend le verrou : dès que rien ne tourne (busy, échec), sinon à la fin de `stop`, une fois le groupe disparu. */
+async function launch(o, deadline, release) {
+    const none = async () => { };
+    const available = Math.max(0, deadline - Date.now()); // le délai de l'étape moins l'attente du verrou : c'est lui que le message annonce
+    if (await responds(o.url)) {
+        release();
+        return { state: { kind: 'busy' }, stop: none };
+    }
+    let fd;
+    try {
+        fd = openSync(o.log, 'a');
+    }
+    catch (e) {
+        release();
+        return { state: { kind: 'unverified', cause: `journal ${o.log} : ${e.message}` }, stop: none };
+    }
+    const child = spawn('sh', ['-c', o.command], { cwd: o.cwd, env: appEnv(o.nodeBin), stdio: ['ignore', fd, fd], detached: true });
+    closeSync(fd);
+    const pid = child.pid;
+    if (pid === undefined) {
+        const cause = await new Promise((r) => child.once('error', (e) => r(e.message)));
+        release();
+        return { state: { kind: 'unverified', cause: `lancement impossible : ${cause}` }, stop: none };
+    }
+    const gone = {};
+    child.once('error', (e) => (gone.why = `lancement impossible : ${e.message}`));
+    child.once('close', (code, sig) => (gone.why = `la commande s'est arrêtée (${sig ?? `code ${code}`})`));
+    const stop = async () => {
+        live.delete(stop);
+        try {
+            if (!signal(pid, 'SIGTERM'))
+                return;
+            const limit = Date.now() + (o.killAfterMs ?? APP_KILL_AFTER_MS);
+            while (Date.now() < limit && signal(pid, 0))
+                await sleep(50);
+            signal(pid, 'SIGKILL');
+            for (let i = 0; i < 40 && signal(pid, 0); i++)
+                await sleep(25); // le SIGKILL n'est pas instantané : le groupe disparu, pas seulement signalé
+        }
+        finally {
+            release(); // après l'arrêt de l'application seulement : l'autre vague ne trouve pas un port encore tenu
+        }
+    };
+    live.add(stop);
+    for (;;) {
+        if (await responds(o.url)) {
+            if (signal(pid, 0))
+                return { state: { kind: 'ready' }, stop };
+            gone.why ??= 'la commande s\'est arrêtée alors que l\'URL répond (autre processus ?)'; // la réponse n'est pas la nôtre
+            break;
+        }
+        if (gone.why || Date.now() >= deadline)
+            break;
+        await sleep(o.every ?? 500);
+    }
+    const why = gone.why ?? `l'URL n'a pas répondu en ${Math.round(available / 1000)} s`;
+    await stop();
+    return { state: { kind: 'unverified', cause: `${why}. Fin du journal :\n${tail(o.log)}` }, stop: none };
+}

package/dist/orchestrate/briefs.js

@@ -4,7 +4,23 @@ import { fileURLToPath } from 'node:url';
 import { RafError } from '../plan.js';
 /** Gabarits livrés avec le paquet (à la racine, à côté de dist/ et src/). */
 export const TEMPLATES_DIR = fileURLToPath(new URL('../../templates/orchestrate', import.meta.url));
+/** Consigne d'implémentation d'un lot `visible` : son entrée Nouveautés (convention de `cadence news`, voir le README). */
+export function newsText(lot, captureDir) {
+    return [
+        `This lot is visible: write its News entry. Run \`cadence news new ${lot}\` (it creates \`docs/nouveautes/<date>-<slug>.md\`), then write the text in terms of what changes for the user, factual (what the user sees or can now do, no implementation detail, no promise).`,
+        `The entry's title is user-side: \`cadence news new\` takes the lot's public title when it has one; otherwise rewrite the title in the user's words with \`--title\` (never the internal title of the lot).`,
+        captureDir
+            ? `Add a screenshot of the result: copy it into \`docs/nouveautes/captures/\` and list it under \`captures:\` (a Playwright capture lands in the wave's output directory, outside the repository: \`${captureDir}\`, which this session may read; the file you keep for the entry is the one exception, copied into \`docs/nouveautes/captures/\`); if a screenshot makes no sense (or the app cannot be run), write \`nocapture: <reason>\` instead.`
+            : `Add a screenshot of the result: save it under the OS temp directory (never inside the repository), then copy it into \`docs/nouveautes/captures/\` and list it under \`captures:\` (the file you keep for the entry is the one exception to "nothing inside the repository"); if a screenshot makes no sense (or the app cannot be run), write \`nocapture: <reason>\` instead.`,
+        'Commit the entry with the lot (`cadence news check` must pass).',
+    ].join('\n');
+}
+/** Consigne des briefs de correction d'un lot `visible` : où la vague range les captures Playwright (même dossier que l'étape implement). */
+export function capturesText(captureDir) {
+    return `Playwright captures of this wave land in \`${captureDir}\` (outside the repository; this session may read it): a screenshot a finding asks for is copied from there into \`docs/nouveautes/captures/\`.`;
+}
 const FILES = {
+    precheck: 'precheck.md',
     implement: 'implement.md',
     fix: 'fix.md',
     'fix-minors': 'fix-minors.md',

package/dist/orchestrate/command.js

@@ -6,20 +6,28 @@ 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 { acquireSlot, cadenceHome, liveSlots, liveWaves, registerWave, unregisterWave } from './registry.js';
-import { loadTemplates, objective, renderBrief } from './briefs.js';
-import { Budget, MAX_PASSES, countInterrupted } from './cycle.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 { excludeState, lotKey, lotSlug, 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`. */
@@ -37,10 +45,12 @@ export function parseMaxSessions(text, what = '--max-sessions') {
         throw new RafError(`${what} invalide : ${text} (entier ≥ 1)`);
     return Number(text);
 }
-const LOT_LIKE = /^(?:[\w.-]+:)?[A-Za-z]+\d+(?:@\w+)?$/;
+// 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./-]*|[A-Za-z]+\d+)(?:@\w+)?$/;
 const MODELS = ['sonnet', 'opus', 'haiku'];
 function lotArg(text) {
-    const m = /^(?:([\w.-]+):)?([\w.-]+?)(?:@(\w+))?$/.exec(text);
+    // le premier « : » sépare le projet du lot, un « @ » final le modèle ; le lot garde ses « / » (L120)
+    const m = /^(?:([\w.-]+):)?([\w.-][\w./-]*?)(?:@(\w+))?$/.exec(text);
     if (!m)
         throw new RafError(`lot invalide : ${text} (projet:lot, lot, projet:lot@haiku)`);
     if (m[3] && !MODELS.includes(m[3]))
@@ -48,7 +58,7 @@ function lotArg(text) {
     return { project: m[1], lot: m[2], model: m[3] };
 }
 export function parseOrchestrateArgs(argv) {
-    const a = { lots: [], dryRun: false, answers: [] };
+    const a = { lots: [], dryRun: false, watch: false, answers: [] };
     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];
@@ -65,6 +75,10 @@ export function parseOrchestrateArgs(argv) {
                 i++;
             a[t === '--status' ? 'status' : 'resume'] = v ?? true;
         }
+        else if (t === '--watch')
+            a.watch = true;
+        else if (t === '--interval')
+            a.interval = parseMaxSessions(value(t), '--interval');
         else if (t === '--budget')
             a.budget = parseBudget(value(t));
         else if (t === '--max-sessions')
@@ -85,7 +99,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 };
 }
@@ -182,9 +196,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 };
@@ -218,26 +241,40 @@ 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, 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: 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 file = join(tmp, `${lotSlug(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>/${lotSlug(l.project, l.lot)}/playwright)` : 'aucun'}`);
         }
     }
 }
@@ -263,6 +300,21 @@ function liveLines() {
         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;
 }
+/** 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;
+/** Ce que `--status` montre à un instant : les vagues vivantes, puis le tableau (absent si seules les vagues vivantes comptent). */
+function statusView(args, launch) {
+    const store = typeof args.status === 'string' ? RunStore.find(launch, args.status) : RunStore.last(launch);
+    const live = liveLines();
+    if (!store && live.length && args.status === true)
+        return { live, running: true };
+    if (!store)
+        throw new RafError(typeof args.status === 'string' ? `vague inconnue : ${args.status}` : '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 = typeof args.status === 'string' ? liveWaves(cadenceHome()).some((w) => w.wave === store.readWave().id) : live.length > 0;
+    return { live, table: renderTable(store.readWave(), store.lots()), running };
+}
 /** 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à`);
@@ -273,26 +325,48 @@ export async function orchestrate(argv, io, deps) {
     const args = parseOrchestrateArgs(argv);
     const launch = io.cwd;
     const today = io.env.RAF_TODAY && isDay(io.env.RAF_TODAY) ? io.env.RAF_TODAY : toDay(io.now());
+    if (args.watch && args.status === undefined)
+        throw new RafError('--watch s\'utilise avec --status');
+    if (args.interval !== undefined && !args.watch)
+        throw new RafError('--interval s\'utilise avec --status --watch');
     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)
+        if (!args.watch) {
+            const { live, table } = statusView(args, launch);
+            for (const line of live)
+                io.out(line);
+            if (!table)
+                return 0; // sans identifiant : les vagues vivantes suffisent
+            if (live.length)
+                io.out('');
+            for (const line of table)
+                io.out(line);
+            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)));
+        for (;;) {
+            const { live, table, running } = statusView(args, launch);
+            io.out(CLEAR_SCREEN);
+            for (const line of live)
+                io.out(line);
+            if (table) {
+                if (live.length)
+                    io.out('');
+                for (const line of table)
+                    io.out(line);
+            }
+            if (!running)
+                return 0;
             io.out('');
-        for (const line of renderTable(store.readWave(), store.lots()))
-            io.out(line);
-        return 0;
+            io.out(`rafraîchi toutes les ${args.interval ?? DEFAULT_WATCH_INTERVAL} s — Ctrl-C pour quitter`);
+            await sleep((args.interval ?? DEFAULT_WATCH_INTERVAL) * 1000);
+        }
     }
     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] [--max-sessions 2] [--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] [--watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"]');
     const refusals = [];
     const targets = resolveTargets(args, io, refusals);
     const pre = await preflight(args, targets, io, deps, launch);
@@ -312,13 +386,42 @@ export async function orchestrate(argv, io, deps) {
         dryRun(pre.lots, io, deps, budget, id);
         return 0;
     }
-    const store = RunStore.reserve(launch, args.wave ?? defaultWaveBase(io), { exact: args.wave !== undefined });
+    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);
     // 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 = () => {
@@ -326,6 +429,12 @@ export async function orchestrate(argv, io, deps) {
             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;
@@ -434,8 +543,9 @@ async function execute(wave, lots, store, io, deps, today, cap, 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')
@@ -473,10 +583,16 @@ async function execute(wave, lots, store, io, deps, today, cap, 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();
@@ -521,11 +637,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)
@@ -566,6 +698,9 @@ async function resume(args, io, deps, launch, today) {
 /** 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: () => {
@@ -579,6 +714,7 @@ export function realOrchestrateDeps(env) {
             }
         },
         agentsDir: AGENTS_DIR,
+        snapshot: child ? undefined : { packageRoot: PACKAGE_ROOT, reexec: spawnReexec },
         claudeHome: env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'),
     };
 }