@sylad/cadence 1.12.1 → 1.13.0

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "cadence",
       "description": "Session start and close rituals driven by a versioned plan (raf), and deliveries proven by their effect. Needs the cadence CLI (npm i -g @sylad/cadence).",
-      "version": "1.12.1",
+      "version": "1.13.0",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "description": "A repo-native working method: session start and close rituals driven by a versioned plan (raf), deliveries proven by their effect, and three reviewer agents (UX, code, QA).",
-  "version": "1.12.1",
+  "version": "1.13.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/bin/cadence.js

@@ -13,7 +13,7 @@ const io = {
 
 if (tool === 'raf') {
   process.exitCode = await run(args, io);
-} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead', 'corrections', 'perf', 'spec', 'ref'].includes(tool)) {
+} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead', 'corrections', 'perf', 'spec', 'ref', 'config', 'release'].includes(tool)) {
   process.exitCode = await run([tool, ...args], io);
 } else if (tool === '--version' || tool === '-v') {
   const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
@@ -39,6 +39,9 @@ if (tool === 'raf') {
   cadence ref measure <slug> <page> <page | x,y | x,y,l,h> [--quoi couleurs|contraste|boites|texte] [--largeur 1440] [--json]
                     mesure une zone d'une page rendue : couleurs, contraste WCAG 2.2, boîtes, mots OCR et taille de police estimée,
                     ramenés à 1440 px de large, tolérance déclarée
+  cadence release patch|minor|major [--dry-run]
+                    prépare le commit de version (fichiers de version, CHANGELOG) sans rien commiter ni publier ;
+                    imprime les étapes du lead dans l'ordre et vérifie docs/whats-new.md
   cadence verify [--retry secondes] [--sha rév]
                     rejoue les vérifications d'effet (deliver.verify) hors livraison, une passe, en parallèle ;
                     code 0 tout vert, 1 un effet rouge, 2 rien à vérifier ; « session start » la lance aussi
@@ -52,6 +55,10 @@ if (tool === 'raf') {
   cadence lead tour [dossier] [--idle 3] [--json]
                     le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier courant
                     s'il est lui-même un projet ; une première ligne « cadence.yaml · ✗ erreur » si priority: est illisible
+  cadence config set <clé> <valeur> --all [--dry-run] [--depth n]
+                    pose la même clé dans le cadence.yaml de chaque projet du dossier (ceux de lead tour), commentaires et ordre gardés,
+                    avec un lot de config qui la cite et un commit à chemin explicite par projet ; ne pousse pas ;
+                    s'arrête sur une config qui ne se relit pas
   cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--since date] [--json]
                     la mesure des passes de correction des vagues (dossier/.cadence/runs) : lots à ≥1 et ≥2 corrections,
                     par projet, visibles ou non, passes par cause ; --classify les classe par Ollama (hors quota)

package/dist/cli.js

@@ -18,7 +18,8 @@ import { invalidResource, Plan, RafError, SCREENS, STATUSES } from './plan.js';
 import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
-import { findProjects, leadTour, readLeadUx, tourFreeLine, tourLine, tourNoTestLines, tourWorktreeLines } from './lead.js';
+import { configSet } from './config-set.js';
+import { findProjects, readDepth, leadTour, readLeadUx, tourFreeLine, tourLine, tourNoTestLines, tourWorktreeLines } from './lead.js';
 import { configuredCap, expiredHoldLines, liveLines, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { addHold, releaseHold } from './orchestrate/registry.js';
 import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
@@ -28,6 +29,7 @@ import { classifyAll, measure, ollamaClassifier, readCache, readJournals, readRu
 import { computePerf, perfHeader, perfWindows, readPlans, readProjectDeliveries, readProjectFailedEntries, renderPerf } from './perf.js';
 import { findAcceptation, parseAcceptation, resealAcceptation } from './orchestrate/accept.js';
 import { refCommand } from './ref/command.js';
+import { release } from './release.js';
 import { applyMigration, describeMigration, planMigration, unhandledError } from './migrate.js';
 import { checkFiche, deriveQa, readFiche, summary } from './spec.js';
 import { readHudContext } from './hud-context.js';
@@ -59,6 +61,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot (ou citant un id inconnu) sans réécrire l'historique ; raf check --ignored les liste
   raf docs-ok <lot> --reason texte   acquitte l'écart docs.sync d'un lot (documentation en retard) avec la raison pour laquelle la documentation reste telle quelle ; lu par raf check et par orchestrate, qui ne rend jamais prêt un lot avec un écart ouvert
   raf gantt [-o .cadence/gantt.html]
+  cadence config set <clé> <valeur> --all [--dry-run] [--depth n]   pose la même clé dans le cadence.yaml de chaque projet du dossier (ceux de lead tour), commentaires et ordre gardés, un lot de config qui la cite (raf add + start) et un commit à chemin explicite par projet ; ne pousse pas ; liste ce qui est fait et sauté (dépôt sale, déjà posée, plan en lecture seule) ; s'arrête sur une config qui ne se relit pas
   raf migrate [--dry-run]   déplace docs/plan/raf.yaml vers .cadence/raf.yaml (git mv) et réécrit les lecteurs du chemin dans le dépôt ; --dry-run les liste sans rien toucher ; refus tant qu'un lecteur n'est pas traité (migrate.keep de cadence.yaml pour ceux qui ne lisent pas le plan) ; rejouable
   raf hook install      (pre-commit et post-commit ; cadence.yaml hook.autostart: warn|refuse|start)
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--goal "…"] [--dry-run] [--wave nom] [--continue [--until HH:MM] [--priority a,b]]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague | --wave vague] [--budget 1M] [--budget projet:lot=+300k] [--answer projet:lot "réponse"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague] ; --waits [--since AAAA-MM-JJ]
@@ -74,6 +77,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   cadence ref check <inventaire.json | lecture.json>   valide un inventaire ou une lecture (schéma version 1, modèle templates/inventaire.json) : une ligne « ✗ chemin : raison » par écart puis « N écart(s) » sur la sortie standard (code 1), le résumé par type sinon (code 0) ; fichier absent, vide ou illisible : code 2 ; n'appelle aucun outil système
   cadence ref eval <attendu.json | dossier> <lecture.json | dossier> [--json]   note une lecture contre l'inventaire attendu (vérité connue) : rappel et précision par type, faux lu (éléments sûrs et faux), pièges trouvés, tokens par page (usage.tokens de la lecture) ; lecture d'un autre document refusée (code 2) ; sur dossiers, un cas par sous-dossier (attendu.json / lecture.json)
   cadence ref corpus <dossier> [--sans-rendu]   écrit le corpus synthétique à vérité connue (7 pièges : texte ambigu levé par une figure, figure qui contredit, table en image, gabarit BUFR, contrôle translucide, page Proposal, scan bruité) : par cas document.html et attendu.json, puis document.pdf et page-<n>.png (1700×2200) rendus par Playwright (CADENCE_PLAYWRIGHT = dossier du paquet) ; dossier existant ou Playwright introuvable : code 2
+  cadence release patch|minor|major [--dry-run]   prépare le commit de version (package.json, package-lock.json, plugin.json, marketplace.json, CHANGELOG.md) sans commiter ni publier ; imprime les étapes du lead et vérifie docs/whats-new.md : refus sur un arbre sale, un [Unreleased] vide ou une version déjà taguée
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
@@ -194,7 +198,7 @@ function dispatch(argv, io) {
         io.out(HELP);
         return 0;
     }
-    if (command !== 'session' && !(command === 'lead' && !values.all) && (values.all || values.depth !== undefined))
+    if (command !== 'session' && command !== 'config' && !(command === 'lead' && !values.all) && (values.all || values.depth !== undefined))
         throw new RafError(`${values.all ? '--all' : '--depth'} ne va qu'avec session start ou session close`);
     const today = io.env.RAF_TODAY ?? toDay(io.now());
     if (!isDay(today))
@@ -263,12 +267,29 @@ function dispatch(argv, io) {
         }
         return 0;
     }
+    // Poser une clé dans le cadence.yaml de chaque projet du dossier (L342) : ne lit ni le plan ni le cadence.yaml du dossier courant.
+    if (command === 'config') {
+        if (rest[0] !== 'set' || rest.length !== 3)
+            throw new RafError('usage : cadence config set <clé> <valeur> --all [--dry-run] [--depth n]');
+        if (!values.all)
+            throw new RafError('config set demande --all : la commande s\'applique aux projets du dossier courant (lancer la commande dans le projet visé pour un seul)');
+        if (values.depth !== undefined && !(Number.isInteger(Number(values.depth)) && Number(values.depth) >= 1))
+            throw new RafError(`--depth invalide : ${values.depth} (un entier ≥ 1)`);
+        const parent = resolve(io.cwd);
+        const result = configSet(parent, rest[1], rest[2], { dryRun: values['dry-run'], depth: values.depth === undefined ? readDepth(parent) : Number(values.depth) }, today);
+        for (const l of result.lines)
+            io.out(l);
+        return result.code;
+    }
     if (command === 'corrections')
         return corrections(rest, values, io);
     if (command === 'perf')
         return perf(rest, values, today, io);
     if (command === 'ref')
         return refCommand(rest, values, root, io);
+    // Prépare le commit de version : écrit les fichiers de version, ne commite ni ne publie rien (L341).
+    if (command === 'release')
+        return release(rest, !!values['dry-run'], root, today, io.out);
     // Déplacer le plan ne lit pas le plan : pas d'avertissement « ancien emplacement » (L284).
     if (command === 'migrate') {
         if (rest.length > 0)

package/dist/config-set.js

@@ -0,0 +1,249 @@
+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 } 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 dirty = dirtyPaths(dir, ['cadence.yaml', planRel]);
+        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');
+        const restore = () => {
+            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], `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

@@ -5,7 +5,7 @@ import { isDay } from './dates.js';
 import { DEFAULT_TEST_PATTERNS } from './testgate.js';
 import { gitRoot } from './git.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'];
 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)]);
@@ -88,7 +88,9 @@ export function readPlanConfig(file, root) {
         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}');
+    return { ...(p.path != null ? { path: String(p.path) } : {}), ...(p.add != null ? { add: String(p.add) } : {}), settings };
 }
 export const PLAN_DEFAULT = '.cadence/raf.yaml';
 export const PLAN_LEGACY = 'docs/plan/raf.yaml';

package/dist/corrections.js

@@ -118,6 +118,7 @@ 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.warnings) && rec.warnings.some((w) => typeof w === 'string' && w.startsWith(LOCAL_PRECHECK_UNREADABLE)) ? { localUnreadable: true } : {}),

package/dist/git.js

@@ -212,3 +212,34 @@ 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']) ?? '';
+}
+/** 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/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;

package/dist/orchestrate/command.js

@@ -1,7 +1,8 @@
 import { gateProgress, gateText } from '../audit.js';
 import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { homedir, tmpdir } from 'node:os';
+import { availableParallelism, homedir, tmpdir } from 'node:os';
+import { testWorkersFrom } from './workers.js';
 import { basename, join, resolve } from 'node:path';
 import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readOrchestrateConfig } from '../config.js';
 import { isDay, toDay } from '../dates.js';
@@ -14,6 +15,7 @@ import { pidAlive, sharedStateDir } from '../state.js';
 import { findProjects, isProject as isLeadProject } from '../lead.js';
 import { freeLine, readyFree } from '../ready-free.js';
 import { acquireSlot, cadenceHome, expiredHolds, freeSlots, liveHolds, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
+import { decisionsText, humanDecisions } from './decisions.js';
 import { headline, loadTemplates, newsText, objective, renderBrief } from './briefs.js';
 import { readWaits, renderWaits } from './waits.js';
 import { acceptationFile, acceptText } from './accept.js';
@@ -22,7 +24,7 @@ import { ficheReviewText } from './fiche.js';
 import { maquetteText } from './maquette.js';
 import { specScreen, specText } from './spec.js';
 import { candidates, parsePriority, parseUntil, readPriority, stopReason } from './continue.js';
-import { precheckNothingToFind, Budget, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
+import { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
 import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
 import { buildArgs, buildLocalArgs, killSessions, mcpServersFor, readAgents, realClaude } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
@@ -64,7 +66,11 @@ const SCREEN_LOT_BUDGET = 1_300_000;
  */
 export const SPEC_STAGE_ALLOCATION = 450_000;
 /** Base mesurée d'un budget, pour `--dry-run` : l'estimate (et l'étape spec) d'où il sort. */
-export function lotBudgetBasis(estimate, stage) {
+export function lotBudgetBasis(estimate, stage, escalationModel) {
+    const base = ordinaryBasis(estimate, stage);
+    return escalationModel ? `${base}, plus ${ESCALATION_RESERVE} réservés à l'escalade ${escalationModel}` : base;
+}
+function ordinaryBasis(estimate, stage) {
     if (stage === 'screen' && lotBudget(estimate, stage) === SCREEN_LOT_BUDGET)
         return "p90 mesuré du total d'un lot à écran, étapes spec, maquette et accept comprises";
     const ordinary = lotBudget(estimate);
@@ -73,8 +79,9 @@ export function lotBudgetBasis(estimate, stage) {
         return basis;
     return `${ordinary} dérivés de l'estimate (${basis}), plus ${SPEC_STAGE_ALLOCATION} pour les étapes spec, ${stage === 'screen' ? 'maquette' : 'fiche'} et accept`;
 }
-/** Budget d'un lot, dérivé de son estimate et de sa catégorie : empêche quelques lots d'avaler le budget de la vague au détriment des autres. Un lot à `screen:` vaut le total mesuré d'un lot à écran (L194) ; un lot à `spec: true` y ajoute l'allocation de son étape (L191). */
-export const lotBudget = (estimate, stage) => {
+/** Budget d'un lot, dérivé de son estimate et de sa catégorie : empêche quelques lots d'avaler le budget de la vague au détriment des autres. Un lot à `screen:` vaut le total mesuré d'un lot à écran (L194) ; un lot à `spec: true` y ajoute l'allocation de son étape (L191) ; `escalation` (orchestrate.escalation déclarée) y ajoute la part de l'escalade (L349). */
+export const lotBudget = (estimate, stage, escalation = false) => lotBaseBudget(estimate, stage) + (escalation ? ESCALATION_RESERVE : 0);
+const lotBaseBudget = (estimate, stage) => {
     const ordinary = estimate <= 0.5 ? LOT_BUDGET_FLOOR : Math.max(LOT_BUDGET_ONE_DAY, Math.round(estimate * LOT_BUDGET_PER_DAY));
     if (stage === 'screen')
         return Math.max(SCREEN_LOT_BUDGET, ordinary + SPEC_STAGE_ALLOCATION);
@@ -351,7 +358,10 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             state.repos = neighbours.repos;
         state.estimate = lot.estimate;
         state.light = lot.estimate <= env.config.review.threshold;
-        state.budget = lotBudget(lot.estimate, screen ? 'screen' : lot.spec ? 'spec' : undefined);
+        const escalating = !!env.config.escalation;
+        state.budget = lotBudget(lot.estimate, screen ? 'screen' : lot.spec ? 'spec' : undefined, escalating);
+        if (escalating)
+            state.escalationReserve = ESCALATION_RESERVE;
         state.dependsOn = lot.after.filter((d) => earlier.includes(d));
         if (node.kind === 'ok')
             state.node = { version: node.version, wanted: node.wanted, bin: node.bin, ...(node.skipped ? { skipped: node.skipped } : {}) };
@@ -391,7 +401,7 @@ function dryRun(lots, io, deps, budget, id) {
         io.out(`${lotKey(l.project, l.lot)} — ${l.title}`);
         if (l.goal)
             io.out(`  objectif donné : ${l.goal} (à la place du titre dans les briefs)`);
-        io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, l.screen ? 'screen' : l.specLot ? 'spec' : undefined)})`);
+        io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, l.screen ? 'screen' : l.specLot ? 'spec' : undefined, l.escalationReserve ? env.config.escalation?.model : undefined)})`);
         const mine = lots.filter((o) => o.repo === l.repo);
         const together = env.config.worktrees && mine.length > 1 && !mine.some((o) => o.repos?.length) && !!repoBranch(l.repo);
         io.out(together ? `  file ${basename(l.repo)} · en parallèle des autres lots du dépôt, dans son worktree (cadence/${id}/${lotSlug(l.project, l.lot)}, créé à la prise du créneau)` : `  file ${basename(l.repo)} · ${slot < 2 ? `créneau ${slot + 1}` : 'en attente d\'un créneau'}`);
@@ -437,6 +447,7 @@ function dryRun(lots, io, deps, budget, id) {
         const pwDir = join(resolve(RunStore.runsDir(io.cwd)), id, lotSlug(l.project, l.lot), 'playwright');
         // brief écrit par --dry-run = base d'une délégation à la main : aucun dossier de vague (il n'existe pas)
         const vars = { chemin: l.repo, lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '' };
+        vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? env.loadPlan().lots().find((x) => x.id === lot.parent) : undefined));
         if (specStage)
             vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, back: !!l.specLot });
         if (l.screen && env.config.maquette)
@@ -1054,6 +1065,8 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         wave.budget = budget.limit;
         store.writeWave(wave);
     };
+    // Part de la machine de chaque session (L350) : recalculée à chaque (re)prise, le plafond peut avoir changé.
+    wave.testWorkers = testWorkersFrom(io.env, (deps.cores ?? availableParallelism)(), cap);
     const wctx = {
         id: wave.id,
         store,
@@ -1063,6 +1076,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         today,
         claudeHome: deps.claudeHome,
         templates,
+        testWorkers: wave.testWorkers,
         quota: { hit: false },
         incident: null,
         log: (line) => {
@@ -1303,7 +1317,7 @@ async function resume(args, argv, io, deps, launch, today) {
         else
             drops.push(lotKey(matches[0].project, matches[0].lot));
     }
-    // --resume --budget projet:lot=+N (L223) : un lot rendu sur budget est remis en jeu avec son budget relevé. Il subit ensuite les gardes d'un lot vivant.
+    // --resume --budget projet:lot=+N (L223) : un lot rendu sur budget est remis en jeu avec son budget relevé (N reste la marge des passes ordinaires : la part de l'escalade encore retenue, L349, s'y ajoute). Il subit ensuite les gardes d'un lot vivant.
     const raised = new Map();
     const answered = args.answers.map((a) => lots.filter((x) => x.lot === a.lot && (a.project ? x.project === a.project : true))).filter((m) => m.length === 1).map((m) => m[0]);
     const dropped = args.drop.map((d) => lots.filter((x) => x.lot === d.lot && (d.project ? x.project === d.project : true))).filter((m) => m.length === 1).map((m) => m[0]);
@@ -1327,7 +1341,7 @@ async function resume(args, argv, io, deps, launch, today) {
         else if (budgetStep(l) === 'fix' && b.raise <= REVIEW_RESERVE)
             refusals.push(`--budget ${key}=+${b.text} : un fix ne part qu'au-dessus de ${REVIEW_RESERVE} tokens de réserve`);
         else
-            raised.set(l, { from: l.budget ?? lotSpent(l), to: lotSpent(l) + b.raise, step: budgetStep(l) });
+            raised.set(l, { from: l.budget ?? lotSpent(l), to: lotSpent(l) + b.raise + heldForEscalation(l), step: budgetStep(l) });
     }
     // --resume --integrate projet:lot (L279, R27) : un lot rendu à l'étape d'intégration (next: integrate) n'est rejoué que si le lead le nomme. Ni --resume seul, ni --drop, --answer ou --budget ne le rejouent.
     const integ = [];

package/dist/orchestrate/continue.js

@@ -73,14 +73,17 @@ export function candidates(launch, o) {
             continue;
         }
         let specDir = 'docs/specs';
+        let escalating = false;
         try {
-            specDir = projectEnv(dir).config.spec.dir;
+            const config = projectEnv(dir).config;
+            specDir = config.spec.dir;
+            escalating = !!config.escalation;
         }
         catch {
             // configuration illisible : le dossier par défaut
         }
         for (const lot of ready) {
-            if (o.exclude.has(`${project}:${lot.id}`) || decisionPending(lot) || lotBudget(lot.estimate, specScreen(dir, specDir, lot) ? 'screen' : lot.spec ? 'spec' : undefined) > o.remaining)
+            if (o.exclude.has(`${project}:${lot.id}`) || decisionPending(lot) || lotBudget(lot.estimate, specScreen(dir, specDir, lot) ? 'screen' : lot.spec ? 'spec' : undefined, escalating) > o.remaining)
                 continue;
             out.push({ project, dir, lot });
         }