@sylad/cadence 1.12.1 → 1.14.1

package/dist/orchestrate/changelog-merge.js

@@ -1,5 +1,6 @@
 /** Ordre des sections de Keep a Changelog ; un titre inconnu vient après, dans l'ordre où il apparaît. */
 const SECTION_ORDER = ['Added', 'Changed', 'Deprecated', 'Removed', 'Fixed', 'Security'];
+const rank = (s) => (SECTION_ORDER.includes(s) ? SECTION_ORDER.indexOf(s) : SECTION_ORDER.length);
 /** Découpe le fichier autour de `## [Unreleased]` : ce qui précède (titre compris), le bloc, ce qui suit à partir de la version suivante. */
 function split(text) {
     const lines = text.split('\n');
@@ -84,7 +85,6 @@ export function mergeUnreleased(base, ours, theirs, start) {
         }
     }
     const titles = [...new Set([...os.keys(), ...ts.keys()])];
-    const rank = (s) => (SECTION_ORDER.includes(s) ? SECTION_ORDER.indexOf(s) : SECTION_ORDER.length);
     titles.sort((x, y) => rank(x) - rank(y));
     const body = titles.map((title) => {
         const entries = [...new Set([...(os.get(title) ?? []).filter((e) => !own.has(e)), ...(ts.get(title) ?? [])])];
@@ -92,3 +92,42 @@ export function mergeUnreleased(base, ours, theirs, start) {
     });
     return `${head}\n\n${body.join('\n')}\n${tail}`;
 }
+/** Entrées du bloc `[Unreleased]` de `text`, par section ; null sans bloc ou avec du texte hors entrée. */
+function unreleasedEntries(text) {
+    const s = split(text);
+    return s ? sections(s.block) : null;
+}
+/**
+ * Replace sous `[Unreleased]` les entrées du lot qu'une publication de la branche a laissées sous une version (L362). `lotTip` : le CHANGELOG du sommet du lot
+ * avant le rebase, `start` celui de son point de départ — une entrée de `[Unreleased]` du premier absente du second est au lot — et `main` celui de la
+ * branche du dépôt : une entrée déjà dans sa partie publiée n'a pas été glissée là par le rebase, elle reste. `rebased` : le CHANGELOG après le rebase.
+ * Rend le texte corrigé et le nombre d'entrées déplacées, ou null quand il n'y a rien à déplacer (ou que le fichier n'a pas la forme attendue).
+ */
+export function moveToUnreleased(rebased, lotTip, start, main) {
+    const [r, mainSplit] = [split(rebased), split(main)];
+    const [tip, was] = [unreleasedEntries(lotTip), unreleasedEntries(start)];
+    const [now, published] = [sections(r?.block ?? []), mainSplit ? mainSplit.tail : ''];
+    if (!r || !tip || !was || !now)
+        return null;
+    const known = new Set([...was.values()].flat());
+    let tail = r.tail;
+    let moved = 0;
+    const added = new Map();
+    for (const [title, entries] of tip) {
+        for (const e of entries) {
+            if (known.has(e) || published.includes(e) || (now.get(title) ?? []).includes(e) || !tail.includes(e))
+                continue;
+            tail = tail.replace(`${e}\n`, '');
+            added.set(title, [...(added.get(title) ?? []), e]);
+            moved++;
+        }
+    }
+    if (moved === 0)
+        return null;
+    tail = tail.replace(/^### .+\n\n(\n|$)/gm, '');
+    for (const [title, entries] of added)
+        now.set(title, [...(now.get(title) ?? []), ...entries]);
+    const titles = [...now.keys()].sort((x, y) => rank(x) - rank(y));
+    const body = titles.map((title) => `### ${title}\n\n${(now.get(title) ?? []).join('\n')}\n`);
+    return { text: `${r.head}\n\n${body.join('\n')}\n${tail}`, moved };
+}

package/dist/orchestrate/command.js

@@ -1,9 +1,11 @@
 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 { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readOrchestrateConfig, readPlanConfig } from '../config.js';
+import { PLAN_ACTIONS, commitMsgHook, leadAnswerMessage, commitMsgRefusal, planCommitMessage } from '../plan-commit.js';
 import { isDay, toDay } from '../dates.js';
 import { gitRoot } from '../git.js';
 import { onTermination } from '../proc.js';
@@ -14,17 +16,19 @@ 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';
+import { acceptationFile, acceptText, redAcceptations } from './accept.js';
 import { noTestGate, noTestText } from './no-test.js';
 import { ficheReviewText } from './fiche.js';
 import { maquetteText } from './maquette.js';
-import { specScreen, specText } from './spec.js';
+import { costlyHypotheses, specScreen, specText } from './spec.js';
+import { fichesDuDossier } 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 { buildArgs, buildLocalArgs, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { groupLots, runPool } from './pool.js';
 import { repoBranch } from './integrate.js';
@@ -64,7 +68,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 +81,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);
@@ -98,15 +107,12 @@ export function parseMaxSessions(text, what = '--max-sessions') {
     return Number(text);
 }
 // une vague (2026-10-04-1412) n'a ni « : » ni « / » : leur présence désigne un lot, quel que soit son motif (R-M7/ux-1)
-const LOT_LIKE = /^(?:[\w.-]+(?:\/[\w.-]+)*:[\w.-][\w./-]*|[\w.-]+\/[\w./-]*|[A-Za-z]+\d+)(?:@\w+)?$/;
-const MODELS = ['sonnet', 'opus', 'haiku'];
+const LOT_LIKE = /^(?:[\w.-]+(?:\/[\w.-]+)*:[\w.-][\w./-]*|[\w.-]+\/[\w./-]*|[A-Za-z]+\d+)(?:@[\w.-]+)?$/;
 function lotArg(text) {
     // le premier « : » sépare le projet du lot, un « @ » final le modèle ; le lot garde ses « / » (L120), le projet peut être un chemin depuis le dossier (`groupe/gamma`, projet imbriqué de lead tour --depth, L201)
-    const m = /^(?:([\w.-]+(?:\/[\w.-]+)*):)?([\w.-][\w./-]*?)(?:@(\w+))?$/.exec(text);
+    const m = /^(?:([\w.-]+(?:\/[\w.-]+)*):)?([\w.-][\w./-]*?)(?:@([\w.-]+))?$/.exec(text);
     if (!m)
-        throw new RafError(`lot invalide : ${text} (projet:lot, lot, projet:lot@haiku)`);
-    if (m[3] && !MODELS.includes(m[3]))
-        throw new RafError(`modèle inconnu : @${m[3]} (attendu : ${MODELS.join(', ')})`);
+        throw new RafError(`lot invalide : ${text} (projet:lot, lot, projet:lot@haiku ; @ suivi d'un alias ou d'un nom de modèle)`);
     return { project: m[1], lot: m[2], model: m[3] };
 }
 /** `projet:lot=+200k`, `lot=+0.3M` (L223) : le « = » distingue le relèvement d'un lot du budget de la vague. */
@@ -351,7 +357,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 } : {}) };
@@ -378,12 +387,81 @@ function waveId(io, requested, launch) {
         id = `${base}-${i}`;
     return id;
 }
+/** Version du `node` que le PATH donné résout (`node --version`), null s'il n'y en a pas ou s'il ne répond pas. */
+function pathNodeVersion(env) {
+    try {
+        return execFileSync('node', ['--version'], { env: { ...process.env, ...env }, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10_000 }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** La version (`v24.1.0`) commence-t-elle par ce que demande le .nvmrc (`24`, `v24`, `24.1`) ? */
+function matchesNvmrc(version, wanted) {
+    const v = version.replace(/^v/, '');
+    const w = wanted.replace(/^v/, '');
+    return v === w || v.startsWith(`${w}.`);
+}
+/**
+ * Ce avec quoi le dry-run mesure les messages de la fiche d'un lot à étape spec (L343) : la fiche du lot quand elle est déjà écrite (son sujet pour les hypothèses
+ * notées, ses hypothèses coûteuses pour la réponse du lead, qui ne source que les règles posées en question — `costlyHypotheses` — et n'est pas commitée sans elles),
+ * sinon le sujet le plus long du dossier des fiches et autant de règles coûteuses que la fiche du dossier qui en porte le plus (1 au moins). Un sujet de 7 caractères
+ * (« <sujet> ») faisait accepter un message que `header-max-length` refuse avec un sujet réel ; toutes les hypothèses d'une fiche (13) faisaient refuser une réponse qui n'en cite que les coûteuses.
+ */
+function ficheMeasure(repo, dir, lot) {
+    const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+    const costly = (doc) => costlyHypotheses(doc).map((x) => x.id);
+    const fiches = fichesDuDossier(repo, dir);
+    const mine = fiches.find(({ doc }) => (isObj(doc.sujet) && doc.sujet.lot === lot) || (isObj(doc.ecran) && doc.ecran.lot === lot));
+    if (mine) {
+        const sujet = isObj(mine.doc.sujet) && typeof mine.doc.sujet.id === 'string' ? mine.doc.sujet.id : mine.name;
+        const regles = costly(mine.doc);
+        const about = regles.length ? `réponse du lead mesurée avec ${regles.length > 1 ? 'les règles coûteuses' : 'la règle coûteuse'} ${regles.join(', ')}` : 'aucune hypothèse coûteuse : pas de réponse du lead à commiter';
+        return { sujet, regles, line: `  fiche du lot : ${dir}/${mine.name}/fiche.yaml (${about})` };
+    }
+    if (!fiches.length)
+        return { sujet: '<sujet>', regles: ['R1'], line: `  aucune fiche dans ${dir} : les messages de la fiche sont mesurés avec « <sujet> » (7 caractères) et 1 règle ; un sujet réel plus long peut dépasser une limite du hook` };
+    const sujet = fiches.map((f) => f.name).reduce((a, b) => (b.length > a.length ? b : a));
+    const n = Math.max(1, ...fiches.map((f) => costly(f.doc).length));
+    return { sujet, regles: Array.from({ length: n }, (_, i) => `R${i + 1}`), line: `  fiche du lot pas encore écrite : mesure avec le sujet le plus long de ${dir} (${sujet}) et ${n} règle(s) coûteuse(s) pour la réponse du lead` };
+}
+/**
+ * Les messages de commit de plan que la vague écrirait pour ce lot, passés au hook commit-msg réel du dépôt : un refus se lit ici, avant une vague payante (L343).
+ * Les messages de la fiche (hypothèses, mineurs de sa revue, réponse du lead) ne sont joués que pour un lot à étape spec, avec un sujet de longueur réelle (`ficheMeasure`) ;
+ * les hypothèses ne sont notées que pour un lot `spec: true` sans écran (`settleHypotheses`), la réponse du lead n'est commitée que pour une hypothèse coûteuse (`sourceAnsweredRules`).
+ */
+function planMessageLines(repo, l, wave, dir) {
+    const template = readPlanConfig(join(repo, 'cadence.yaml'), repo)?.commit;
+    const specStage = !!(l.screen || l.specLot);
+    const measure = specStage ? ficheMeasure(repo, dir, l.lot) : null;
+    const actions = [PLAN_ACTIONS.started, PLAN_ACTIONS.reviewRecorded, PLAN_ACTIONS.reviewNoted];
+    if (measure) {
+        if (l.specLot && !l.screen)
+            actions.push(PLAN_ACTIONS.hypotheses(measure.sujet));
+        actions.push(PLAN_ACTIONS.minors('la fiche'));
+    }
+    const planMessages = actions.map((action) => planCommitMessage(template, { lot: l.lot, action, wave }));
+    const messages = [...new Set(measure?.regles.length ? planMessages.concat(leadAnswerMessage(template, l.lot, measure.regles, wave)) : planMessages)];
+    const hook = commitMsgHook(repo);
+    if (!hook)
+        return template ? [`  messages de plan : « ${messages[0]} » (gabarit plan.commit ; aucun hook commit-msg dans ce dépôt)`] : [];
+    const refused = messages.map((m) => ({ m, why: commitMsgRefusal(repo, m) })).filter((r) => r.why !== null);
+    const about = measure ? [measure.line] : [];
+    if (!refused.length)
+        return [`  messages de plan : ${messages.length} message(s) acceptés par le hook commit-msg du dépôt (${hook})${template ? ' — gabarit plan.commit' : ''}`, ...about];
+    return [
+        ...refused.map((r) => `  ✗ message de plan refusé par le hook commit-msg : « ${r.m} » — ${r.why}`),
+        ...about,
+        `  ✗ le lot échouerait au premier commit de plan refusé, avant ou pendant ses sessions : régler plan.commit dans cadence.yaml (gabarit avec {lot}, {action}, {vague})`,
+    ];
+}
 function dryRun(lots, io, deps, budget, id) {
     const tmp = mkdtempSync(join(tmpdir(), 'cadence-orchestrate-'));
     const agents = agentsOf(deps);
     io.out(`vague ${id} — simulation, rien n'est lancé (budget ${budget} tokens comptés)`);
     const repos = [...new Set(lots.map((l) => l.repo))];
     const noTestSaid = new Set();
+    const redSaid = new Set();
     for (const l of lots) {
         const env = projectEnv(l.repo);
         const lot = env.loadPlan().lot(l.lot);
@@ -391,7 +469,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'}`);
@@ -401,6 +479,10 @@ function dryRun(lots, io, deps, budget, id) {
             const sk = l.node.skipped;
             const skipped = sk?.length ? ` ; ${sk.join(', ')} ${sk.length > 1 ? 'écartées' : 'écartée'} : pas de node exécutable` : '';
             io.out(`  node : ${l.node.version} (.nvmrc ${l.node.wanted}${skipped})`);
+            const gate = env.config.test || env.config.build;
+            const onPath = gate ? (deps.pathNode ?? (() => pathNodeVersion(io.env)))() : null;
+            if (onPath && !matchesNvmrc(onPath, l.node.wanted))
+                io.out(`  ⚠ .nvmrc ${l.node.wanted} ≠ node du PATH ${onPath} : la porte et les autres commandes du programme tournent sous ${l.node.version} (lien node-bin en tête du PATH), pas sous ${onPath}`);
         }
         const steps = [{ kind: 'implement', model: l.model }];
         const specStage = !!(l.screen || l.specLot);
@@ -428,15 +510,31 @@ function dryRun(lots, io, deps, budget, id) {
                 steps.push({ kind: 'ux', model: full }); // L221 : l'UX est jouée une fois, après la revue de code conforme
         }
         io.out(`  étapes : ${steps.map((s) => `${s.kind} (${s.model})`).join(' → ')}${l.small ? ' — petit lot' : ''}${l.light ? ` — revue légère (${light}, pas de passe des mineurs ; un bloquant ou un majeur → correction puis revue ${full})` : ''}${l.visible && !env.config.ux ? ' — UX à faire par le lead (orchestrate.ux absent)' : ''}`);
+        for (const m of new Set(steps.map((s) => s.model))) {
+            if (m !== 'local' && !MODEL_ALIASES.includes(m))
+                io.out(`  ⚠ modèle « ${m} » hors des alias ${MODEL_ALIASES.join(', ')} : passé tel quel à claude --model (un nom que le compte ne connaît pas fait échouer la session)`);
+        }
+        for (const line of planMessageLines(l.repo, l, id, env.config.spec.dir))
+            io.out(line);
         const noTest = noTestSaid.has(l.repo) ? null : noTestGate(l.repo);
         noTestSaid.add(l.repo);
         if (noTest)
             io.out(`  ${basename(l.repo)} · ${noTestText(noTest)}`);
+        if (!redSaid.has(l.repo)) {
+            redSaid.add(l.repo);
+            // L366 : l'acceptation à vert: false d'un lot clos à la main verrouille ses tests pour tous les lots du dépôt, sans que ce lot y ait touché.
+            const closed = new Set(env.loadPlan().lots().filter((x) => x.status === 'done').map((x) => x.id));
+            for (const red of redAcceptations(l.repo, env.config.spec.dir)) {
+                if (closed.has(red.lot))
+                    io.out(`  ⚠ ${basename(l.repo)} · acceptation rouge d'un lot clos : ${red.lot} (${red.path}, vert: false) — le verrou des tests d'acceptation peut bloquer les lots de la vague ; cadence spec green ${red.lot}`);
+            }
+        }
         io.out(`  corrections : ${MAX_PASSES} passe(s) au plus (${MAX_PASSES_CONVERGING} si la revue converge), en session neuve`);
         io.out(l.light ? '  revue conforme avec mineurs : pas de passe des mineurs, ils sont rendus en notes' : '  revue conforme avec mineurs : une passe de correction des mineurs (session neuve), puis une revue courte ; les mineurs refusés sont rendus en « choix »');
         const pwDir = join(resolve(RunStore.runsDir(io.cwd)), id, lotSlug(l.project, l.lot), 'playwright');
         // brief écrit par --dry-run = base d'une délégation à la main : aucun dossier de vague (il n'existe pas)
         const vars = { chemin: l.repo, lot: l.lot, titre: 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 +1152,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 +1163,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 +1404,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 +1428,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 });
         }