@sylad/cadence 1.41.0 → 1.43.0

package/dist/cli/session-commands.js

@@ -0,0 +1,152 @@
+// session start|close|next|context, et leur variante --all (L488, sorti de cli.ts).
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { readSessionConfig } from '../config.js';
+import { parseDeliverConfig } from '../deliver.js';
+import { defaultTarget, effectLines, realCheckDeps } from '../verify.js';
+import { gitRoot } from '../git.js';
+import { RafError } from '../plan.js';
+import { closeMemoryLines } from '../memory-index.js';
+import { findLeadDir, findProjects, readLeadContextThreshold } from '../lead.js';
+import { readHudContext } from '../hud-context.js';
+import { sessionClose, sessionStart } from '../session.js';
+import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from '../state.js';
+/**
+ * Reprise : lignes d'effets à rejouer, ou null quand il n'y a rien à vérifier (sans cadence.yaml, sans deliver,
+ * script sans verify) — la reprise reste alors synchrone. Ne lève jamais.
+ */
+function morningEffects(configPath, root) {
+    if (!existsSync(configPath))
+        return null;
+    const text = readFileSync(configPath, 'utf8');
+    if (!/^deliver\s*:/m.test(text))
+        return null;
+    try {
+        const config = parseDeliverConfig(text, configPath);
+        if (config.verify.length === 0)
+            return null;
+        const target = defaultTarget(root, config);
+        return effectLines(config, target.sha, realCheckDeps(root, { quiet: true }), target.note);
+    }
+    catch (e) {
+        return [`✗ ${e.message}`];
+    }
+}
+/** `session start|close --all [--depth n]` : la commande jouée dans chaque projet sous le dossier courant, une section par projet. */
+async function sessionAll(rest, values, io, run) {
+    const sub = rest[0];
+    if (!values.all)
+        throw new RafError('--depth demande --all');
+    // Chaque projet lit son propre plan : un plan ou une config imposés se retrouveraient dans toutes les sections.
+    const imposed = values.file !== undefined ? '--file' : values.config !== undefined ? '--config' : io.env.RAF_FILE !== undefined ? 'RAF_FILE' : null;
+    if (imposed)
+        throw new RafError(`${imposed} ne va pas avec --all : chaque projet lit son propre plan (lancer la commande dans le projet visé)`);
+    if (sub !== 'start' && sub !== 'close')
+        throw new RafError('--all ne va qu\'avec session start ou session close');
+    const depth = values.depth === undefined ? 1 : Number(values.depth);
+    if (!Number.isInteger(depth) || depth < 1)
+        throw new RafError(`--depth invalide : ${values.depth} (un entier ≥ 1)`);
+    if (values.idle !== undefined && !(Number.isInteger(Number(values.idle)) && Number(values.idle) >= 0))
+        throw new RafError(`--idle invalide : ${values.idle}`);
+    const projects = findProjects(io.cwd, depth);
+    if (projects.length === 0) {
+        io.out(`aucun projet sous ${io.cwd} (.cadence/raf.yaml, docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
+        return 0;
+    }
+    const argv = ['session', sub, ...(values.since === undefined ? [] : [`--since=${values.since}`]), ...(values.idle === undefined ? [] : ['--idle', values.idle])];
+    let worst = 0;
+    for (const dir of projects) {
+        io.out(`${dir === projects[0] ? '' : '\n'}## ${relative(io.cwd, dir)}`);
+        let code;
+        const top = gitRoot(dir);
+        if (top && realpathSync(top) !== realpathSync(dir)) {
+            // run() lirait le plan du dépôt parent : mieux vaut le dire que montrer le plan d'un autre projet.
+            io.out(`✗ ${relative(io.cwd, dir)} n'a pas son propre dépôt git (dépôt parent : ${top}) — lancer cadence dans ce dossier`);
+            worst = 2;
+            continue;
+        }
+        try {
+            code = await run(argv, { ...io, cwd: dir, err: (l) => io.out(`✗ ${l}`), notice: io.notice ?? io.err });
+        }
+        catch (e) {
+            io.out(`✗ ${e instanceof Error ? e.message : String(e)}`);
+            code = 2;
+        }
+        worst = Math.max(worst, code);
+    }
+    return worst;
+}
+/** Le contexte (et sa position par rapport à `lead.contextThreshold`, en tokens) de la session de `--session <id>`, sinon de `CLAUDE_CODE_SESSION_ID`, sinon (variable absente) de la seule session du dossier courant, tel que la bande cadence-hud le publie ; illisible = code 2, à lire comme « au seuil ». */
+function sessionContext(io, session) {
+    const r = readHudContext(io.env, io.now().getTime(), { cwd: io.cwd, session });
+    if (!r.ok)
+        throw new RafError(`session context : contexte illisible — ${r.reason} ; à traiter comme au seuil`);
+    io.out(`ctx ${Math.round(r.ctx.percent)} % (${r.ctx.tokens}/${r.ctx.window})`);
+    // Lancée d'un sous-projet, la commande lit le cadence.yaml du dossier du lead (L457) et nomme le dossier lu.
+    const leadDir = findLeadDir(io.cwd);
+    const threshold = readLeadContextThreshold(leadDir);
+    io.out(`seuil ${threshold} tokens : ${r.ctx.tokens >= threshold ? 'atteint' : 'sous le seuil'}${leadDir === io.cwd ? '' : ` (lu dans ${join(leadDir, 'cadence.yaml')})`}`);
+    return 0;
+}
+function session([sub, ...args], ctx, values) {
+    switch (sub) {
+        case 'start': {
+            const idle = values.idle === undefined ? 2 : Number(values.idle);
+            if (!Number.isInteger(idle) || idle < 0)
+                throw new RafError(`--idle invalide : ${values.idle}`);
+            return sessionStart(ctx, { since: values.since ?? '24 hours ago', idle });
+        }
+        case 'close':
+            return sessionClose(ctx, { since: values.since });
+        case 'next': {
+            const lines = args.filter((l) => l.trim() !== '');
+            if (values.clear) {
+                if (lines.length)
+                    throw new RafError('session next --clear efface les notes : ne pas lui passer de ligne');
+                const gone = clearNext(ctx.state);
+                ctx.out(gone ? `notes effacées (${gone.lines.length} ligne(s) du ${gone.date})` : 'aucune note à effacer');
+                return 0;
+            }
+            // Lancée sans ligne (variable vide dans un script, agent pressé), la commande effaçait en silence
+            // les notes de la dernière clôture : effacer se demande exprès.
+            if (lines.length === 0) {
+                const kept = readNext(ctx.state);
+                throw new RafError(`session next : aucune ligne — ${kept ? `${kept.lines.length} ligne(s) du ${kept.date} conservée(s)` : "rien n'est écrit"} ; ` +
+                    'usage : cadence session next "ligne" … (pour effacer les notes exprès : cadence session next --clear)');
+            }
+            writeNext(ctx.state, ctx.today, lines);
+            // Rien sur stdout laissait croire à un échec : on redit les lignes telles qu'enregistrées, pour que
+            // session-close les rapporte sans relancer session start.
+            const n = lines.length;
+            ctx.out(`${n} ligne${n > 1 ? 's' : ''} enregistrée${n > 1 ? 's' : ''} pour la prochaine ouverture\n${lines.map((l) => `  - ${l}`).join('\n')}`);
+            return 0;
+        }
+        default:
+            throw new RafError('usage : cadence session start [--since …] [--idle 2] | close [--since …] | start|close --all [--depth n] | next "ligne" … | next --clear | context [--session id]');
+    }
+}
+/** cadence session start|close|next|context. */
+export function cmdSession(c) {
+    const { rest, values, io, today, root, configPath, loadPlan, newsDir } = c;
+    // Le contexte de la session ne dépend d'aucun dépôt : le lead le lit depuis le dossier parent.
+    if (rest[0] === 'context')
+        return sessionContext(io, values.session);
+    if (!gitRoot(io.cwd))
+        throw new RafError('session : à lancer dans un dépôt git');
+    // « next » n'écrit que les notes : la commande du projet ne se joue qu'à la reprise et à la clôture.
+    const sconf = rest[0] === 'start' || rest[0] === 'close' ? readSessionConfig(configPath) : {};
+    const facts = rest[0] === 'start' || rest[0] === 'close' ? sconf[rest[0]] : undefined;
+    const clean = rest[0] === 'close' && sconf.clean ? { patterns: sconf.clean, days: sconf.cleanDays } : undefined;
+    const sctx = { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, now: io.now(), out: io.out, facts, clean, memory: closeMemoryLines(io.env, io.cwd, configPath) };
+    if (rest[0] !== 'start')
+        return session(rest, sctx, values);
+    // La reprise rejoue les vérifications d'effet (un essai, borné) : un effet rouge d'hier se lit avec les faits du matin.
+    const effects = morningEffects(configPath, root);
+    if (effects === null)
+        return session(rest, sctx, values);
+    return Promise.resolve(effects).then((lines) => session(rest, { ...sctx, effects: lines }, values));
+}
+/** `--all` balaie les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant ; null sans --all ni --depth. */
+export function cmdSessionAll(c, run) {
+    return c.values.all || c.values.depth !== undefined ? sessionAll(c.rest, c.values, c.io, run) : null;
+}

package/dist/cli/setup-commands.js

@@ -0,0 +1,72 @@
+// Installer et déplacer : init, skills, migrate (L488, sorti de cli.ts).
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { gitRoot } from '../git.js';
+import { installHook } from '../hook.js';
+import { Plan, RafError } from '../plan.js';
+import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from '../skills.js';
+import { applyMigration, describeMigration, planMigration, unhandledError } from '../migrate.js';
+/** Ajoute `line` au .gitignore de `root` s'il n'y est pas déjà (avec ou sans `/` initial ou final). Rend vrai si écrit. */
+export function ensureGitignore(root, line) {
+    const file = join(root, '.gitignore');
+    const text = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    const norm = (l) => l.trim().replace(/^\//, '').replace(/\/$/, '');
+    if (text.split('\n').some((l) => norm(l) === norm(line)))
+        return false;
+    writeFileSync(file, `${text}${text === '' || text.endsWith('\n') ? '' : '\n'}${line}\n`);
+    return true;
+}
+/** raf init : crée le plan, le dossier des notes, le .gitignore et le hook. */
+export function cmdInit(c) {
+    const { values, io, today, root, configPath, planConfig, planPath, chosen } = c;
+    if (planConfig?.settings.format)
+        throw new RafError(`plan en lecture seule : ${configPath} décrit un plan tenu par un autre outil`);
+    const plan = Plan.create(planPath, values.project ?? basename(root), values.prefix ?? 'L', today);
+    io.out(`plan créé : ${plan.path}`);
+    if (chosen === undefined) {
+        mkdirSync(join(root, '.cadence/notes'), { recursive: true });
+        writeFileSync(join(root, '.cadence/notes/.gitkeep'), '');
+    }
+    if (ensureGitignore(root, '.playwright-mcp/'))
+        io.out('.gitignore : .playwright-mcp/');
+    if (!values['no-hook'] && gitRoot(io.cwd))
+        io.out(`hook : ${installHook(io.cwd).path}`);
+    return 0;
+}
+/** cadence skills install : skills et agents dans le dossier .claude. */
+export function cmdSkills(c) {
+    const { rest, values, io, root } = c;
+    if (rest[0] !== 'install')
+        throw new RafError('usage : cadence skills install [--dir .claude] [--force]');
+    // --dir désigne le dossier .claude (défaut : celui du dépôt) : skills/ et agents/ dedans.
+    const base = resolve(io.cwd, values.dir ?? join(root, '.claude'));
+    const label = { installed: 'installé', updated: 'mis à jour', unchanged: 'inchangé' };
+    const force = !!values.force;
+    // Vérifier les deux avant d'écrire : un conflit d'agent ne doit pas laisser les skills à moitié installés.
+    if (!force) {
+        installSkills(SKILLS_DIR, join(base, 'skills'), false, true);
+        installAgents(AGENTS_DIR, join(base, 'agents'), false, true);
+    }
+    for (const r of installSkills(SKILLS_DIR, join(base, 'skills'), force))
+        io.out(`${r.name} : ${label[r.status]}`);
+    for (const r of installAgents(AGENTS_DIR, join(base, 'agents'), force))
+        io.out(`${r.name} (agent) : ${label[r.status]}`);
+    io.out(base);
+    return 0;
+}
+/** Déplacer le plan ne lit pas le plan : pas d'avertissement « ancien emplacement » (L284). */
+export function cmdMigrate(c) {
+    const { rest, values, io, root } = c;
+    if (rest.length > 0)
+        throw new RafError('usage : raf migrate [--dry-run]');
+    const migration = planMigration(root);
+    // --dry-run décrit ce qui serait fait avant de refuser ; sans lui, un refus n'annonce rien de fait.
+    if (values['dry-run'] || migration.unhandled.length === 0)
+        for (const l of describeMigration(migration, !!values['dry-run']))
+            io.out(l);
+    if (migration.unhandled.length > 0)
+        throw unhandledError(migration);
+    if (!values['dry-run'])
+        applyMigration(root, migration);
+    return 0;
+}

package/dist/cli/spec-commands.js

@@ -0,0 +1,298 @@
+// Les commandes de la spec : check|qa de la fiche, spec on|off, green et reseal de l'acceptation (L488, sorti de cli.ts).
+import { dirtyPaths } from '../git.js';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { dirname, join, posix, relative, resolve } from 'node:path';
+import { readOrchestrateConfig, readPlanConfig } from '../config.js';
+import { PLAN_ACTIONS, planCommitMessage } from '../plan-commit.js';
+import { gitRoot } from '../git.js';
+import { RafError } from '../plan.js';
+import { waveHolding } from '../repo-busy.js';
+import { cadenceHome, liveWaves, openLotsIn, openWavesIn } from '../orchestrate/registry.js';
+import { resumeCommand } from '../orchestrate/table.js';
+import { findAcceptation, modeSpecGreen, parseAcceptation, resealAcceptation, resealForGreen, runAcceptation, setVert } from '../orchestrate/accept.js';
+import { checkFiche, deriveQa, readFiche, summary } from '../spec.js';
+const git = (cwd, args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+/** Chemin à coller dans un shell : entre apostrophes dès qu'il contient autre chose que des caractères sûrs. */
+const shellPath = (p) => (/^[\w@%+=:,./-]+$/.test(p) ? p : `'${p.replace(/'/g, "'\\''")}'`);
+/** Le refus de `spec reseal` devant des vagues non terminées (L238) : chaque vague (vivante ou arrêtée), son dossier de lancement, ses lots, et pour chaque vague arrêtée UNE commande à lancer telle quelle (un `--drop` par lot ouvert du dépôt, y compris ceux en file qui ne sont pas en cours au plan : `--resume` relance toute la vague avec les lots non retirés, et un lot en file reprendrait le verrou, L239). */
+function openWavesRefusal(open, command) {
+    const lines = open.map((w) => {
+        const where = [w.live ? 'vivante' : 'arrêtée', ...(w.live && w.pid !== undefined ? [`pid ${w.pid}`] : []), ...(w.launchDir ? [`lancée depuis ${w.launchDir}`] : [])].join(', ');
+        return `  - vague ${w.wave} (${where}) : ${w.lots.length ? [...w.lots.map((l) => `${l.key} (${l.status})`), ...w.others.map((l) => `${l.key} (${l.status}, pas en cours au plan)`)].join(', ') : 'lots illisibles'}`;
+    });
+    const how = open.map((w) => w.live
+        ? `  vague ${w.wave} : orchestration en cours, à attendre (le verrou du dépôt tombe dès que tous ses lots y sont prêts ou rendus)`
+        : `  cd ${shellPath(w.launchDir)} && ${resumeCommand(w.wave, ...[...w.lots, ...w.others].flatMap((l) => ['--drop', l.key]))}`);
+    return [
+        `${command} : refusé — ${open.length > 1 ? `${open.length} vagues non terminées gardent` : 'une vague non terminée garde'} ouvert au moins un lot en cours de ce dépôt (${command === 'spec green' ? 'le commit de spec green posé' : 'un rescellé commité'} maintenant lui serait rendu comme « premier commit fautif » à la reprise de la vague) :`,
+        ...lines,
+        `Marche à suivre : clore chacun de ces lots dans sa vague (attendre les vivantes, retirer les lots des arrêtées), puis relancer ${command === 'spec green' ? 'spec green' : 'le rescellé'} :`,
+        ...how,
+    ].join('\n');
+}
+/**
+ * Les vagues non terminées qui gardent ouvert un lot de `repo` encore en cours au plan (L238). Une vague range son état dans le dossier d'où elle a été lancée (`RunStore.runsDir(cwd)`),
+ * souvent un dossier PARENT du dépôt (le dossier des projets) : on remonte donc de la racine du plan jusqu'à la racine du disque.
+ */
+function unfinishedWaves(root, repo, plan) {
+    const launchDirs = new Set();
+    for (let d = resolve(root); !launchDirs.has(d); d = dirname(d))
+        launchDirs.add(d);
+    launchDirs.add(repo);
+    const doing = new Set(plan.lots().filter((l) => l.status === 'doing').map((l) => l.id));
+    const alive = liveWaves(cadenceHome());
+    return [...launchDirs].flatMap((dir) => openWavesIn(dir, repo, (l) => doing.has(l.lot), alive));
+}
+/** La vague qui tient le verrou du dépôt rejoint la liste des vagues en cause, même quand l'état de ses lots ne dit rien (illisible, ou lots absents du plan) : le refus est unique et la nomme toujours. */
+function withHolder(open, holder, repo) {
+    const known = open.find((w) => w.wave === holder.wave);
+    if (known)
+        return open.map((w) => (w === known ? { ...w, live: true, pid: holder.pid } : w));
+    const reg = liveWaves(cadenceHome()).find((w) => w.pid === holder.pid);
+    const keys = openLotsIn(cadenceHome(), holder.pid, repo) ?? [];
+    return [{ wave: holder.wave, launchDir: reg?.cwd ?? '', live: true, pid: holder.pid, lots: keys.map((key) => ({ key, status: 'ouvert' })), others: [] }, ...open];
+}
+/**
+ * `cadence spec green <lot>` (L366) : un lot mené ou clos à la main (raf done) dont l'acceptation est restée à `vert: false` bloque toutes les vagues suivantes du dépôt.
+ * Lance la commande dédiée (`orchestrate.accept`) comme le cycle ; verte, rescelle les tests mis au point depuis le commit rouge (`resealForGreen`), pose `vert: true` et commite le seul fichier, en citant le lot. Rouge : rien n'est changé, code 1.
+ */
+function specGreen(args, ctx, io) {
+    if (args.length !== 1)
+        throw new RafError('usage : cadence spec green <lot>');
+    if (io.env.CADENCE_ORCHESTRATED)
+        throw new RafError(`spec green refusé pendant une vague orchestrée (${io.env.CADENCE_ORCHESTRATED}) : c'est le travail du lead, hors session`);
+    refuseWhileWaveHolds(ctx, 'spec green');
+    const lotId = args[0];
+    const plan = ctx.loadPlan();
+    const lot = plan.lot(lotId);
+    if (lot.status === 'todo')
+        throw new RafError(`${lotId} n'est pas commencé (todo) : il n'a rien livré dont l'acceptation puisse passer au vert`);
+    const repo = gitRoot(ctx.root) ?? ctx.root;
+    const config = readOrchestrateConfig(ctx.configPath);
+    if (!config.accept)
+        throw new RafError(`orchestrate.accept absent de ${ctx.configPath} : sans la commande dédiée, il n'y a rien à lancer pour ${lotId}`);
+    const json = findAcceptation(repo, config.spec.dir, lotId);
+    if (!json)
+        throw new RafError(`${lotId} : aucune acceptation sous ${config.spec.dir} (le lot n'a pas passé l'étape accept)`);
+    const doc = parseAcceptation(readFileSync(join(repo, json), 'utf8'));
+    if (typeof doc === 'string')
+        throw new RafError(`${json} : ${doc}`);
+    // Vert mais sans empreintes (L526, issue #20) : clos avant le scellement, il tient le verrou total sans qu'aucun chemin ne le scelle. On rejoue l'acceptation et, verte, on pose les empreintes.
+    const mode = modeSpecGreen(doc);
+    if (mode.deja) {
+        io.out(`${lotId} : ${json} est déjà vert, rien à faire`);
+        return 0;
+    }
+    const open = unfinishedWaves(ctx.root, repo, plan);
+    if (open.length)
+        throw new RafError(openWavesRefusal(open, 'spec green'));
+    const dirty = git(repo, ['status', '--porcelain', '-z', '--', ...doc.fichiers]).split('\0').filter(Boolean).map((l) => l.slice(3));
+    if (dirty.length)
+        throw new RafError(`${lotId} : test(s) listé(s) modifié(s) sans être commités : ${dirty.join(', ')} — les commiter (en citant ${lotId}) avant de poser vert: true`);
+    const { runs, orphans } = runAcceptation(repo, json, config.accept);
+    if (orphans.length)
+        throw new RafError(`fichiers listés dans ${json} sous la racine d'aucune commande de orchestrate.accept : ${orphans.join(', ')}`);
+    const failed = runs.filter((r) => r.code !== 0);
+    if (failed.length) {
+        io.err(`${lotId} : tests d'acceptation encore rouges (${failed.map((r) => `${r.command}, code ${r.code}`).join(' ; ')}), ${json} ${mode.reste}`);
+        for (const r of failed)
+            io.err(r.output.trim().split('\n').slice(-40).join('\n'));
+        return 1;
+    }
+    const before = readFileSync(join(repo, json), 'utf8');
+    let sealed;
+    try {
+        sealed = resealForGreen(repo, json, ctx.today);
+    }
+    catch (e) {
+        throw new RafError(`${lotId} : ${e.message}`);
+    }
+    const resceles = sealed.refaits;
+    setVert(repo, json); // déjà vrai pour un lot vert sans empreintes : le fichier garde ce qu'il avait
+    try {
+        git(repo, ['add', '--', json]);
+        // Le sujet reste court et fixe (le gabarit `plan.commit` du projet s'il y en a un, comme tout commit écrit par cadence, L343) ; les tests rescellés, sans borne, vont dans le corps, une ligne chacun.
+        const template = readPlanConfig(join(repo, 'cadence.yaml'), repo)?.commit;
+        const subject = template ? planCommitMessage(template, { lot: lotId, action: mode.action }) : `chore(${lotId}): ${mode.action}`;
+        const body = resceles.length ? ['empreintes rescellées (tests mis au point depuis le commit rouge) :', ...resceles.map((f) => `- ${f}`)].join('\n') : null;
+        git(repo, ['commit', '-q', '-m', subject, ...(body ? ['-m', body] : []), '--', json]);
+    }
+    catch (e) {
+        // Atomique, comme le rescellé : un commit refusé (hook pre-commit, ...) laisse le fichier tel qu'avant.
+        writeFileSync(join(repo, json), before);
+        try {
+            git(repo, ['reset', '-q', '--', json]);
+        }
+        catch {
+            // rien d'indexé : rien à défaire
+        }
+        const out = e;
+        throw new RafError(`spec green : le commit a échoué, ${json} est revenu tel qu'avant la commande — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
+    }
+    io.out(`${lotId} : ${json} → ${mode.fait}${sealed.scelles.length ? ` (${sealed.scelles.join(', ')})` : ''}, commit ${git(repo, ['rev-parse', '--short', 'HEAD']).trim()}${resceles.length ? ` ; empreintes rescellées (tests mis au point depuis le commit rouge) : ${resceles.join(', ')}` : ''}`);
+    return 0;
+}
+/** Un commit du lead en pleine passe ferait signaler au lot suivant un écart qui n'est pas le sien : tant qu'une vague tient le verrou du dépôt, `spec reseal` et `spec green` refusent. */
+function refuseWhileWaveHolds(ctx, command) {
+    // Comme `deliver` : la vague tient le verrou du dépôt tant qu'un de ses lots y travaille (état illisible : on refuse).
+    // Le refus est UN message : la vague vivante qui tient le verrou (à attendre) et les vagues arrêtées du dépôt, avec leurs dossiers et leurs commandes (L238).
+    const orchestrating = waveHolding(ctx.root, command);
+    if (orchestrating) {
+        const repo = gitRoot(ctx.root) ?? ctx.root;
+        let open = [];
+        try {
+            open = unfinishedWaves(ctx.root, repo, ctx.loadPlan());
+        }
+        catch {
+            // plan illisible : le verrou seul motive le refus, la vague qui le tient est nommée
+        }
+        throw new RafError(openWavesRefusal(withHolder(open, orchestrating, repo), command));
+    }
+}
+/**
+ * `cadence spec reseal <lot> <test> --reason texte` (L200) : le chemin du lead quand un test d'acceptation scellé du lot EN COURS contredit la fiche.
+ * Le test est corrigé dans l'arbre de travail (fiche inchangée, ou amendée et commitée par des commits du lot, L217) ; la commande refait l'empreinte de ce seul test, journalise la raison dans
+ * acceptation.json, commite test + acceptation (le nouveau commit rouge), et note la raison au lot. Le verrou garde tout le reste.
+ */
+function specReseal(args, reason, porteur, ctx, io) {
+    if (args.length !== 2 || !reason?.trim())
+        throw new RafError('usage : cadence spec reseal <lot> <test> --reason "pourquoi le test contredit la fiche" [--porteur <lot en cours>, pour un lot livré]');
+    if (io.env.CADENCE_ORCHESTRATED)
+        throw new RafError(`spec reseal refusé pendant une vague orchestrée (${io.env.CADENCE_ORCHESTRATED}) : c'est le travail du lead, hors session`);
+    refuseWhileWaveHolds(ctx, 'spec reseal');
+    const [lotId, test] = args;
+    const plan = ctx.loadPlan();
+    const lot = plan.lot(lotId);
+    const repo = gitRoot(ctx.root) ?? ctx.root;
+    const dir = readOrchestrateConfig(ctx.configPath).spec.dir;
+    const json = findAcceptation(repo, dir, lotId);
+    // Un lot livré (acceptation verte) se rescelle pour un test instable dont le contrat ne change pas : le lot en cours qui porte la correction est nommé (--porteur) et cité dans le commit.
+    const livre = lot.status !== 'doing' && !!json && ((a) => typeof a !== 'string' && a.vert)(parseAcceptation(readFileSync(join(repo, json), 'utf8')));
+    if (lot.status !== 'doing' && !livre)
+        throw new RafError(`${lotId} n'est pas en cours (${lot.status}) : le rescellé vaut pour le lot en cours, ou pour un lot livré dont l'acceptation est verte (vert: true) avec --porteur <lot en cours>`);
+    if (porteur && lot.status === 'doing')
+        throw new RafError(`--porteur n'a de sens que pour un lot livré : ${lotId} est en cours, son rescellé est cité sous son propre id`);
+    if (livre && !porteur?.trim())
+        throw new RafError(`${lotId} est livré : --porteur <lot en cours> est obligatoire (le lot dont le commit porte la correction du test)`);
+    if (livre && porteur) {
+        if (porteur === lotId)
+            throw new RafError(`--porteur doit être un autre lot que ${lotId} (le lot livré est clos)`);
+        const carrier = plan.lot(porteur);
+        if (carrier.status !== 'doing')
+            throw new RafError(`--porteur ${porteur} n'est pas en cours (${carrier.status}) : le lot porteur est celui dont le commit porte la correction`);
+    }
+    const cite = livre ? porteur : lotId;
+    if (!json)
+        throw new RafError(`${lotId} : aucune acceptation sous ${dir} (le lot n'a pas passé l'étape accept)`);
+    // Une vague non terminée (arrêtée sur une question ou le quota) garde ouverts des lots que son `--resume` rejouera : un rescellé commité entre-temps serait rendu à l'un d'eux comme « premier commit fautif » (L238).
+    // Le verrou du rescellé couvre tous les lots ouverts du dépôt, pas seulement le porteur : on refuse dès qu'un lot DE CE DÉPÔT, encore en cours au plan, reste ouvert dans une vague non terminée.
+    const open = unfinishedWaves(ctx.root, repo, plan);
+    if (open.length)
+        throw new RafError(openWavesRefusal(open, 'spec reseal'));
+    const before = { json: readFileSync(join(repo, json), 'utf8'), test: existsSync(join(repo, test)) ? readFileSync(join(repo, test), 'utf8') : '' };
+    let r;
+    try {
+        r = resealAcceptation(repo, json, test, reason, ctx.today, livre ? porteur : undefined, plan.refs, plan.lots().filter((l) => l.status === 'done').map((l) => l.id));
+    }
+    catch (e) {
+        throw new RafError(e.message);
+    }
+    const norm = posix.normalize(test);
+    try {
+        git(repo, ['add', '--', json, norm]);
+        git(repo, ['commit', '-q', '-m', `test(${cite}): acceptation rescellée${livre ? ` du lot livré ${lotId}` : ''}, ${norm} : ${reason.trim()}${r.ficheAmendee ? ` (fiche amendée en ${r.ficheAmendee})` : ''}`, '--', json, norm]);
+    }
+    catch (e) {
+        // Atomique : un commit refusé (hook pre-commit, ...) ne laisse ni empreinte refaite ni index à moitié prêt ; le test retrouve le texte du lead.
+        writeFileSync(join(repo, json), before.json);
+        writeFileSync(join(repo, norm), before.test);
+        try {
+            git(repo, ['reset', '-q', '--', json, norm]);
+        }
+        catch {
+            // rien d'indexé : rien à défaire
+        }
+        const out = e;
+        throw new RafError(`spec reseal : le commit du rescellé a échoué, ${json} et ${norm} sont revenus tels qu'avant la commande (rien n'est rescellé) — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
+    }
+    const sha = git(repo, ['rev-parse', '--short', 'HEAD']).trim();
+    // Un plan tenu par un autre outil ne se modifie pas d'ici : la raison est déjà dans acceptation.json et dans le commit, la note reste à la main du lead.
+    if (plan.readonly) {
+        io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha}${r.ficheAmendee ? `, fiche amendée en ${r.ficheAmendee}` : ''} ; raison dans ${json} et dans le commit — note à ajouter au lot ${cite} avec l'outil du projet (plan en lecture seule)`);
+        return 0;
+    }
+    plan.note(cite, `test d'acceptation rescellé${livre ? ` (lot livré ${lotId}, ` : ' ('}${norm}, ${r.ficheAmendee ? `fiche amendée en ${r.ficheAmendee}` : 'fiche inchangée'}) : ${reason.trim()}`, ctx.today);
+    try {
+        plan.save();
+    }
+    catch (e) {
+        // Le rescellé est commité (sha) : seul le plan est refusé (plan.onWrite en échec), il reste inchangé et la note n'est pas écrite ; dire « écriture refusée » seul laisserait croire que rien n'a été fait.
+        throw new RafError(`spec reseal : le rescellé a eu lieu (commit ${sha}) mais la note du lot n’a pas été écrite, le plan est inchangé — ${e.message} — relancer la commande dit « rien à resceller » : ajouter la note à la main (raf note ${cite}) une fois le plan réparé`);
+    }
+    // La note du lot rejoint le dépôt dans la foulée (un dépôt sale arrêterait la vague suivante) ; un plan hors du dépôt ou non suivi reste à la main du lead.
+    const planRel = relative(repo, plan.path);
+    const produced = plan.produced;
+    const tracked = !planRel.startsWith('..') && git(repo, ['ls-files', '--', planRel]).trim() !== '';
+    if (tracked) {
+        try {
+            // Les fichiers de plan.onWrite (L346) partent avec la note : la commande a tourné à l'écriture du plan.
+            const withPlan = [planRel, ...dirtyPaths(repo, produced)];
+            git(repo, ['add', '--', ...withPlan]);
+            git(repo, ['commit', '-q', '-m', planCommitMessage(readPlanConfig(join(repo, 'cadence.yaml'), repo)?.commit, { lot: cite, action: PLAN_ACTIONS.resealed(norm) }), '--', ...withPlan]);
+        }
+        catch (e) {
+            // Le rescellé est fait (commit ${sha}) : on ne le défait pas, on dit où en est la note, au lieu d'une pile d'appels.
+            const out = e;
+            throw new RafError(`spec reseal : le rescellé a eu lieu (commit ${sha}) mais le commit de la note du lot a échoué — la note est écrite dans ${planRel}, à commiter à la main (un plan sale arrêterait la vague suivante) — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
+        }
+    }
+    io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha}${r.ficheAmendee ? `, fiche amendée en ${r.ficheAmendee}` : ''} ; raison dans ${json} et en note du lot ${cite}${tracked ? '' : ' (plan à commiter)'}`);
+    return 0;
+}
+/** `cadence spec check|qa <fiche>` (L170) : code 0 valide, 1 écarts, 2 usage ou fichier illisible. `qa` imprime la section expectations.md de l'écran. */
+function spec(rest, io) {
+    const sub = rest[0];
+    if ((sub !== 'check' && sub !== 'qa') || rest.length !== 2)
+        throw new RafError('usage : cadence spec check|qa <fiche.yaml>');
+    const doc = readFiche(resolve(io.cwd, rest[1]));
+    const problems = checkFiche(doc);
+    if (sub === 'qa') {
+        // les écarts vont sur la sortie d'erreur : la sortie standard est la section, qu'on redirige vers le fichier
+        for (const m of problems)
+            io.err(`✗ ${m}`);
+        if (problems.length > 0)
+            return 1;
+        io.out(deriveQa(doc).trimEnd());
+        return 0;
+    }
+    for (const m of problems)
+        io.out(`✗ ${m}`);
+    if (problems.length > 0) {
+        io.out(`${problems.length} écart(s)`);
+        return 1;
+    }
+    io.out(summary(doc));
+    return 0;
+}
+/** raf spec <id> on|off, spec green <lot>, spec reseal <lot> <test> : le verbe de raf et les deux chemins du lead. */
+export function cmdSpec(c) {
+    const { rest, values, io, today, root, configPath, loadPlan } = c;
+    if (rest[0] === 'green')
+        return specGreen(rest.slice(1), { root, loadPlan, configPath, today }, io);
+    if (rest[0] === 'reseal')
+        return specReseal(rest.slice(1), values.reason, values.porteur, { root, loadPlan, configPath, today }, io);
+    if (rest.length !== 2 || (rest[1] !== 'on' && rest[1] !== 'off'))
+        throw new RafError('usage : raf spec <id> on|off (ou cadence spec check|qa <fiche.yaml>)');
+    const plan = loadPlan();
+    if (!plan.setSpec(rest[0], rest[1] === 'on')) {
+        io.out(`${rest[0]} a déjà screen: page — l'écran implique la spec, rien à changer`);
+        return 0;
+    }
+    plan.save();
+    return 0;
+}
+/** `spec` est aussi un verbe de raf (raf spec <id> on|off, L186) : seuls check et qa vont à la fiche, sans lire le plan ; null pour les autres. */
+export function cmdSpecChecks(c) {
+    return c.rest[0] === 'check' || c.rest[0] === 'qa' ? spec(c.rest, c.io) : null;
+}