@sylad/cadence 1.13.0 → 1.14.1

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/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

@@ -4,7 +4,8 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, wri
 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';
@@ -18,15 +19,16 @@ import { acquireSlot, cadenceHome, expiredHolds, freeSlots, liveHolds, liveSlots
 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, 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';
@@ -105,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. */
@@ -388,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);
@@ -411,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);
@@ -438,10 +510,25 @@ 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');