@sylad/cadence 0.10.1 → 0.12.0

package/dist/orchestrate/launch.js

@@ -1,22 +1,58 @@
 import { spawn } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { delimiter, join, resolve } from 'node:path';
 import { parse } from 'yaml';
 import { RafError } from '../plan.js';
 import { isQuotaMessage, lacksStructuredOutput, parseSession, salvageUsage, sumTokens, tokensOf } from './result.js';
+/**
+ * Serveurs MCP d'une étape : Playwright pour `ux` et, sur un lot `visible`, pour `implement` et `fix` (fix-minors compris) ;
+ * et `review-small` d'un petit lot visible (sa seule revue d'ergonomie) ; rien pour `review`, ni pour un lot sans écran.
+ * Sorties dans `outputDir`, hors du dépôt.
+ */
+export function mcpServersFor(kind, visible, outputDir, small = false) {
+    if (!(kind === 'ux' || (visible && (kind === 'implement' || kind === 'fix' || (kind === 'review-small' && small)))))
+        return {};
+    return { playwright: { command: 'npx', args: ['-y', '@playwright/mcp@latest', '--output-dir', outputDir] } };
+}
+/** Dossier de sortie du Playwright MCP d'un lot : `<lotDir>/playwright`, chemin absolu. */
+export function playwrightDir(lotDir) {
+    return join(resolve(lotDir), 'playwright');
+}
+/** Écrit `<lotDir>/mcp-<étape>.json` (et, si Playwright est chargé, le dossier `playwright/`) ; rend le chemin absolu du fichier. */
+export function writeMcpConfig(lotDir, kind, visible, small = false) {
+    const dir = resolve(lotDir);
+    const out = playwrightDir(dir);
+    const servers = mcpServersFor(kind, visible, out, small);
+    if (servers.playwright)
+        mkdirSync(out, { recursive: true });
+    const file = join(dir, `mcp-${kind}.json`);
+    writeFileSync(file, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`);
+    return file;
+}
 /** Outils interdits à toute session : pas de sous-agent, pas de push, de livraison ni de verdict. */
 export const DISALLOWED = ['Agent', 'Bash(git push:*)', 'Bash(cadence deliver:*)', 'Bash(raf done:*)', 'Bash(raf review:*)', 'Bash(raf ux:*)'];
+/** Outils MCP du serveur Playwright, par le préfixe du serveur (sonde réelle du 07-10 : `mcp__playwright` expose tous les `browser_*`). */
+export const PLAYWRIGHT_TOOLS = 'mcp__playwright';
+/** Agents passés à `--agents` : l'agent d'une étape qui charge Playwright, s'il a une liste d'outils, y gagne les outils du serveur (sinon il ne peut pas l'appeler). */
+function agentsFor(spec, agents) {
+    const a = spec.agent ? agents[spec.agent] : undefined;
+    if (!spec.playwright || !spec.agent || !a?.tools)
+        return agents;
+    return { ...agents, [spec.agent]: { ...a, tools: [...a.tools, PLAYWRIGHT_TOOLS] } };
+}
 export function buildArgs(spec, agents) {
     const args = ['-p', spec.brief, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model];
     if (spec.agent) {
         if (!agents[spec.agent])
             throw new RafError(`agent introuvable dans le paquet : ${spec.agent}`);
-        args.push('--agents', JSON.stringify(agents), '--agent', spec.agent);
+        args.push('--agents', JSON.stringify(agentsFor(spec, agents)), '--agent', spec.agent);
     }
     args.push('--session-id', spec.sessionId, '--permission-mode', spec.permissionMode);
     for (const d of spec.addDirs)
         args.push('--add-dir', d);
     args.push('--disallowedTools', ...DISALLOWED);
+    if (spec.mcpConfig)
+        args.push('--strict-mcp-config', '--mcp-config', spec.mcpConfig);
     return args;
 }
 /** Définitions d'agents du paquet (`agents/*.md`) au format de --agents. */
@@ -49,12 +85,14 @@ export function buildRetryArgs(spec, sessionId, agents) {
     if (spec.agent) {
         if (!agents[spec.agent])
             throw new RafError(`agent introuvable dans le paquet : ${spec.agent}`);
-        args.push('--agents', JSON.stringify(agents), '--agent', spec.agent);
+        args.push('--agents', JSON.stringify(agentsFor(spec, agents)), '--agent', spec.agent);
     }
     args.push('--resume', sessionId, '--permission-mode', spec.permissionMode);
     for (const d of spec.addDirs)
         args.push('--add-dir', d);
     args.push('--disallowedTools', ...DISALLOWED);
+    if (spec.mcpConfig)
+        args.push('--strict-mcp-config', '--mcp-config', spec.mcpConfig);
     return args;
 }
 /**
@@ -64,7 +102,7 @@ export function buildRetryArgs(spec, sessionId, agents) {
  * s'ajoutent à ceux de la session ; toujours rien après elle, c'est l'échec habituel.
  */
 export async function runSession(spec, deps) {
-    const launch = (args) => deps.claude(args, { cwd: spec.cwd, env: { CADENCE_ORCHESTRATED: spec.wave }, timeoutMs: spec.timeoutMs, onSpawn: deps.onSpawn });
+    const launch = (args) => deps.claude(args, { cwd: spec.cwd, env: { CADENCE_ORCHESTRATED: spec.wave, ...(spec.nodeBin || spec.toolBin ? { PATH: [spec.toolBin, spec.nodeBin, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {}) }, timeoutMs: spec.timeoutMs, onSpawn: deps.onSpawn });
     const out = await launch(buildArgs(spec, deps.agents));
     const first = classify(out);
     const missing = first.kind === 'failed' && !out.timedOut && out.code === 0 ? lacksStructuredOutput(out.stdout) : null;

package/dist/orchestrate/lock.js

@@ -1,6 +1,19 @@
 import { linkSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { processStart } from '../proc.js';
 import { pidAlive } from '../state.js';
+/**
+ * Le porteur vit encore : son pid existe ET, quand l'heure de démarrage est connue des deux côtés, c'est la même.
+ * Un pid repris par un autre processus est un porteur mort.
+ */
+export function holderAlive(pid, start) {
+    if (!pidAlive(pid))
+        return false;
+    if (!start)
+        return true;
+    const now = processStart(pid);
+    return now === null || now === start;
+}
 /** Nom du verrou d'orchestration d'un dépôt, dans l'état commun aux worktrees (celui de `deliver`). */
 export const REPO_LOCK = 'orchestrate.lock';
 function read(file) {
@@ -15,13 +28,13 @@ function read(file) {
     }
     try {
         const raw = JSON.parse(text);
-        return { pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), ageMs };
+        return { pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), start: raw.start === undefined ? undefined : String(raw.start), ageMs };
     }
     catch {
         return { pid: 0, wave: '?', started: '?', unreadable: true, ageMs };
     }
 }
-const alive = (l) => (l.unreadable ? l.ageMs < 5_000 : pidAlive(l.pid));
+const alive = (l) => (l.unreadable ? l.ageMs < 5_000 : holderAlive(l.pid, l.start));
 /** Le verrou s'il est tenu par un processus vivant, sinon null (absent ou périmé). */
 export function activeLock(file) {
     const l = read(file);
@@ -31,7 +44,8 @@ export function activeLock(file) {
  * Pose le verrou (lien vers un fichier complet : atomique). Un verrou de pid mort est retiré — `stale` le
  * dit pour avertir. `held` : le porteur vivant quand la pose échoue.
  */
-export function takeLock(file, lock) {
+export function takeLock(file, given) {
+    const lock = { ...given, start: given.start ?? processStart(given.pid) ?? undefined };
     let stale;
     for (let attempt = 0; attempt < 3; attempt++) {
         const tmp = join(dirname(file), `.orchestrate.lock.${lock.pid}.${Date.now()}.${attempt}.tmp`);
@@ -60,8 +74,8 @@ export function takeLock(file, lock) {
             continue;
         }
         const now = read(aside);
-        if (now && now.pid === seen.pid && now.wave === seen.wave && now.started === seen.started) {
-            stale = { pid: seen.pid, wave: seen.wave, started: seen.started };
+        if (now && now.pid === seen.pid && now.wave === seen.wave && now.started === seen.started && now.start === seen.start) {
+            stale = { pid: seen.pid, wave: seen.wave, started: seen.started, start: seen.start };
             rmSync(aside, { force: true });
         }
         else {

package/dist/orchestrate/node-env.js

@@ -0,0 +1,77 @@
+import { accessSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, symlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const realNodeFs = {
+    read: (f) => (existsSync(f) ? readFileSync(f, 'utf8') : null),
+    list: (d) => (existsSync(d) ? readdirSync(d) : []),
+    executable: (f) => {
+        try {
+            accessSync(f, constants.X_OK);
+            return statSync(f).isFile();
+        }
+        catch {
+            return false;
+        }
+    },
+};
+/** Dossier des versions de nvm : `$NVM_DIR/versions/node`, par défaut `~/.nvm/versions/node`. */
+export function nvmVersionsDir(env, home = homedir()) {
+    return join(env.NVM_DIR || join(home, '.nvm'), 'versions', 'node');
+}
+const parts = (v) => v.split('.').map(Number);
+const cmp = (a, b) => {
+    const x = parts(a);
+    const y = parts(b);
+    for (let i = 0; i < 3; i++)
+        if ((x[i] ?? 0) !== (y[i] ?? 0))
+            return (x[i] ?? 0) - (y[i] ?? 0);
+    return 0;
+};
+/**
+ * Node demandé par le `.nvmrc` à la racine d'un projet, résolu dans les versions installées de nvm : la plus haute
+ * dont le numéro commence par celui du fichier (`22`, `v22`, `22.22`, `v22.22.3`) et qui a un node exécutable. Pas de .nvmrc : rien à changer.
+ * .nvmrc illisible pour nous (`lts/*`, alias) ou version absente : refus nommant ce qui est demandé et où on a cherché
+ * — jamais de repli silencieux sur le node par défaut.
+ */
+export function resolveNode(repo, versionsDir, fs = realNodeFs) {
+    const raw = fs.read(join(repo, '.nvmrc'));
+    if (raw === null)
+        return { kind: 'none' };
+    const wanted = raw.trim();
+    const m = /^v?(\d+(?:\.\d+){0,2})$/.exec(wanted);
+    if (!m)
+        return { kind: 'missing', message: `.nvmrc « ${wanted} » : version non résoluble (seuls 22, v22, 22.22, v22.22.3 sont compris)` };
+    const want = m[1];
+    const matching = fs
+        .list(versionsDir)
+        .map((n) => /^v(\d+\.\d+\.\d+)$/.exec(n)?.[1])
+        .filter((v) => !!v && (v === want || v.startsWith(`${want}.`)))
+        .sort(cmp);
+    if (matching.length === 0)
+        return { kind: 'missing', message: `.nvmrc ${wanted} : aucun Node installé correspondant dans ${versionsDir}` };
+    // Une version dont le bin n'a pas de node exécutable (install vide ou cassée) donnerait un dossier de liens vide,
+    // donc un repli silencieux sur le node par défaut : on l'écarte, et une plus basse valide peut être retenue.
+    const found = matching.filter((v) => fs.executable(join(versionsDir, `v${v}`, 'bin', 'node')));
+    if (found.length === 0) {
+        const names = matching.map((v) => `v${v}`).join(', ');
+        return { kind: 'missing', message: `.nvmrc ${wanted} : ${names} trouvée(s) dans ${versionsDir} mais sans node exécutable dans bin (installation vide ou cassée)` };
+    }
+    const best = found[found.length - 1];
+    const skipped = matching.filter((v) => cmp(v, best) > 0).reverse().map((v) => `v${v}`);
+    return { kind: 'ok', version: `v${best}`, wanted, bin: join(versionsDir, `v${best}`, 'bin'), ...(skipped.length ? { skipped } : {}) };
+}
+/** Les seuls binaires d'une version de Node que les sessions voient : le reste de son bin (raf, cadence, claude… installés en global) ne doit pas masquer ceux du PATH. */
+export const NODE_LINKED = ['node', 'npm', 'npx', 'corepack'];
+/**
+ * Dossier de liens `<runDir>/node-bin/<version>/` : un lien vers chacun des `NODE_LINKED` présents dans `bin`. Recréé à
+ * chaque appel (départ et reprise), donc idempotent. C'est lui, et non `bin`, qui passe en tête du PATH des sessions.
+ */
+export function linkNodeBin(runDir, version, bin) {
+    const dir = join(runDir, 'node-bin', version);
+    rmSync(dir, { recursive: true, force: true });
+    mkdirSync(dir, { recursive: true });
+    for (const name of NODE_LINKED)
+        if (existsSync(join(bin, name)))
+            symlinkSync(join(bin, name), join(dir, name));
+    return dir;
+}

package/dist/orchestrate/pool.js

@@ -1,10 +1,11 @@
 import { runLot } from './cycle.js';
 import { lotKey } from './state.js';
-/** Deux sessions au plus en même temps (imposé ici, pas de --parallel) : deux dépôts à la fois. */
+/** Valeur de repli de `runPool` quand l'appelant ne donne pas de plafond ; le réglage réel est DEFAULT_MAX_SESSIONS, `--max-sessions` ou CADENCE_MAX_SESSIONS (command.ts). */
 export const SLOTS = 2;
 /**
- * Ordonnanceur : une file par dépôt, les lots d'un dépôt l'un après l'autre dans l'ordre donné, deux dépôts
- * au plus en parallèle. Le budget, le quota et les incidents sont vérifiés par le cycle avant chaque session.
+ * Ordonnanceur : une file par dépôt, les lots d'un dépôt l'un après l'autre dans l'ordre donné, `slots` dépôts
+ * au plus en parallèle (le plafond global des sessions de toutes
+ * les vagues est tenu par command.ts). Le budget, le quota et les incidents sont vérifiés par le cycle avant chaque session.
  */
 export async function runPool(ctxs, slots = SLOTS, known = []) {
     const queues = new Map();

package/dist/orchestrate/registry.js

@@ -0,0 +1,120 @@
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { processStart } from '../proc.js';
+import { activeLock, holderAlive, releaseLock, takeLock } from './lock.js';
+/**
+ * État commun à toutes les vagues de l'utilisateur, quel que soit le dossier d'où elles partent : le registre
+ * des vagues vivantes (`waves/<pid>.json`) et les créneaux de sessions simultanées (`slots/slot-<n>.lock`).
+ * Les verrous de DÉPÔT restent dans le dépôt (`.git/cadence/orchestrate.lock`).
+ */
+export function cadenceHome(env = process.env) {
+    return env.CADENCE_HOME || join(env.HOME || homedir(), '.cadence', 'orchestrate');
+}
+const wavesDir = (home) => join(home, 'waves');
+const slotsDir = (home) => join(home, 'slots');
+function readWave(file) {
+    try {
+        const raw = JSON.parse(readFileSync(file, 'utf8'));
+        const w = { pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), cwd: String(raw.cwd), repos: Array.isArray(raw.repos) ? raw.repos.map(String) : [] };
+        if (raw.cap !== undefined)
+            w.cap = Number(raw.cap);
+        if (raw.start !== undefined)
+            w.start = String(raw.start);
+        return w;
+    }
+    catch {
+        return null;
+    }
+}
+/** Les vagues dont le processus vit encore. */
+export function liveWaves(home) {
+    let names;
+    try {
+        names = readdirSync(wavesDir(home)).filter((n) => n.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names) {
+        const w = readWave(join(wavesDir(home), n));
+        if (w && holderAlive(w.pid, w.start))
+            out.push(w);
+    }
+    return out.sort((a, b) => a.started.localeCompare(b.started));
+}
+/** Inscrit la vague ; écarte au passage les entrées de processus morts (les `.tmp` d'une inscription en cours ne sont pas touchés). */
+export function registerWave(home, given) {
+    const w = { ...given, start: given.start ?? processStart(given.pid) ?? undefined };
+    mkdirSync(wavesDir(home), { recursive: true });
+    for (const n of readdirSync(wavesDir(home))) {
+        if (!n.endsWith('.json'))
+            continue;
+        const old = readWave(join(wavesDir(home), n));
+        if (!old || !holderAlive(old.pid, old.start))
+            rmSync(join(wavesDir(home), n), { force: true });
+    }
+    const file = join(wavesDir(home), `${w.pid}.json`);
+    writeFileSync(`${file}.tmp`, JSON.stringify(w));
+    renameSync(`${file}.tmp`, file);
+}
+export function unregisterWave(home, pid) {
+    rmSync(join(wavesDir(home), `${pid}.json`), { force: true });
+}
+/** Les sessions en cours en ce moment, toutes vagues confondues. */
+export function liveSlots(home) {
+    let names;
+    try {
+        names = readdirSync(slotsDir(home)).filter((n) => /^slot-\d+\.lock$/.test(n));
+    }
+    catch {
+        return [];
+    }
+    return names.map((n) => activeLock(join(slotsDir(home), n))).filter((l) => l !== null);
+}
+/** Index de créneau le plus haut essayé : le plafond de chaque vague est le sien, les fichiers sont communs. */
+const MAX_SLOT_INDEX = 64;
+/** Intervalle des rappels d'attente dans le journal. */
+const WAIT_REPORT_MS = 60_000;
+/**
+ * Attend que le nombre de sessions vivantes, TOUTES vagues confondues et quel que soit l'index de leur créneau,
+ * soit sous `cap` (le plafond de cette vague), puis prend le premier créneau libre (un pid mort est repris) et
+ * rend sa libération. Chaque vague applique SON plafond au total commun : avec des plafonds différents, la
+ * vague au plafond le plus haut peut porter le total au-dessus du plafond de l'autre, qui attend alors.
+ * Deux vagues qui prennent en même temps se départagent au recomptage : si le total dépasse `cap` une fois
+ * le créneau pris, il est rendu et l'attente reprend.
+ *
+ * `onWait(holders, waitedMs)` : appelé quand on commence à attendre (0 ms), puis toutes les minutes.
+ * `onGot(waitedMs)` : appelé à l'obtention, seulement si on a attendu.
+ */
+export async function acquireSlot(home, cap, opts) {
+    mkdirSync(slotsDir(home), { recursive: true });
+    const now = opts.now ?? Date.now; // injectable : les tests pilotent l'horloge
+    const t0 = now();
+    let reportedAt = null;
+    const pollMs = opts.pollMs ?? 2000;
+    const live = opts.slots ?? liveSlots; // injectable : les tests simulent une vague qui prend un créneau entre les deux comptées
+    for (;;) {
+        if (live(home).length < cap) {
+            for (let k = 0; k < MAX_SLOT_INDEX; k++) {
+                const file = join(slotsDir(home), `slot-${k}.lock`);
+                const got = takeLock(file, { pid: process.pid, wave: opts.wave, started: new Date().toISOString() });
+                if (!got.ok)
+                    continue;
+                if (live(home).length <= cap) {
+                    if (reportedAt !== null)
+                        opts.onGot?.(now() - t0);
+                    return () => releaseLock(file, process.pid);
+                }
+                releaseLock(file, process.pid); // pris à plusieurs en même temps : on rend, on retente
+                break;
+            }
+        }
+        if (reportedAt === null || now() - reportedAt >= (opts.reportMs ?? WAIT_REPORT_MS)) {
+            reportedAt = now();
+            opts.onWait?.(live(home), reportedAt - t0);
+        }
+        await new Promise((r) => setTimeout(r, pollMs + Math.random() * pollMs * 0.25));
+    }
+}

package/dist/orchestrate/schemas.js

@@ -30,7 +30,13 @@ export const REVIEW_SCHEMA = {
     },
     required: ['bloquants', 'majeurs', 'mineurs', 'constats', 'sousTaches', 'nonVerifie', 'verdict'],
 };
-export const schemaFor = (kind) => (kind === 'implement' || kind === 'fix' ? WORK_SCHEMA : REVIEW_SCHEMA);
+/** Sortie du contrôle préalable : `dejaPresent` vaut « oui » (rien à faire), « partiel » ou « non ». */
+export const PRECHECK_SCHEMA = {
+    type: 'object',
+    properties: { dejaPresent: { type: 'string', enum: ['oui', 'partiel', 'non'] }, preuves: strings, resume: str },
+    required: ['dejaPresent', 'preuves', 'resume'],
+};
+export const schemaFor = (kind) => (kind === 'precheck' ? PRECHECK_SCHEMA : kind === 'implement' || kind === 'fix' ? WORK_SCHEMA : REVIEW_SCHEMA);
 /** Contrôle la forme d'une sortie structurée : un champ absent ou mal typé est une erreur nommée. */
 export function checkShape(value, schema) {
     if (!value || typeof value !== 'object' || Array.isArray(value))

package/dist/orchestrate/snapshot.js

@@ -0,0 +1,99 @@
+import { spawn } from 'node:child_process';
+import { chmodSync, cpSync, existsSync, mkdirSync, realpathSync, symlinkSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join, sep } from 'node:path';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+/** Racine du paquet en cours d'exécution (dist/orchestrate/ ou src/orchestrate/ → deux niveaux au-dessus). */
+export const PACKAGE_ROOT = fileURLToPath(new URL('../..', import.meta.url));
+/** Posée par le processus relancé depuis la copie : il tourne déjà sur l'instantané, il n'en refait pas. */
+export const SNAPSHOT_ENV = 'CADENCE_SNAPSHOT';
+/** Vague déjà réservée (et copiée) par le processus d'origine : le processus relancé la reprend telle quelle. */
+export const RESERVED_ENV = 'CADENCE_WAVE_RESERVED';
+/** Environnement sans les variables de relance : le fils les lit, il ne les transmet ni aux sessions ni aux commandes du projet. */
+export function withoutLaunchVars(env) {
+    const { [SNAPSHOT_ENV]: _s, [RESERVED_ENV]: _r, ...rest } = env;
+    return rest;
+}
+const real = (p) => {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+};
+/** Vrai fils : CADENCE_SNAPSHOT désigne CE paquet (la copie qui s'exécute). Une valeur héritée d'une autre vague ne compte pas. */
+export const isSnapshotChild = (env, root = PACKAGE_ROOT) => !!env[SNAPSHOT_ENV] && real(env[SNAPSHOT_ENV]) === real(root);
+/** Entrées de `package.json#bin` : nom de commande → fichier de `bin/`. */
+const BIN_ENTRIES = { raf: 'raf.js', cadence: 'cadence.js' };
+/** Ce du paquet qui sert à l'exécution d'une vague ; node_modules est lié, jamais copié. */
+const COPIED = ['bin', 'dist', 'templates', 'agents', 'skills', 'package.json'];
+export const toolDirOf = (waveDir) => join(waveDir, 'tool');
+/** `<vague>/tool/bin` si la vague a un instantané (entrées `raf` et `cadence`), sinon rien : le PATH de la session ne change pas. */
+export const toolBinOf = (waveDir) => (existsSync(join(toolDirOf(waveDir), 'bin', 'raf')) ? join(toolDirOf(waveDir), 'bin') : undefined);
+/** Refus de prendre l'instantané (avant toute copie) : le message dit quoi faire. */
+export class SnapshotRefusal extends Error {
+}
+/**
+ * Le `node_modules` où les dépendances du paquet se résolvent réellement : celui du paquet, ou — installation npx ou
+ * locale — un dossier parent. On résout `yaml` depuis le paquet et on remonte jusqu'à son `node_modules`.
+ */
+export function resolveModulesDir(packageRoot) {
+    let file;
+    try {
+        file = createRequire(join(packageRoot, 'package.json')).resolve('yaml');
+    }
+    catch {
+        throw new SnapshotRefusal(`dépendances introuvables : « yaml » ne se résout pas depuis ${packageRoot} (installation incomplète ?) — instantané impossible, aucune vague lancée`);
+    }
+    const marker = `${sep}node_modules${sep}`;
+    const at = file.lastIndexOf(marker);
+    if (at < 0)
+        throw new SnapshotRefusal(`dépendances introuvables : « yaml » résolu hors de tout node_modules (${file}) — instantané impossible, aucune vague lancée`);
+    return file.slice(0, at + marker.length - 1);
+}
+/** Instantané du paquet dans `<vague>/tool/` : le code, les gabarits et les agents d'une vague ne bougent plus. */
+export function takeSnapshot(waveDir, packageRoot) {
+    const modules = resolveModulesDir(packageRoot); // avant toute copie
+    const tool = toolDirOf(waveDir);
+    mkdirSync(tool, { recursive: true });
+    for (const name of COPIED) {
+        const from = join(packageRoot, name);
+        if (existsSync(from))
+            cpSync(from, join(tool, name), { recursive: true });
+    }
+    symlinkSync(modules, join(tool, 'node_modules'), 'dir');
+    // Comme npm à l'installation : `raf` et `cadence` sont les bin/*.js de la copie (shebang `env node` conservé).
+    for (const [name, target] of Object.entries(BIN_ENTRIES)) {
+        const js = join(tool, 'bin', target);
+        if (!existsSync(js))
+            continue;
+        chmodSync(js, 0o755);
+        symlinkSync(target, join(tool, 'bin', name));
+    }
+    return tool;
+}
+export const snapshotExists = (waveDir) => existsSync(join(toolDirOf(waveDir), 'bin', 'cadence.js'));
+/** Relance réelle : un processus node sur la copie, signaux transmis, code de sortie rendu. */
+export function spawnReexec(toolDir, argv, env, sink) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [join(toolDir, 'bin', 'cadence.js'), 'orchestrate', ...argv], { cwd: sink.cwd, env: { ...env, [SNAPSHOT_ENV]: toolDir }, stdio: ['inherit', 'pipe', 'pipe'] });
+        const lines = [createInterface({ input: child.stdout }).on('line', sink.out), createInterface({ input: child.stderr }).on('line', sink.err)];
+        const drained = Promise.all(lines.map((l) => new Promise((r) => l.once('close', r))));
+        const relay = (sig) => () => child.kill(sig);
+        const handlers = ['SIGINT', 'SIGTERM', 'SIGHUP'].map((s) => [s, relay(s)]);
+        for (const [s, h] of handlers)
+            process.on(s, h);
+        child.once('error', reject);
+        child.once('close', async (code, signal) => {
+            for (const [s, h] of handlers)
+                process.off(s, h);
+            await drained;
+            // Le fils est mort d'un signal (il se nettoie puis se le renvoie) : on meurt du même, comme sans instantané.
+            if (signal)
+                process.kill(process.pid, signal);
+            resolve(code ?? 1);
+        });
+    });
+}

package/dist/orchestrate/state.js

@@ -22,6 +22,28 @@ export class RunStore {
         this.dir = join(launchDir, '.cadence', 'runs', id);
         mkdirSync(this.dir, { recursive: true });
     }
+    /**
+     * Réserve l'identifiant de vague : `mkdir` sans `recursive` échoue (EEXIST) si une autre vague l'a pris, même à
+     * la même seconde. Sans identifiant demandé, on passe au suffixe suivant (`-2`, `-3`…) ; avec un identifiant
+     * demandé, null (refus : jamais deux vagues dans le même dossier d'état).
+     */
+    static reserve(launchDir, base, opts = {}) {
+        mkdirSync(RunStore.runsDir(launchDir), { recursive: true });
+        for (let i = 1;; i++) {
+            const id = i === 1 ? base : `${base}-${i}`;
+            try {
+                mkdirSync(join(RunStore.runsDir(launchDir), id));
+            }
+            catch (e) {
+                if (e.code !== 'EEXIST')
+                    throw e;
+                if (opts.exact)
+                    return null;
+                continue;
+            }
+            return new RunStore(launchDir, id);
+        }
+    }
     static runsDir(launchDir) {
         return join(launchDir, '.cadence', 'runs');
     }

package/dist/orchestrate/table.js

@@ -18,7 +18,15 @@ function review(l) {
     const fixes = l.pass === 0 ? '' : ` après ${l.pass} correction${l.pass > 1 ? 's' : ''}`;
     if (l.status === 'ready')
         return `conforme${fixes}`;
-    return `non conforme (${l.code.bloquants} bloquant, ${l.code.majeurs} majeur)`;
+    const verdict = l.code.conforme ? 'conforme' : `non conforme (${l.code.bloquants} bloquant, ${l.code.majeurs} majeur)`;
+    // Rendu, échoué ou suspendu pour une autre cause que la revue (dépôt sale, session coupée…) : la colonne ne présente pas
+    // un verdict de revue comme la cause ; elle donne le dernier verdict réel, la cause est dans les lignes sous le tableau.
+    const stopped = l.status === 'handed-back' || l.status === 'failed' || l.status === 'suspended' || l.status === 'question';
+    const last = l.steps[l.steps.length - 1];
+    const byReview = !l.code.conforme && !!last && last.status === 'ok' && (last.kind === 'review' || last.kind === 'review-small');
+    if (stopped && !byReview)
+        return `${verdict} (dernier verdict ; rendu pour une autre cause)`;
+    return verdict;
 }
 function ux(l) {
     if (!l.visible)
@@ -51,6 +59,8 @@ export function renderTable(wave, lots) {
     for (const l of lots) {
         if (l.uxNote)
             out.push(`${l.project}:${l.lot} — ${l.uxNote}`);
+        if (l.uxCaptures)
+            out.push(`${l.project}:${l.lot} — captures Playwright : ${l.uxCaptures}`);
         for (const w of l.warnings)
             out.push(`${l.project}:${l.lot} — ⚠ ${w}`);
         for (const x of l.choix ?? [])

package/dist/plan.js

@@ -122,6 +122,35 @@ export class Plan {
         }
         return { patterns, invalid };
     }
+    /** Commits acquittés (`raf ignore`) : exemptés de « sans lot » et d'« inconnu », par sha complet ou par sujet exact. */
+    get acknowledged() {
+        const raw = this.doc.get('acknowledged');
+        if (!isSeq(raw))
+            return [];
+        return raw.toJSON().flatMap((e) => {
+            const o = (e ?? {});
+            const sha = o.sha == null ? undefined : String(o.sha);
+            const subject = o.subject == null ? undefined : String(o.subject);
+            if (!sha && !subject)
+                return [];
+            return [{ sha, subject, date: String(o.date ?? ''), reason: o.reason == null ? undefined : String(o.reason) }];
+        });
+    }
+    /** Acquitte un commit : une ligne datée dans la section `acknowledged:` du plan. */
+    acknowledge(entry) {
+        this.writable();
+        // Déjà acquitté (même sha, ou même sujet pour une entrée par sujet) : on garde la première ligne et son motif.
+        if (this.acknowledged.some((a) => (entry.sha ? a.sha === entry.sha : a.sha === undefined && a.subject === entry.subject)))
+            return;
+        let list = this.doc.get('acknowledged');
+        if (!isSeq(list)) {
+            list = this.doc.createNode([]);
+            this.doc.set('acknowledged', list);
+        }
+        const node = this.doc.createNode(Object.fromEntries(Object.entries(entry).filter(([, v]) => v !== undefined)));
+        node.flow = true;
+        list.add(node);
+    }
     /** Fichier de configuration lu pour ce plan, null quand on n'en connaît pas (cadence.yaml à la racine alors). */
     get configFile() {
         return this.settings.config ?? null;

package/dist/proc.js

@@ -90,6 +90,25 @@ export function readProcs() {
     }
     return procs;
 }
+/** Heure de démarrage d'un processus (son identité : un pid se réutilise) ; null s'il est mort ou illisible. */
+export function processStart(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19] ?? null;
+    }
+    catch {
+        // pas de /proc (macOS) ou processus sorti : ps
+    }
+    try {
+        const out = execFileSync('ps', ['-p', String(pid), '-o', 'lstart='], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Âge au-delà duquel un relevé de secours (le relevé suivant a échoué) n'est plus cru : un pid y a pu être repris. */
 export const MAX_SNAPSHOT_AGE_MS = 1_000;
 /** Intervalle du relevé des descendants d'une commande de deliver pendant qu'elle tourne. */

package/dist/session.js

@@ -108,7 +108,7 @@ export function sessionStart(ctx, opts) {
         done.push(`${recent.orphans.length} commit(s) sans lot`);
     section(out, `Fait depuis ${opts.since}`, done);
     section(out, 'Récurrent', recurringByDue(lots, today).map((l) => `${l.id}  ${l.title} — ${dueLine(l, today)}`));
-    section(out, 'Écarts (raf check)', audit(plan, ctx.root, ctx.newsDir, today).map((i) => `✗ ${i.message}`));
+    section(out, 'Écarts (raf check)', audit(plan, ctx.root, ctx.newsDir, today).map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`));
     section(out, 'Dépôt', [repoLine(ctx.root).line]);
     section(out, 'Effets en production (cadence verify)', ctx.effects ?? []);
     section(out, 'Faits propres au projet', projectFacts(ctx, opts.since));
@@ -131,7 +131,7 @@ export function sessionClose(ctx, opts) {
     const quiet = plan.lots().filter((l) => l.status === 'doing' && !isRecurring(l) && !recent.byLot.has(l.id));
     section(out, 'Lots en cours', quiet.map((l) => `${l.id}  ${l.title} — aucun commit sur la période : ${plan.readonly ? "le fermer ou l'annoter avec l'outil du projet" : 'raf done ou raf note'}`));
     const issues = audit(plan, ctx.root, ctx.newsDir, today);
-    section(out, 'Écarts (raf check)', issues.map((i) => `✗ ${i.message}`));
+    section(out, 'Écarts (raf check)', issues.map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`));
     const repo = repoLine(ctx.root);
     const lock = lockStatus(ctx.shared);
     section(out, 'Dépôt', [repo.line, ...(lock ? [lock.line] : [])]);
@@ -149,7 +149,10 @@ export function sessionClose(ctx, opts) {
             section(out, "Nettoyage : parcours interrompu, rien n'est proposé", [e instanceof Error ? e.message : String(e)]);
         }
     }
-    const open = issues.length + repo.open + (lock?.live ? 1 : 0);
+    else {
+        out(`\n(aucun motif de nettoyage déclaré — exemple de session.clean, dans cadence.yaml : session: { clean: [ "tmp/*", "~/partage/capture-*.png" ], cleanDays: 7 } ; chemins relatifs à la racine ou absolus, cleanDays = âge minimal en jours)`);
+    }
+    const open = issues.filter((i) => !i.warning).length + repo.open + (lock?.live ? 1 : 0);
     out(open === 0 ? '\n✓ prêt à fermer' : `\n✗ pas fermé : ${open} point(s)`);
     return open === 0 ? 0 : 1;
 }