@sylad/cadence 1.12.1 → 1.14.1

package/dist/config-set.js

@@ -0,0 +1,252 @@
+import { execSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { isNode, isScalar, parse, parseDocument } from 'yaml';
+import { defaultPlan, readDocsConfig, readHookConfig, readMigrateConfig, readNewsConfig, readOrchestrateConfig, readPerfConfig, readPlanConfig, readReferencesConfig, readSessionConfig } from './config.js';
+import { parseDeliverConfig } from './deliver.js';
+import { commitPaths, dirtyPaths, gitRoot, restorePaths } from './git.js';
+import { findProjects, isProject, readDepth, readLeadUx } from './lead.js';
+import { readPriority } from './orchestrate/continue.js';
+import { Plan, RafError } from './plan.js';
+const KEY = /^[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)*$/;
+/** Un argument de shell entre apostrophes. */
+const shellQuote = (s) => `'${s.replaceAll("'", "'\\''")}'`;
+/** Estimation du lot de config : une ligne de configuration, pas une journée. */
+const ESTIMATE = 0.05;
+/** Relit un cadence.yaml avec chacun des chargeurs de config de cadence : la première erreur sort (RafError). */
+export function validateConfig(file, root) {
+    readPlanConfig(file, root);
+    readNewsConfig(file);
+    readHookConfig(file);
+    readPerfConfig(file);
+    readSessionConfig(file);
+    readOrchestrateConfig(file);
+    readDocsConfig(file);
+    readReferencesConfig(file);
+    readMigrateConfig(file);
+    readLeadUx(dirname(file));
+    readDepth(dirname(file));
+    readPriority(dirname(file));
+    const text = readFileSync(file, 'utf8');
+    if (parse(text)?.deliver != null)
+        parseDeliverConfig(text, file);
+}
+/** Les chargeurs lisent un chemin : le texte est posé dans un dossier jetable, le cadence.yaml du projet ne change pas avant d'avoir été relu. */
+function inTemp(text, use) {
+    const dir = mkdtempSync(join(tmpdir(), 'cadence-config-'));
+    try {
+        const file = join(dir, 'cadence.yaml');
+        writeFileSync(file, text);
+        try {
+            return use(file);
+        }
+        catch (e) {
+            throw new RafError((e instanceof Error ? e.message : String(e)).split('\n')[0].replaceAll(file, 'cadence.yaml'));
+        }
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+/** Le message de la première erreur des chargeurs de config sur ce texte, null quand il se relit. */
+function readsBack(text, root) {
+    try {
+        inTemp(text, (file) => validateConfig(file, root));
+        return null;
+    }
+    catch (e) {
+        return e.message;
+    }
+}
+/** Le texte de cadence.yaml avec `key` posée à `value` (le reste du fichier est gardé tel quel : seules les lignes de la clé changent) ; null quand la clé a déjà cette valeur. */
+export function setKey(text, key, value) {
+    const doc = parseDocument(text);
+    if (doc.errors.length > 0)
+        throw new RafError(doc.errors[0].message.split('\n')[0]);
+    const baseline = doc.toString({ lineWidth: 0 });
+    const path = key.split('.');
+    const old = doc.getIn(path, true);
+    const next = value.clone().contents; // une copie par projet : le commentaire de l'ancienne valeur ne passe pas au projet suivant
+    if (JSON.stringify(doc.getIn(path)) === JSON.stringify(value.toJS()))
+        return null;
+    if (isScalar(old) && isScalar(next))
+        old.value = next.value; // la même case : son commentaire de fin de ligne reste
+    else {
+        if (isNode(old) && isNode(next))
+            next.comment = old.comment;
+        doc.setIn(path, next);
+    }
+    const full = doc.toString({ lineWidth: 0 });
+    const kept = onlyChangedLines(text, baseline, full);
+    return readsAs(kept, full) ? kept : full; // un report mal aligné change le sens du fichier : l'écriture entière de yaml
+}
+/** Les deux textes sont le même document YAML ; un texte qui ne se lit pas (clés en double d'un report mal aligné) n'est pas le même. */
+function readsAs(text, expected) {
+    try {
+        return JSON.stringify(parse(text)) === JSON.stringify(parse(expected));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * La réécriture de yaml normalise tout le fichier (`[a, b]` devient `[ a, b ]`, les espaces avant un commentaire de fin de ligne) :
+ * seules les lignes que la pose de la clé a changées (`baseline` → `changed`, deux écritures de yaml) sont reportées dans le texte d'origine.
+ * Quand yaml a aussi changé le nombre de lignes du fichier non modifié, le report n'est pas sûr : l'écriture entière de yaml est rendue (`setKey` la rend aussi quand le report ne relit pas le même document).
+ */
+function onlyChangedLines(original, baseline, changed) {
+    const o = original.split('\n');
+    const b = baseline.split('\n');
+    const c = changed.split('\n');
+    if (o.length !== b.length)
+        return changed;
+    let head = 0;
+    while (head < b.length && head < c.length && b[head] === c[head])
+        head++;
+    let tail = 0;
+    while (tail < b.length - head && tail < c.length - head && b[b.length - 1 - tail] === c[c.length - 1 - tail])
+        tail++;
+    // Les lignes reportées doivent être celles que yaml a écrites au même endroit : un commentaire que yaml a déplacé d'une ligne (compensé par une liste regroupée) ne se reporte pas.
+    const sameComments = (from, n, ofB) => Array.from({ length: n }, (_, k) => commentOf(o[from + k]) === commentOf(b[ofB + k])).every(Boolean);
+    if (!sameComments(0, head, 0) || !sameComments(o.length - tail, tail, b.length - tail))
+        return changed;
+    return [...o.slice(0, head), ...c.slice(head, c.length - tail), ...o.slice(o.length - tail)].join('\n');
+}
+/** Le commentaire d'une ligne (à partir du premier `#` en début de ligne ou après un blanc), '' sans commentaire ; une erreur sur un `#` de chaîne ne coûte que l'écriture entière. */
+const commentOf = (line) => /(^|\s)#.*$/.exec(line)?.[0].trim() ?? '';
+/**
+ * `cadence config set <clé> <valeur> --all` (L342) : pose la même clé dans le cadence.yaml de chaque projet de `parent` (ceux que `lead tour` connaît),
+ * crée dans chacun un lot de config qui la cite (en cours, à fermer par le lead) et commite à chemin explicite le cadence.yaml et le plan, sans pousser.
+ * Un projet que la commande ne peut pas traiter sans risque est sauté et dit pourquoi ; une config qui ne se relit pas arrête le passage.
+ */
+export function configSet(parent, key, valueText, opts, today) {
+    if (!KEY.test(key))
+        throw new RafError(`clé invalide : « ${key} » (segments de lettres, chiffres, - ou _ séparés par des points : orchestrate.escalation)`);
+    if (valueText.trim() === '')
+        throw new RafError('valeur vide : cadence config set <clé> <valeur> --all');
+    const value = parseDocument(valueText);
+    if (value.errors.length > 0 || value.contents == null)
+        throw new RafError(`valeur illisible en YAML : ${valueText} — ${value.errors[0]?.message.split('\n')[0] ?? 'vide'}`);
+    const shown = valueText.trim().replace(/\s+/g, ' ');
+    let projects = findProjects(parent, opts.depth);
+    if (projects.length === 0 && isProject(parent))
+        projects = [parent]; // comme lead tour : sans sous-projet, le dossier lui-même s'il en est un
+    if (projects.length === 0)
+        return { lines: [`aucun projet sous ${parent} (.cadence/raf.yaml, docs/plan/raf.yaml ou cadence.yaml avec plan:)`], code: 0 };
+    const lines = [];
+    let done = 0;
+    let skipped = 0;
+    let stopped = false;
+    for (const [i, dir] of projects.entries()) {
+        const name = relative(parent, dir).split('\\').join('/') || basename(dir);
+        const skip = (why) => {
+            skipped++;
+            lines.push(`– ${name} · sauté : ${why}`);
+        };
+        const stop = (why) => {
+            stopped = true;
+            lines.push(`✗ ${name} · arrêt : ${why}`);
+            const rest = projects.slice(i + 1).map((p) => relative(parent, p).split('\\').join('/'));
+            if (rest.length)
+                lines.push(`non traités : ${rest.join(', ')}`);
+        };
+        const top = gitRoot(dir);
+        if (!top || realpathSync(top) !== realpathSync(dir)) {
+            skip(top ? `pas de dépôt git propre au projet (dépôt parent : ${top})` : 'pas un dépôt git');
+            continue;
+        }
+        const configFile = join(dir, 'cadence.yaml');
+        const before = existsSync(configFile) ? readFileSync(configFile, 'utf8') : null;
+        if (before !== null) {
+            const unreadable = readsBack(before, dir);
+            if (unreadable) {
+                stop(`la config ne se relit pas, avant toute modification : ${unreadable}`);
+                break;
+            }
+        }
+        let text;
+        try {
+            text = setKey(before ?? '', key, value);
+        }
+        catch (e) {
+            skip(`la clé ne se pose pas dans ce cadence.yaml (${e.message.split('\n')[0]})`);
+            continue;
+        }
+        if (text === null) {
+            skip(`${key} a déjà cette valeur`);
+            continue;
+        }
+        const failure = readsBack(text, dir);
+        if (failure) {
+            stop(`la config modifiée ne se relit pas (${failure}) — rien n'est écrit ici`);
+            break;
+        }
+        // Le plan : lu avec la config modifiée (une clé plan: posée peut le déplacer) ; un plan tenu par un autre outil ne se modifie pas d'ici.
+        const found = planOf(text, dir);
+        if (found.readonly && !found.add) {
+            skip(`plan en lecture seule (tenu par un autre outil) sans commande de création : nommer plan.add dans son cadence.yaml, ou créer le lot de config avec l'outil du projet puis poser ${key}`);
+            continue;
+        }
+        const planPath = found.path ?? defaultPlan(dir).path;
+        const planRel = relative(dir, planPath).split('\\').join('/');
+        if (!existsSync(planPath)) {
+            skip(`pas de plan à ${planRel}`);
+            continue;
+        }
+        const produced = found.settings.onWrite?.files ?? [];
+        const dirty = dirtyPaths(dir, ['cadence.yaml', planRel, ...produced]);
+        if (dirty.length) {
+            skip(`${dirty.join(', ')} non commité : le commit à chemin explicite l'emporterait`);
+            continue;
+        }
+        if (opts.dryRun) {
+            lines.push(`+ ${name} · serait fait : ${key} = ${shown}, lot de config créé et démarré dans ${planRel}, commit de cadence.yaml et ${planRel}`);
+            done++;
+            continue;
+        }
+        const planBefore = readFileSync(planPath, 'utf8');
+        // Ce que plan.onWrite produit est propre ici (vérifié plus haut) : le défaire, c'est le remettre à HEAD.
+        const restore = () => {
+            restorePaths(dir, produced);
+            if (before === null) {
+                if (existsSync(configFile))
+                    unlinkSync(configFile);
+            }
+            else
+                writeFileSync(configFile, before);
+            writeFileSync(planPath, planBefore);
+        };
+        try {
+            writeFileSync(configFile, text);
+            const title = `config cadence.yaml : ${key} = ${shown}`;
+            let id;
+            if (found.readonly && found.add) {
+                // La commande du plan crée le lot (et l'ouvre, si son outil le veut) : l'identifiant est le premier mot de sa sortie qui ressemble à un id de lot.
+                const out = execSync(found.add.replaceAll('{title}', shellQuote(title)), { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+                id = /\b[A-Za-z]+-?\d+(?:\.\d+)?\b/.exec(out)?.[0] ?? '';
+            }
+            else {
+                const plan = Plan.load(planPath, { ...found.settings, config: configFile });
+                id = plan.add(title, today, { estimate: ESTIMATE });
+                plan.setStatus(id, 'doing', today);
+                plan.save();
+            }
+            const sha = commitPaths(dir, ['cadence.yaml', planRel, ...(produced.length ? dirtyPaths(dir, produced) : [])], `chore${id ? `(${id})` : ''}: cadence.yaml — ${key} = ${shown}`);
+            done++;
+            lines.push(`✓ ${name} · ${id || 'lot de config'} · ${key} = ${shown} · commit ${sha}`);
+        }
+        catch (e) {
+            restore();
+            stop(`lot ou commit impossible, fichiers remis en l'état (${e.message.split('\n')[0]})`);
+            break;
+        }
+    }
+    lines.push(`${done} fait${done > 1 ? 's' : ''}${opts.dryRun ? ' (simulation, rien écrit)' : ''}, ${skipped} sauté${skipped > 1 ? 's' : ''}${stopped ? ', arrêt sur un projet' : ''}`);
+    return { lines, code: stopped ? 1 : 0 };
+}
+/** Où est le plan et est-il en lecture seule, d'après le texte de config modifié. */
+function planOf(text, root) {
+    const c = inTemp(text, (file) => readPlanConfig(file, root));
+    return { readonly: !!c?.settings.format, ...(c?.path ? { path: resolve(root, c.path) } : {}), ...(c?.add ? { add: c.add } : {}), settings: c?.settings ?? {} };
+}

package/dist/config.js

@@ -1,11 +1,14 @@
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
 import { parse } from 'yaml';
 import { isDay } from './dates.js';
 import { DEFAULT_TEST_PATTERNS } from './testgate.js';
 import { gitRoot } from './git.js';
+import { planCommitProblem } from './plan-commit.js';
+import { isComposedGate } from './orchestrate/workers.js';
 import { FIELDS, Plan, RafError, STATUSES } from './plan.js';
-const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates'];
+const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit'];
+const ON_WRITE_KEYS = ['command', 'files'];
 const FORMAT_KEYS = ['lots', 'fields', 'statuses', 'estimates'];
 const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const list = (v) => (v == null ? [] : Array.isArray(v) ? v.map(String) : [String(v)]);
@@ -42,6 +45,25 @@ function readQa(qa, file, workRoot) {
         throw new RafError(`${file} : qa.expectations « ${v.trim()} » est hors du dépôt`);
     return rel;
 }
+/** Clé `plan.onWrite` (L346) : la commande qui republie le plan après chaque écriture, lancée dans `cwd` (la racine du dépôt), et les fichiers qu'elle produit (relatifs au dépôt, jamais hors de lui). */
+function readOnWrite(v, cwd, bad) {
+    if (!isObject(v))
+        throw bad('onWrite doit être un objet { command, files }');
+    for (const k of Object.keys(v))
+        if (!ON_WRITE_KEYS.includes(k))
+            throw bad(`onWrite.${k} inconnu (attendu : ${ON_WRITE_KEYS.join(', ')})`);
+    if (typeof v.command !== 'string' || v.command.trim() === '')
+        throw bad('onWrite.command doit être une commande');
+    const files = list(v.files).map((f) => {
+        const rel = posix.normalize(f.trim().replace(/\\/g, '/'));
+        if (rel === '.' || rel === '..' || rel.startsWith('../') || isAbsolute(rel))
+            throw bad(`onWrite.files « ${f} » est hors du dépôt`);
+        if (existsSync(resolve(cwd, rel)) && statSync(resolve(cwd, rel)).isDirectory())
+            throw bad(`onWrite.files « ${f} » est un dossier (déclarer les fichiers produits, pas leur dossier)`);
+        return rel;
+    });
+    return { command: v.command, files, cwd };
+}
 /**
  * Clé `plan:` de cadence.yaml : où est le plan et, s'il est tenu par un autre outil, comment le lire.
  * `root` : la racine du dépôt de travail (celle du CLI), d'où se résout un chemin absolu de `qa.expectations`.
@@ -84,11 +106,20 @@ export function readPlanConfig(file, root) {
         settings.ignore = list(p.ignore);
     if (p.files != null)
         settings.files = list(p.files);
+    if (p.onWrite != null)
+        settings.onWrite = readOnWrite(p.onWrite, root ?? dirname(resolve(file)), bad);
     if (FORMAT_KEYS.some((k) => p[k] != null))
         settings.format = parseFormat(p, bad);
     if (p.path != null && String(p.path).trim() === '')
         throw bad('path est vide');
-    return { ...(p.path != null ? { path: String(p.path) } : {}), settings };
+    if (p.add != null && (typeof p.add !== 'string' || !p.add.includes('{title}')))
+        throw bad('add doit être une commande qui contient {title}');
+    if (p.commit != null) {
+        const problem = typeof p.commit === 'string' ? planCommitProblem(p.commit) : 'doit être un gabarit de message';
+        if (problem)
+            throw bad(`commit ${problem}`);
+    }
+    return { ...(p.path != null ? { path: String(p.path) } : {}), ...(p.add != null ? { add: String(p.add) } : {}), ...(p.commit != null ? { commit: String(p.commit) } : {}), settings };
 }
 export const PLAN_DEFAULT = '.cadence/raf.yaml';
 export const PLAN_LEGACY = 'docs/plan/raf.yaml';
@@ -281,9 +312,8 @@ export function readSessionConfig(file) {
 }
 const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
 export const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'fix', 'review', 'ux'];
-const MODELS = ['haiku', 'sonnet', 'opus'];
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeDeps', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
     const config = { precheck: true, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, worktrees: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
@@ -318,7 +348,7 @@ export function readOrchestrateConfig(file) {
             throw bad('accept : commande non vide attendue (chaîne ou liste de commandes non vides)');
         config.accept = o.accept.map((x) => x.trim());
     }
-    for (const k of ['start', 'verdict', 'test', 'build', 'accept']) {
+    for (const k of ['start', 'verdict', 'test', 'testReplay', 'build', 'accept']) {
         if (k === 'accept' && Array.isArray(o.accept))
             continue;
         if (o[k] == null)
@@ -327,6 +357,16 @@ export function readOrchestrateConfig(file) {
             throw bad(`${k} : commande non vide attendue`);
         config[k] = o[k].trim();
     }
+    if (config.testReplay && !config.testReplay.includes('{files}'))
+        throw bad('testReplay : la commande doit contenir {files} (remplacé par les fichiers des tests rouges)');
+    if (config.testReplay && config.test && isComposedGate(config.test))
+        throw bad('testReplay : refusé quand orchestrate.test est une porte composée (&&, ||, sous-shell) : le rejeu seul ne vaut que pour un lanceur unique');
+    if (o.worktreeDeps != null) {
+        const deps = o.worktreeDeps;
+        if (!Array.isArray(deps) || !deps.length || deps.some((x) => typeof x !== 'string' || !x.trim() || isAbsolute(x) || x.split(/[\\/]/).includes('..')))
+            throw bad('worktreeDeps : liste de chemins relatifs au dépôt, sans « .. » (node_modules, .venv…)');
+        config.worktreeDeps = deps.map((x) => x.trim().replace(/\/$/, ''));
+    }
     if (o.maquette != null) {
         if (typeof o.maquette !== 'boolean')
             throw bad('maquette : true ou false attendu');
@@ -416,9 +456,9 @@ export function readOrchestrateConfig(file) {
             const m = o.review[k];
             if (m == null)
                 continue;
-            if (!MODELS.includes(m))
-                throw bad(`review.${k} : ${MODELS.join(', ')} attendu`);
-            config.review[k] = m;
+            if (typeof m !== 'string' || !m.trim())
+                throw bad(`review.${k} : nom de modèle non vide attendu (haiku, sonnet, opus ou un nom passé tel quel à claude --model)`);
+            config.review[k] = m.trim();
         }
     }
     if (o.escalation != null) {

package/dist/corrections.js

@@ -118,8 +118,10 @@ export function readJournals(runsDir, until, since) {
                 small: !!rec.small,
                 status: String(rec.status),
                 ...(typeof rec.budget === 'number' ? { budget: rec.budget } : {}),
+                ...(typeof rec.escalationReserve === 'number' ? { escalationReserve: rec.escalationReserve } : {}),
                 ...(precheck ? { precheck } : {}),
                 ...(escalation ? { escalation } : {}),
+                ...(Array.isArray(rec.instables) && rec.instables.some((t) => typeof t === 'string') ? { instables: rec.instables.filter((t) => typeof t === 'string') } : {}),
                 ...(Array.isArray(rec.warnings) && rec.warnings.some((w) => typeof w === 'string' && w.startsWith(LOCAL_PRECHECK_UNREADABLE)) ? { localUnreadable: true } : {}),
                 steps: steps.map((s) => {
                     const usage = usageOf(s.tokens);

package/dist/git.js

@@ -1,4 +1,5 @@
 import { execFileSync } from 'node:child_process';
+import { rmSync } from 'node:fs';
 import { basename, dirname, resolve } from 'node:path';
 function git(cwd, args) {
     // Le journal complet d'un gros dépôt dépasse le Mo par défaut : sans marge, il serait lu comme vide.
@@ -110,7 +111,7 @@ export function fileAt(cwd, rev, file) {
         return null;
     }
 }
-function tryGit(cwd, args) {
+export function tryGit(cwd, args) {
     try {
         return git(cwd, args).trim();
     }
@@ -212,3 +213,43 @@ export function addedTimes(dir) {
     }
     return times;
 }
+/** Chemins parmi `paths` (relatifs à la racine) que git voit modifiés, stagés ou non suivis. */
+export function dirtyPaths(root, paths) {
+    const out = git(root, ['-c', 'core.quotepath=off', 'status', '--porcelain', '-z', '--', ...paths]);
+    return out.split('\0').filter(Boolean).map((l) => l.slice(3));
+}
+/** Commit de `paths` seuls (à chemin explicite : le reste de l'index n'y entre pas). Rend le sha court. Lève l'erreur de git (hook refusé compris). */
+export function commitPaths(root, paths, message) {
+    git(root, ['add', '--', ...paths]);
+    try {
+        git(root, ['commit', '-q', '-m', message, '--', ...paths]);
+    }
+    catch (e) {
+        tryGit(root, ['reset', '-q', '--', ...paths]);
+        const err = e;
+        throw new Error((err.stderr || err.stdout || err.message).trim().split('\n')[0]);
+    }
+    return tryGit(root, ['rev-parse', '--short', 'HEAD']) ?? '';
+}
+/** Remet `paths` comme à HEAD : un fichier suivi retrouve sa version commitée, un fichier que HEAD ne connaît pas est supprimé. */
+export function restorePaths(root, paths) {
+    for (const f of paths) {
+        if (tryGit(root, ['cat-file', '-e', `HEAD:${f}`]) !== null)
+            git(root, ['checkout', '-q', 'HEAD', '--', f]);
+        else
+            rmSync(resolve(root, f), { force: true });
+    }
+}
+/** Un fichier SUIVI est-il modifié (indexé ou non) ? Les fichiers non suivis ne comptent pas : un commit à chemins explicites ne les embarque pas. `except` : chemins qu'on ne compte pas. */
+export function hasTrackedChanges(cwd, except = []) {
+    return git(cwd, ['status', '--porcelain', '--untracked-files=no', '--', '.', ...except.map((f) => `:(exclude)${f}`)]).trim() !== '';
+}
+/** Le tag existe-t-il (local) ? */
+export function tagExists(cwd, tag) {
+    return git(cwd, ['tag', '--list', tag]).trim() !== '';
+}
+/** Branche courante, ou null sur un HEAD détaché. */
+export function currentBranch(cwd) {
+    const name = git(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+    return name === 'HEAD' ? null : name;
+}

package/dist/lead.js

@@ -12,6 +12,7 @@ import { priorityRank, readPriority } from './orchestrate/continue.js';
 import { readNext, sharedStateDir, stateDir } from './state.js';
 import { freeLine, readyFree } from './ready-free.js';
 import { cadenceHome } from './orchestrate/registry.js';
+import { staleNotes, staleText } from './stale-notes.js';
 import { noTestGate, noTestText } from './orchestrate/no-test.js';
 import { KEPT_TITLE, keptLine, keptTrees } from './orchestrate/worktree.js';
 /** Clé `lead.ux` du cadence.yaml du dossier parent (L197) : qui pose le verdict UX (`raf ux`) d'un lot visible. `human` (défaut) : l'humain ; `lead` : le lead, l'humain n'étant consulté qu'en cas de doute. */
@@ -123,6 +124,9 @@ export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
         });
         row.drift = audit(plan, root, join(root, 'docs/nouveautes'), today).map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`);
         row.notes = readNext(stateDir(root))?.lines ?? [];
+        const stale = [...new Set(staleNotes(row.notes, lots).flatMap((n) => n.stale))];
+        if (stale.length)
+            row.staleNotes = stale;
         const counted = lots.filter((l) => l.status !== 'dropped' && l.every === undefined);
         row.progress = {
             done: counted.filter((l) => l.status === 'done').length,
@@ -213,7 +217,7 @@ export function tourLine(r) {
     const drift = r.drift.length
         ? `${r.drift.length} (${r.drift.slice(0, DRIFT_SHOWN).join(' ; ')}${r.drift.length > DRIFT_SHOWN ? ' ; …' : ''})`
         : 'aucune';
-    const notes = r.notes.length ? truncate(r.notes.join(' / '), NOTES_MAX) : 'aucune';
+    const notes = r.notes.length ? `${truncate(r.notes.join(' / '), NOTES_MAX)}${r.staleNotes ? ` ${staleText(r.staleNotes)}` : ''}` : 'aucune';
     const next = r.next ? `${r.next.id} ${truncate(r.next.title, TITLE_MAX)}` : 'aucun';
     return [r.project, `en cours ${doing}`, `dérive ${drift}`, `notes : ${notes}`, `prochain ${next}`, ...(r.waiting?.length ? [`attend ${r.waiting.join(', ')}`] : []), `dépôt ${r.repo.length ? r.repo.join(', ') : 'propre'}`].join(' · ');
 }

package/dist/orchestrate/accept.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, posix } from 'node:path';
 import { parse } from 'yaml';
@@ -180,6 +180,68 @@ export function resealAcceptation(repo, path, test, reason, today, porteur, refs
     writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
     return { avant, apres, lot: a.lot, ...(ficheAmendee ? { ficheAmendee } : {}) };
 }
+/** Les acceptations de `dir` à `vert: false` au HEAD : leur chemin et le lot qu'elles portent. Un fichier illisible n'en est pas une. */
+export function redAcceptations(repo, dir) {
+    const out = [];
+    for (const path of listAcceptations(repo, dir).sort()) {
+        try {
+            const a = parseAcceptation(readFileSync(join(repo, path), 'utf8'));
+            if (typeof a !== 'string' && !a.vert)
+                out.push({ path, lot: a.lot });
+        }
+        catch {
+            // illisible ou absent de l'arbre de travail : le verrou en parle, pas ce signalement
+        }
+    }
+    return out;
+}
+/**
+ * La commande dédiée (`orchestrate.accept`) lancée à la main, sous les mêmes règles que le cycle (`runAccept`) : chaque commande dont la racine contient un fichier listé,
+ * `{acceptation}` substitué, `CADENCE_ACCEPTATION` et `CADENCE_ACCEPTATION_ROOT` posés. Un fichier listé sous la racine d'aucune commande est rendu (`orphans`) sans rien lancer.
+ */
+export function runAcceptation(repo, json, accept) {
+    const abs = join(repo, json);
+    const doc = parseAcceptation(readFileSync(abs, 'utf8'));
+    const plan = planAcceptRuns(acceptCommands(accept), typeof doc === 'string' ? [] : doc.fichiers, !isAcceptList(accept));
+    if (plan.orphans.length)
+        return { runs: [], orphans: plan.orphans };
+    const runs = plan.runs.map((r) => {
+        const done = spawnSync('sh', ['-c', r.command.replaceAll('{acceptation}', abs)], { cwd: repo, encoding: 'utf8', timeout: 30 * 60_000, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, CADENCE_ACCEPTATION: abs, CADENCE_ACCEPTATION_ROOT: r.root || '.' } });
+        return { command: r.command, code: done.status ?? 1, output: `${done.stdout ?? ''}${done.stderr ?? ''}${done.error ? done.error.message : ''}` };
+    });
+    return { runs, orphans: [] };
+}
+/**
+ * `cadence spec green` (L366) : la commande d'acceptation vient de passer au vert sur les tests tels qu'ils sont. Ceux qu'un lot mené à la main a mis au point
+ * après le commit rouge ont une empreinte scellée périmée : le verrou les signalerait encore à chaque lot suivant. Chaque empreinte différente est refaite et
+ * journalisée dans `resceaux` (comme `spec reseal`, sans fiche amendée) ; le commit qui pose `vert: true` devient ainsi le commit rouge. Rend les tests rescellés.
+ * L'appelant s'est assuré que les tests listés sont commités (l'empreinte rescellée est celle de l'arbre de travail) ; un test absent est refusé.
+ */
+export function resealForGreen(repo, path, today) {
+    const file = join(repo, path);
+    const a = parseAcceptation(readFileSync(file, 'utf8'));
+    if (typeof a === 'string')
+        throw new Error(`${path} : ${a}`);
+    const fichiers = a.fichiers.map((f) => posix.normalize(f));
+    const absents = fichiers.filter((f) => !existsSync(join(repo, f)));
+    if (absents.length)
+        throw new Error(`test(s) listé(s) absent(s) de ${path} : ${absents.join(', ')}`);
+    const doc = JSON.parse(readFileSync(file, 'utf8'));
+    const empreintes = isObj(doc.empreintes) ? doc.empreintes : {};
+    const journal = Array.isArray(doc.resceaux) ? doc.resceaux : [];
+    const refaits = fichiers.filter((f) => empreintes[f] !== git(repo, 'hash-object', '--', f).trim());
+    for (const f of refaits) {
+        const apres = git(repo, 'hash-object', '--', f).trim();
+        journal.push({ test: f, raison: 'cadence spec green : tests mis au point après le commit rouge, acceptation verte sur ces tests', date: today, avant: empreintes[f] ?? '', apres });
+        empreintes[f] = apres;
+    }
+    if (refaits.length) {
+        doc.empreintes = empreintes;
+        doc.resceaux = journal;
+        writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
+    }
+    return refaits;
+}
 /** Pose `vert: true` dans le fichier (le cycle, jamais une session) ; le commit est à faire. */
 export function setVert(repo, path) {
     const file = join(repo, path);

package/dist/orchestrate/baseline.js

@@ -49,6 +49,42 @@ export function failedTests(output) {
     }
     return [...found].sort();
 }
+/** Fichiers de test qui ne se chargent pas (vitest « FAIL  a.test.ts [ a.test.ts ] »), triés, sans doublon : les échecs que `failedTests` laisse de côté faute de test à nommer. */
+export function unloadedSuites(output) {
+    const found = new Set();
+    for (const raw of output.replace(ANSI, '').split('\n')) {
+        if (!FILE_LOAD_FAIL.test(raw))
+            continue;
+        const name = raw.replace(/^\s*FAIL\s+/, '').replace(/\s+\[[^\]]*\]\s*$/, '').trim();
+        if (name)
+            found.add(name);
+    }
+    return [...found].sort();
+}
+/** Sortie sans les séquences de couleur du lanceur. */
+export const stripAnsi = (s) => s.replace(ANSI, '');
+/**
+ * jest : le fichier de chaque « ● Suite › test » et de chaque ligne « FAIL projet fichier » (nom rouge à part entière avec displayName), celui de la dernière ligne `FAIL fichier` qui le précède dans la même sortie (L354). Un test jest ne porte pas son fichier dans son nom ;
+ * sans cette lecture on ne saurait pas quel fichier rejouer pour lui, ni si le rejeu l'a couvert.
+ */
+export function jestTestFiles(output) {
+    const files = new Map();
+    let file = null;
+    for (const raw of stripAnsi(output).split('\n')) {
+        const f = /^\s*(PASS|FAIL)\b(.*)$/.exec(raw);
+        if (f) {
+            // « FAIL src/a.test.ts », « FAIL src/a.test.ts (6.21 s) » (jest ajoute la durée au-delà de 5 s : un fichier lent sous charge) ou « FAIL projet src/a.test.ts » (displayName) : le fichier est le dernier mot. Toute autre ligne PASS/FAIL ne désigne aucun fichier : ne pas garder le précédent.
+            const last = f[1] === 'FAIL' ? f[2].replace(/\s*\([^)]*\)\s*$/, '').trim().split(/\s+/).pop() ?? '' : '';
+            file = /^[^\s|]+\.\w+$/.test(last) ? last : null;
+            if (file)
+                files.set(clean(f[2]), file); // « FAIL projet fichier » est lui-même un nom rouge (failedTests) : son fichier est le sien
+        }
+        const t = /^\s*●\s+(.+)$/.exec(raw);
+        if (t && file)
+            files.set(clean(t[1]), file);
+    }
+    return files;
+}
 /** Échecs d'après le lot qui n'étaient pas rouges au départ (`nouveaux`) et ceux qui l'étaient déjà (`existants`). */
 export function compareBaseline(now, base) {
     const was = new Set(base);
@@ -56,11 +92,11 @@ export function compareBaseline(now, base) {
 }
 /**
  * Un échec que la sortie ne rattache à aucun test : erreur non gérée (vitest « Unhandled Errors », promesse rejetée), fichier de spec qui ne se charge plus (jest « Test suite failed to run », vitest « FAIL  a.test.ts [ a.test.ts ] » : le FAIL de fichier existait peut-être au départ), seuil de
- * couverture non atteint. Comparer les seuls noms lus le masquerait derrière d'anciens échecs : l'appelant garde les tests pour rouges.
+ * couverture non atteint. `loadFailsNamed` : l'appelant nomme déjà les fichiers qui ne se chargent pas (`unloadedSuites`), ils ne comptent plus comme échec sans nom. Comparer les seuls noms lus le masquerait derrière d'anciens échecs : l'appelant garde les tests pour rouges.
  */
-export function hasUnnamedFailure(output) {
+export function hasUnnamedFailure(output, loadFailsNamed = false) {
     const text = output.replace(ANSI, '');
-    if (text.split('\n').some((l) => FILE_LOAD_FAIL.test(l)))
+    if (!loadFailsNamed && text.split('\n').some((l) => FILE_LOAD_FAIL.test(l)))
         return true;
     return /Unhandled (?:Errors?|Rejections?)|Test suite failed to run|caught \d+ unhandled|coverage threshold|Coverage for \w+ \([\d.]+%\) does not meet/i.test(text);
 }

package/dist/orchestrate/briefs.js

@@ -109,7 +109,7 @@ export function loadTemplates(dir = TEMPLATES_DIR) {
 export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     const text = typeof source === 'string' ? loadTemplates(source)[kind] : source[kind];
     const out = text.replace(/\{\{(\w+)\}\}/g, (_m, name) => {
-        const v = { ...vars, repos: vars.repos ?? '', integration: vars.integration ?? '', docs: vars.docs ?? '', elsewhere: vars.elsewhere ?? '', ack: vars.ack ?? '', spec: vars.spec ?? '', accept: vars.accept ?? '', maquette: vars.maquette ?? '', tmp: vars.tmp ?? '', shots: vars.shots ?? '', fiche: vars.fiche ?? '', lecture: vars.lecture ?? PLAN_READING }[name];
+        const v = { ...vars, repos: vars.repos ?? '', integration: vars.integration ?? '', docs: vars.docs ?? '', elsewhere: vars.elsewhere ?? '', ack: vars.ack ?? '', spec: vars.spec ?? '', decisions: vars.decisions ?? '', accept: vars.accept ?? '', maquette: vars.maquette ?? '', tmp: vars.tmp ?? '', workers: vars.workers ?? '', shots: vars.shots ?? '', fiche: vars.fiche ?? '', lecture: vars.lecture ?? PLAN_READING }[name];
         if (v === undefined)
             throw new RafError(`gabarit ${FILES[kind]} : valeur manquante pour {{${name}}}`);
         return v;