@sylad/cadence 1.13.0 → 1.15.0

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 { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, leadReviewedHandBack, 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');
@@ -1345,6 +1432,8 @@ async function resume(args, argv, io, deps, launch, today) {
     }
     // --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 = [];
+    // L370 : un lot rendu hors de l'intégration que le lead a fait corriger puis revoir hors vague (revue conforme au dernier commit du worktree) est repris à l'intégration avec ce verdict.
+    const leadReviewed = new Map();
     const budgeted = args.lotBudgets.map((b) => lots.filter((x) => x.lot === b.lot && (b.project ? x.project === b.project : true))).filter((m) => m.length === 1).map((m) => m[0]);
     for (const t of args.integrate) {
         const matches = lots.filter((x) => x.lot === t.lot && (t.project ? x.project === t.project : true));
@@ -1364,6 +1453,15 @@ async function resume(args, argv, io, deps, launch, today) {
             refusals.push(`${opt} ${key} : lot aussi visé par --answer`);
         else if (budgeted.includes(l))
             refusals.push(`${opt} ${key} : lot aussi visé par --budget`);
+        else if (!t.replay && l.next !== 'integrate' && (() => {
+            // La revue du lead est écrite par `raf review` lancé dans le worktree : c'est le plan du worktree qui la porte, pas celui du dépôt principal.
+            const tree = lotTreeDir(store.dir, l.project, l.lot, l.repo);
+            const r = existsSync(join(tree, '.git')) ? leadReviewedHandBack(l, planLoader(tree)(), tree) : null;
+            if (r)
+                leadReviewed.set(l, r);
+            return r;
+        })())
+            integ.push(l);
         else if (l.status !== 'handed-back' || (l.next !== 'integrate' && !(t.replay && planNoteHandBack(l))))
             refusals.push(`${opt} ${key} : le lot n'est pas rendu ${t.replay ? "à l'étape d'intégration ni sur une écriture de plan refusée" : "à l'étape d'intégration"} (${l.status}, étape ${l.next ?? 'aucune'} : ${l.outcome ?? 'sans cause'})`);
         else
@@ -1458,12 +1556,20 @@ async function resume(args, argv, io, deps, launch, today) {
     }
     for (const l of integ) {
         const k = lotKey(l.project, l.lot);
+        const lead = leadReviewed.get(l);
+        if (lead) {
+            // La revue du lead tient lieu de revue du lot : le rebase reporte son verdict (même patch-id) ou joue la revue courte du diff rebasé.
+            l.next = 'integrate';
+            l.code = { conforme: true, bloquants: 0, majeurs: 0, mineurs: 0, verdict: lead.verdict, sousTaches: [], nonVerifie: [], head: lead.head };
+            l.verdict = lead.verdict;
+            l.constats = [];
+        }
         const planNote = l.next !== 'integrate'; // rendu sur une écriture de plan refusée (--replay) : le lot repart de l'étape gardée
         if (planNote && l.outcome?.startsWith(HYPOTHESES_HANDBACK))
             l.hypotheses = undefined; // les notes d'hypothèses se posent de nouveau (sans doublon) à l'entrée de l'étape
         l.status = 'suspended';
         l.outcome = null;
-        const text = planNote ? `écriture du plan reprise à l'étape ${l.next} (--resume --replay)` : 'intégration reprise (--resume --integrate)';
+        const text = lead ? `intégration reprise (--resume --integrate) : revue conforme du lead hors vague, ${lead.head.slice(0, 7)}` : planNote ? `écriture du plan reprise à l'étape ${l.next} (--resume --replay)` : 'intégration reprise (--resume --integrate)';
         store.journal(`${k} → suspended — ${text}`);
         io.out(`${k} → suspended — ${text}`);
     }