@sylad/cadence 0.20.0 → 0.22.0

package/dist/orchestrate/command.js

@@ -2,16 +2,17 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
-import { readOrchestrateConfig, readPlanConfig } from '../config.js';
+import { planLoader, readOrchestrateConfig } from '../config.js';
 import { isDay, toDay } from '../dates.js';
 import { gitRoot } from '../git.js';
 import { onTermination } from '../proc.js';
 import { stopApps } from './app.js';
-import { Plan, RafError, isOpen } from '../plan.js';
+import { RafError, isOpen } from '../plan.js';
 import { AGENTS_DIR } from '../skills.js';
 import { pidAlive, sharedStateDir } from '../state.js';
-import { acquireSlot, cadenceHome, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
+import { acquireSlot, cadenceHome, freeSlots, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
 import { loadTemplates, newsText, objective, renderBrief } from './briefs.js';
+import { candidates, parsePriority, parseUntil, readPriority, stopReason } from './continue.js';
 import { Budget, MAX_PASSES, countInterrupted, needsPrecheck } from './cycle.js';
 import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
 import { buildArgs, killSessions, mcpServersFor, readAgents, realClaude } from './launch.js';
@@ -59,7 +60,7 @@ function lotArg(text) {
     return { project: m[1], lot: m[2], model: m[3] };
 }
 export function parseOrchestrateArgs(argv) {
-    const a = { lots: [], dryRun: false, watch: false, answers: [] };
+    const a = { lots: [], dryRun: false, watch: false, continue: false, answers: [] };
     const optional = (i) => (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-') && !LOT_LIKE.test(argv[i + 1]) ? argv[i + 1] : undefined);
     for (let i = 0; i < argv.length; i++) {
         const t = argv[i];
@@ -86,6 +87,12 @@ export function parseOrchestrateArgs(argv) {
             a.maxSessions = parseMaxSessions(value(t));
         else if (t === '--wave')
             a.wave = value(t);
+        else if (t === '--continue')
+            a.continue = true;
+        else if (t === '--until')
+            a.until = value(t);
+        else if (t === '--priority')
+            a.priority = parsePriority(value(t));
         else if (t === '--answer') {
             const target = lotArg(value(t));
             a.answers.push({ project: target.project, lot: target.lot, text: value(t) });
@@ -100,9 +107,8 @@ export function parseOrchestrateArgs(argv) {
 /** Ce qu'un projet fournit à l'orchestrateur : sa configuration et la lecture de son plan (comme le CLI). */
 export function projectEnv(repo) {
     const configPath = join(repo, 'cadence.yaml');
-    const planConfig = readPlanConfig(configPath, repo);
-    const planPath = resolve(repo, planConfig?.path ?? 'docs/plan/raf.yaml');
-    return { config: readOrchestrateConfig(configPath), loadPlan: () => Plan.load(planPath, { ...planConfig?.settings, config: configPath }), configPath };
+    const loadPlan = planLoader(repo);
+    return { config: readOrchestrateConfig(configPath), loadPlan, configPath };
 }
 const isProject = (dir) => existsSync(join(dir, 'docs/plan/raf.yaml')) || (existsSync(join(dir, 'cadence.yaml')) && /^plan\s*:/m.test(readFileSync(join(dir, 'cadence.yaml'), 'utf8')));
 function resolveTargets(args, io, refusals) {
@@ -137,6 +143,14 @@ function resolveTargets(args, io, refusals) {
 async function trackedDirty(repo) {
     return (await snapshot(repo, { remote: false })).tracked.map((l) => l.slice(3));
 }
+/** `--effort` date de claude 2.1.284 (L137). Une version illisible n'est pas refusée. */
+function olderThanEffort(version) {
+    const m = /(\d+)\.(\d+)\.(\d+)/.exec(version);
+    if (!m)
+        return false;
+    const [a, b, c] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    return a < 2 || (a === 2 && (b < 1 || (b === 1 && c < 284)));
+}
 /** Préconditions : tout ce qui peut être refusé l'est ici, avant d'agir, sans verrou ni écriture. */
 async function preflight(args, targets, io, deps, launch, opts = {}) {
     const refusals = [];
@@ -162,6 +176,10 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             refusals.push(`${key} : ${e.message}`);
             continue;
         }
+        if (info && olderThanEffort(info.version) && Object.values(env.config.effort).some((e) => e !== 'default')) {
+            refusals.push(`${key} : claude ${info.version} n'a pas --effort (2.1.284 requise) : mettre claude à jour, ou orchestrate.effort à « default » pour chaque passe`);
+            continue;
+        }
         const lot = plan.lots().find((l) => l.id === t.lot);
         if (!lot) {
             refusals.push(`${key} : lot inconnu`);
@@ -283,7 +301,7 @@ function dryRun(lots, io, deps, budget, id) {
             const brief = renderBrief(s.kind, vars, deps.templatesDir);
             writeFileSync(file, brief);
             const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small).playwright;
-            const args = buildArgs({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model, schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'ux' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && s.kind === 'implement' ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
+            const args = buildArgs({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model, effort: env.config.effort[s.kind === 'review-small' ? 'review' : s.kind], schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'ux' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && s.kind === 'implement' ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
             io.out(`  ${s.kind} : claude ${args.join(' ')}`);
             io.out(`    brief : ${file}`);
             const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small));
@@ -301,14 +319,14 @@ function duration(ms) {
     const s = Math.round(ms / 1000);
     return s < 60 ? `${s} s` : `${Math.floor(s / 60)} min ${String(s % 60).padStart(2, '0')} s`;
 }
-/** Vagues vivantes (toutes, quel que soit leur dossier de départ) et dépôts qu'elles tiennent. */
-function liveLines() {
+/** Vagues vivantes (toutes, quel que soit leur dossier de départ), créneaux libres et dépôts qu'elles tiennent. */
+export function liveLines() {
     const home = cadenceHome();
     const waves = liveWaves(home);
     if (waves.length === 0)
         return [];
     const slots = liveSlots(home).length;
-    const lines = [`vagues en cours : ${waves.length} · sessions en cours : ${slots}`];
+    const lines = [`vagues en cours : ${waves.length} · sessions en cours : ${slots} · créneaux libres : ${freeSlots(waves, DEFAULT_MAX_SESSIONS)} sur ${DEFAULT_MAX_SESSIONS}`];
     for (const w of waves)
         lines.push(`  ${w.wave} (pid ${w.pid}, depuis ${w.started}) lancée depuis ${w.cwd} · plafond ${w.cap ?? '?'} · dépôts : ${w.repos.join(', ')}`);
     return lines;
@@ -338,6 +356,12 @@ export async function orchestrate(argv, io, deps) {
     const args = parseOrchestrateArgs(argv);
     const launch = io.cwd;
     const today = io.env.RAF_TODAY && isDay(io.env.RAF_TODAY) ? io.env.RAF_TODAY : toDay(io.now());
+    if ((args.until !== undefined || args.priority !== undefined) && !args.continue)
+        throw new RafError('--until et --priority s\'utilisent avec --continue');
+    if (args.until !== undefined)
+        args.untilAt = parseUntil(args.until, io.now()); // heure invalide ou passée : refus avant d'agir
+    if (args.continue)
+        priorityOf(args, launch); // une clé priority: illisible du cadence.yaml : refus avant d'agir, lots donnés ou non
     if (args.watch && args.status === undefined)
         throw new RafError('--watch s\'utilise avec --status');
     if (args.interval !== undefined && !args.watch)
@@ -378,13 +402,21 @@ export async function orchestrate(argv, io, deps) {
     }
     if (args.resume !== undefined)
         return resume(args, argv, io, deps, launch, today);
-    if (args.lots.length === 0)
-        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] | --status [vague] [--watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"]');
+    if (args.lots.length === 0 && !args.continue)
+        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] [--continue [--until 18:00] [--priority a,b]] | --status [vague] [--watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"]');
     const refusals = [];
     const targets = resolveTargets(args, io, refusals);
     const pre = await preflight(args, targets, io, deps, launch);
     refusals.push(...pre.refusals);
     const budget = args.budget ?? DEFAULT_BUDGET;
+    const firstSkipped = [];
+    // --continue sans lot donné : le premier tour est tiré du plan ; rien de prêt, ou tout refusé, vaut un refus avant d'agir.
+    if (args.continue && args.lots.length === 0 && refusals.length === 0) {
+        const first = await draw(args, io, deps, launch, new Set(), budget, maxSessions(args, io));
+        pre.lots.push(...first.lots);
+        firstSkipped.push(...first.skipped);
+        refusals.push(...(first.lots.length ? [] : first.skipped.length ? first.skipped : ['--continue : aucun lot prêt dont l\'estimation tient dans le budget']));
+    }
     if (refusals.length) {
         for (const r of refusals)
             io.err(`orchestrate : ${r}`);
@@ -397,6 +429,8 @@ export async function orchestrate(argv, io, deps) {
         if (args.wave && existsSync(join(RunStore.runsDir(launch), id)))
             return waveExists(args.wave, io);
         dryRun(pre.lots, io, deps, budget, id);
+        if (args.continue)
+            await continueDryRun(args, io, deps, launch, pre.lots, budget, firstSkipped);
         return 0;
     }
     if (deps.snapshot) {
@@ -434,6 +468,11 @@ export async function orchestrate(argv, io, deps) {
         }
     }
     const id = store.id;
+    // Les candidats refusés au premier tirage : leur cause dit pourquoi ils ne jouent pas (même ligne que celles des tirages suivants).
+    for (const s of firstSkipped) {
+        io.err(`orchestrate : lot sauté — ${s}`);
+        store.journal(`continue : lot sauté — ${s}`);
+    }
     const wave = { id, created: io.now().toISOString(), cwd: launch, budget, consumed: 0, cacheRead: 0, status: 'running', pid: process.pid, lots: pre.lots.map((l) => lotKey(l.project, l.lot)) };
     // Une vague qui n'a pas atteint `wave.json` (refus au verrou, démarrage en échec) ne laisse pas son dossier réservé :
     // le même `--wave` se relance, et `reserve` ne le prend pas pour une vague existante.
@@ -448,7 +487,7 @@ export async function orchestrate(argv, io, deps) {
                 l.node.link = (deps.linkNode ?? linkNodeBin)(store.dir, l.node.version, l.node.bin);
             store.writeLot(l);
         }
-        const code = await execute(wave, pre.lots, store, io, deps, today, maxSessions(args, io));
+        const code = await continueRounds(await execute(wave, pre.lots, store, io, deps, today, maxSessions(args, io)), wave, pre.lots, store, io, deps, today, args, launch);
         abandon();
         return code;
     }
@@ -457,6 +496,152 @@ export async function orchestrate(argv, io, deps) {
         throw e;
     }
 }
+const priorityOf = (args, launch) => args.priority ?? readPriority(launch);
+/**
+ * Tire jusqu'à `n` lots prêts du plan (L147), dans l'ordre de priorité, et les passe au contrôle préalable comme un lot donné :
+ * un lot refusé est sauté, sa cause rendue dans `skipped`. `exclude` reçoit chaque lot tiré ou refusé pour lui-même, pas ceux d'un
+ * dépôt refusé ni un lot qui ne tient pas dans le reste du budget (il tiendra peut-être au tour suivant).
+ * Un tour tire au plus UN lot par dépôt (le pool joue à la suite les lots d'un même dépôt, `--max-sessions` ne servirait à rien) ;
+ * les lots écartés pour cela complètent le tour, dans l'ordre, quand aucun autre dépôt n'a de lot prêt.
+ */
+async function draw(args, io, deps, launch, exclude, remaining, n) {
+    const lots = [];
+    const skipped = [];
+    const badRepos = new Set();
+    const used = new Set();
+    const deferred = [];
+    /** `spread` : premier passage, un dépôt déjà pris ce tour renvoie le lot au second ; sinon (second passage) le lot complète le tour. */
+    const attempt = async (c, repo, spread, checked) => {
+        const key = lotKey(c.project, c.lot.id);
+        if (badRepos.has(repo))
+            return;
+        if (spread && used.has(repo))
+            return void deferred.push({ c, repo });
+        const pre = checked ?? (await preflight(args, [{ project: c.project, projectDir: c.dir, repo, lot: c.lot.id, model: 'sonnet' }], io, deps, launch));
+        if (pre.refusals.length) {
+            // Un refus propre au lot l'écarte pour la vague ; celui d'un dépôt (arbre sale, orchestration en cours, pre-push) est passager :
+            // le dépôt est sauté pour ce tirage seulement, une ligne, et ses lots restent tirables au suivant.
+            const own = pre.refusals.filter((r) => r.startsWith(`${key} : `));
+            if (own.length)
+                exclude.add(key);
+            if (own.length < pre.refusals.length)
+                badRepos.add(repo);
+            skipped.push(...pre.refusals.filter((r) => !skipped.includes(r)));
+            return;
+        }
+        const lot = pre.lots[0];
+        if (lot.budget > remaining)
+            return; // pas exclu : le budget du tour suivant le permettra peut-être
+        if (spread && lotRepoPaths(lot).some((r) => used.has(r)))
+            return void deferred.push({ c, repo, pre }); // un dépôt voisin déjà pris ce tour
+        exclude.add(key);
+        remaining -= lot.budget;
+        lots.push(lot);
+        for (const r of lotRepoPaths(lot))
+            used.add(r);
+    };
+    for (const c of candidates(launch, { priority: priorityOf(args, launch), exclude, remaining })) {
+        if (lots.length >= n)
+            break;
+        const repo = gitRoot(c.dir);
+        if (repo)
+            await attempt(c, repo, true);
+    }
+    for (const d of deferred) {
+        if (lots.length >= n)
+            break;
+        await attempt(d.c, d.repo, false, d.pre);
+    }
+    return { lots, skipped };
+}
+/** Nombre de tours que la simulation de `--dry-run --continue` déroule au plus. */
+const DRY_RUN_ROUNDS = 10;
+/**
+ * `--dry-run --continue` : ce que les tirages suivants joueraient, par tour, avec la même fonction `draw` que la vague (un lot par dépôt
+ * par tour, contrôle préalable, budget) ; les lots sautés disent pourquoi. Le budget est décompté sur l'estimation des lots tirés
+ * (la consommation réelle n'est pas connue). `firstSkipped` : causes écartées au premier tirage, quand il a fourni les lots donnés.
+ */
+async function continueDryRun(args, io, deps, launch, given, budget, firstSkipped) {
+    io.out(`--continue : priorité ${priorityOf(args, launch).join(' > ') || '(aucune déclarée : ordre alphabétique)'}${args.until ? ` · jusqu'à ${args.until}` : ''}`);
+    const said = new Set();
+    const skip = (causes) => {
+        for (const s of causes) {
+            if (said.has(s))
+                continue;
+            said.add(s);
+            io.out(`  lot sauté — ${s}`);
+        }
+    };
+    skip(firstSkipped);
+    const exclude = new Set(given.map((l) => lotKey(l.project, l.lot)));
+    let remaining = budget - given.reduce((sum, l) => sum + (l.budget ?? 0), 0);
+    const cap = maxSessions(args, io);
+    const rounds = [];
+    for (let round = 1; round <= DRY_RUN_ROUNDS && remaining > 0; round++) {
+        const drawn = await draw(args, io, deps, launch, exclude, remaining, cap);
+        skip(drawn.skipped);
+        if (drawn.lots.length === 0)
+            break;
+        rounds.push(`tour ${round} : ${drawn.lots.map((l) => lotKey(l.project, l.lot)).join(', ')}`);
+        remaining -= drawn.lots.reduce((sum, l) => sum + (l.budget ?? 0), 0);
+    }
+    io.out(rounds.length ? `  tirés ensuite, par tour (budget décompté sur les estimations) : ${rounds.join(' · ')}${rounds.length === DRY_RUN_ROUNDS ? ' · …' : ''}` : '  aucun autre lot prêt à tirer');
+}
+/** Lots rendus ou en échec de suite, en comptant depuis le dernier lot de la vague. */
+function handedBackStreak(all) {
+    let n = 0;
+    for (const l of [...all].reverse()) {
+        if (l.status === 'handed-back' || l.status === 'failed')
+            n++;
+        else
+            break;
+    }
+    return n;
+}
+/**
+ * `--continue` (L147) : tant qu'aucune borne ne joue, tire jusqu'à `cap` lots prêts du plan et les joue dans la même vague
+ * (même budget, même dossier d'état). Sans `--continue`, rend le code tel quel. Bornes : budget, `--until`, limite d'usage,
+ * question posée, deux lots rendus de suite, vague interrompue, plus de lot prêt dont l'estimation tient dans le budget restant.
+ */
+async function continueRounds(first, wave, all, store, io, deps, today, args, launch) {
+    if (!args.continue || first === 2)
+        return first; // 2 : refus au verrou, rien n'a tourné
+    const say = (line) => {
+        io.out(line);
+        store.journal(line);
+    };
+    const exclude = new Set(all.map((l) => lotKey(l.project, l.lot)));
+    const cap = maxSessions(args, io);
+    let code = first;
+    for (;;) {
+        const questions = all.filter((l) => l.status === 'question').length;
+        const remaining = wave.status === 'suspended-budget' ? 0 : wave.budget - wave.consumed;
+        const why = stopReason({ now: io.now(), until: args.untilAt, quotaHit: wave.status === 'suspended-quota', questions, streak: handedBackStreak(all), interrupted: wave.status === 'interrupted' && questions === 0, remaining });
+        if (why) {
+            say(`continue : arrêt — ${why}`);
+            return code;
+        }
+        const drawn = await draw(args, io, deps, launch, exclude, remaining, cap);
+        for (const s of drawn.skipped)
+            say(`continue : lot sauté — ${s}`);
+        if (drawn.lots.length === 0) {
+            say("continue : arrêt — plus aucun lot prêt dont l'estimation tient dans le budget restant");
+            return code;
+        }
+        for (const l of drawn.lots) {
+            if (l.node)
+                l.node.link = (deps.linkNode ?? linkNodeBin)(store.dir, l.node.version, l.node.bin);
+            store.writeLot(l);
+            wave.lots.push(lotKey(l.project, l.lot));
+        }
+        store.writeWave(wave);
+        all.push(...drawn.lots);
+        say(`continue : tire ${drawn.lots.map((l) => lotKey(l.project, l.lot)).join(', ')}`);
+        code = await execute(wave, drawn.lots, store, io, deps, today, cap, all);
+        if (code === 2)
+            return code;
+    }
+}
 function contexts(lots, envs, wctx) {
     return lots.map((lot, i) => ({ wave: wctx, lot, config: envs[i].config, loadPlan: envs[i].loadPlan }));
 }
@@ -730,7 +915,7 @@ async function resume(args, argv, io, deps, launch, today) {
             io.out(line);
         return 0;
     }
-    return execute(wave, live, store, io, deps, today, maxSessions(args, io), lots);
+    return continueRounds(await execute(wave, live, store, io, deps, today, maxSessions(args, io), lots), wave, lots, store, io, deps, today, args, launch);
 }
 /** Dépendances réelles : `claude` (ou CADENCE_CLAUDE_BIN), agents et gabarits du paquet, journaux de ~/.claude. */
 export function realOrchestrateDeps(env) {

package/dist/orchestrate/continue.js

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { parse } from 'yaml';
+import { nextUp } from '../audit.js';
+import { planLoader } from '../config.js';
+import { gitRoot } from '../git.js';
+import { findProjects, isProject } from '../lead.js';
+import { RafError } from '../plan.js';
+import { lotBudget } from './command.js';
+/** `--until 18:00` : l'heure d'aujourd'hui (date de `now`) à partir de laquelle la vague ne tire plus de lot. */
+export function parseUntil(text, now) {
+    const m = /^(\d{1,2}):(\d{2})$/.exec(text.trim());
+    if (!m || Number(m[1]) > 23 || Number(m[2]) > 59)
+        throw new RafError(`--until invalide : ${text} (HH:MM, ex. 18:00)`);
+    const at = new Date(now);
+    at.setHours(Number(m[1]), Number(m[2]), 0, 0);
+    if (at.getTime() <= now.getTime())
+        throw new RafError(`--until ${text} : heure déjà passée aujourd'hui`);
+    return at;
+}
+/** `--priority cadence,maritime` : noms de projets, du plus prioritaire au moins prioritaire. */
+export function parsePriority(text) {
+    const names = text.split(',').map((n) => n.trim()).filter(Boolean);
+    if (names.length === 0)
+        throw new RafError(`--priority invalide : ${text} (noms de projets séparés par des virgules)`);
+    return names;
+}
+/** Clé `priority:` du cadence.yaml du dossier de lancement (le dossier parent des projets) ; absente : aucune priorité déclarée. */
+export function readPriority(launchDir) {
+    const file = join(launchDir, 'cadence.yaml');
+    if (!existsSync(file))
+        return [];
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const p = raw?.priority;
+    if (p == null)
+        return [];
+    if (!Array.isArray(p) || p.length === 0 || p.some((n) => typeof n !== 'string' || !n.trim()))
+        throw new RafError(`${file} : priority doit être une liste de noms de projets`);
+    return p.map((n) => n.trim());
+}
+/** Rang d'un projet dans la priorité : son nom, ou un nom suivi de « - » (`maritime` couvre `maritime-atlas`) ; les autres passent après tous les déclarés. */
+export function priorityRank(project, priority) {
+    const i = priority.findIndex((n) => project === n || project.startsWith(`${n}-`));
+    return i < 0 ? priority.length : i;
+}
+/** Un lot « à décider » (« à décider avec Sylvain », « (à décider) » ; titre ou note) attend une décision humaine : jamais tiré. */
+export function decisionPending(lot) {
+    return /à décider/i.test([lot.title, ...lot.notes.map((n) => n.text)].join('\n'));
+}
+/**
+ * Les lots tirables sous `launch` : prêts (à faire, `after` levé, ni récurrents ni en cours), ni « à décider avec Sylvain » ni déjà
+ * dans la vague, dont le budget tient dans `remaining` ; projets dans l'ordre de priorité (puis alphabétique), lots dans l'ordre du plan
+ * (gains rapides d'abord). `launch` est un projet : lui seul ; sinon ses sous-dossiers qui en sont. Un plan illisible est sauté.
+ */
+export function candidates(launch, o) {
+    const dirs = isProject(launch) ? [launch] : findProjects(launch);
+    const out = [];
+    const ranked = dirs.map((dir) => ({ dir, project: basename(dir) })).sort((a, b) => priorityRank(a.project, o.priority) - priorityRank(b.project, o.priority) || a.project.localeCompare(b.project));
+    for (const { dir, project } of ranked) {
+        let ready;
+        try {
+            ready = nextUp(planLoader(gitRoot(dir) ?? dir)().lots()).ready;
+        }
+        catch {
+            continue;
+        }
+        for (const lot of ready) {
+            if (o.exclude.has(`${project}:${lot.id}`) || decisionPending(lot) || lotBudget(lot.estimate) > o.remaining)
+                continue;
+            out.push({ project, dir, lot });
+        }
+    }
+    return out;
+}
+/** Pourquoi la vague ne tire plus de lot, ou null quand elle peut continuer. */
+export function stopReason(f) {
+    if (f.interrupted)
+        return 'vague interrompue (incident ou signal)';
+    if (f.quotaHit)
+        return "limite d'usage atteinte";
+    if (f.questions > 0)
+        return `${f.questions} question(s) posée(s) à la vague`;
+    if (f.streak >= 2)
+        return 'deux lots rendus de suite';
+    if (f.until && f.now.getTime() >= f.until.getTime())
+        return 'fenêtre horaire close (--until)';
+    if (f.remaining <= 0)
+        return 'budget épuisé';
+    return null;
+}

package/dist/orchestrate/cycle.js

@@ -4,6 +4,8 @@ import { randomUUID } from 'node:crypto';
 import { dirname, join, relative } from 'node:path';
 import { writeFileSync } from 'node:fs';
 import { lotCommits, lotWork } from '../audit.js';
+import { readDocsConfig } from '../config.js';
+import { docSyncBrief, docSyncGaps, filesOf } from '../docsync.js';
 import { readCommits, resolveCommit } from '../git.js';
 import { citedRefs } from '../link.js';
 import { repoShas, repoWork } from '../repos.js';
@@ -198,6 +200,14 @@ function checksText(c) {
     const runs = k.runs.map((r) => `- \`${r.command}\` (${r.label}): ${r.code === 0 ? 'green' : `RED, exit code ${r.code}`}`);
     return [`The program already ran these checks at HEAD ${k.head.slice(0, 7)}, just before this review:`, ...runs, 'Take these results as given: do not rebuild, do not rerun the whole suite, and do not wait on them. Run only a check they do not cover (a targeted test of a case you doubt), and list under "nonVerifie" what neither they nor you verified.'].join('\n');
 }
+/** Consigne docs.sync du brief de revue (L143) : calculée sur les commits du lot au moment de la revue, pas écrite d'avance. */
+function docsText(c) {
+    const plan = c.loadPlan();
+    const { sync } = readDocsConfig(plan.configFile ?? join(c.lot.repo, 'cadence.yaml'));
+    if (!sync.length)
+        return '';
+    return docSyncBrief(sync, docSyncGaps(sync, filesOf(c.lot.repo, lotWork(plan, c.lot.repo, c.lot.lot))));
+}
 /** Gabarit d'une étape : la passe des mineurs et la revue courte qui la suit ont chacune le leur. */
 function briefName(l, kind) {
     if (kind === 'fix' && l.minorFix)
@@ -210,7 +220,7 @@ function briefFor(c, kind) {
     const plan = c.loadPlan();
     const l = c.lot;
     const lot = plan.lot(l.lot);
-    const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', news: '', captures: '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []) };
+    const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []) };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
         vars.news = newsText(l.lot, pwDir);
@@ -239,6 +249,20 @@ function briefFor(c, kind) {
 export const lotSpent = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
 /** Le lot a dépensé son propre budget (L78) : il ne compte plus que sur le lead, la vague garde le sien pour les autres. */
 const lotOver = (l) => l.budget !== undefined && lotSpent(l) >= l.budget;
+/**
+ * Coût réservé à la revue qui suit une passe de correction (L145). Réserve fixe de 65 k tokens comptés, proche du p90 des
+ * revues complètes. Mesure faite le 2026-10-09 sur les journaux `.cadence/runs/*` (67 dossiers de vague du 04 au 09-10,
+ * `tokens.counted` des `N-review.json`, `N-review-small.json`, `N-ux.json` ; aucun journal `ux` conservé, 2 `review-small`
+ * sans `tokens.counted` écartés ; p90 par interpolation linéaire) : 187 revues, médiane 43,4 k, p90 62,7 k, max 105,9 k ;
+ * 114 revues courtes (review-small, après la passe des mineurs), médiane 37,4 k, p90 67,6 k, max 82,7 k ; ensemble des
+ * 301 revues, médiane 42,3 k, p90 67,0 k, max 105,9 k. La revue courte a donc un p90 plus haut que la revue complète : 65 k
+ * couvre 170 revues sur 187 (90,9 %) mais 99 revues courtes sur 114 (86,8 %). Une passe fix ne part que s'il reste de quoi payer cette revue.
+ * Seule exception : des tests rouges après une écriture (work() appelle toFix() sans revue) — la passe fix suivante peut
+ * alors être refusée et le lot revient au lead sans revue, avec ses constats.
+ */
+export const REVIEW_RESERVE = 65_000;
+/** Une passe de correction laisse-t-elle de quoi rejouer la revue dans le budget du lot ? Sans budget de lot : toujours. */
+const fixAffordable = (l) => l.budget === undefined || lotSpent(l) + REVIEW_RESERVE < l.budget;
 /** Pourquoi plus aucune session ne doit partir (incident, quota, budget), sinon null. */
 function halted(w, lot) {
     if (w.incident)
@@ -268,16 +292,18 @@ async function session(c, kind) {
     const halt = halted(w, l);
     if (halt)
         return suspend(c, halt);
-    if (lotOver(l))
-        return overBudget(c);
     const write = kind === 'implement' || kind === 'fix';
+    // Le budget du lot borne l'écriture, jamais la revue (L145) : une revue est jouée dès que le code est à relire (sauf tests rouges après une écriture, cf. REVIEW_RESERVE), la passe fix réserve son coût.
+    if (write && (lotOver(l) || (kind === 'fix' && !fixAffordable(l))))
+        return overBudget(c, kind === 'fix' && !lotOver(l));
     const model = write ? l.model : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
+    const effort = c.config.effort[kind === 'review-small' ? 'review' : kind];
     const before = await snapshot(l.repo);
     const neighbours = l.repos ?? [];
     const beforeOthers = await Promise.all(neighbours.map((r) => snapshot(r.path)));
     const n = l.steps.length + 1;
     const sessionId = randomUUID();
-    const step = { n, kind, model, status: 'running', sessionId, started: new Date().toISOString(), headBefore: before.head ?? undefined };
+    const step = { n, kind, model, ...(effort !== 'default' ? { effort } : {}), status: 'running', sessionId, started: new Date().toISOString(), headBefore: before.head ?? undefined };
     l.steps.push(step);
     const label = { implement: 'implementing', fix: 'fixing', review: 'reviewing', ux: 'reviewing', 'review-small': 'reviewing', precheck: 'implementing' };
     transition(c, label[kind]);
@@ -301,6 +327,7 @@ async function session(c, kind) {
         sessionId,
         brief,
         model,
+        effort,
         schema: schemaFor(kind),
         agent: kind === 'ux' ? 'ux-reviewer' : kind === 'precheck' ? 'precheck-reader' : write ? undefined : 'code-reviewer',
         cwd: l.repo,
@@ -423,12 +450,23 @@ function lostVerdict(c, kind, report) {
     c.lot.warnings.push(text);
     return ` ; ${text}`;
 }
-/** Budget du lot atteint avant une session : le lot est rendu au lead (reprendre ne lui rendrait pas de budget), les autres continuent. */
-function overBudget(c) {
+/**
+ * Budget du lot atteint avant une session d'écriture : le lot est rendu au lead (reprendre ne lui rendrait pas de budget), les autres continuent.
+ * `reserve` : le budget n'est pas dépensé, mais la passe fix ne laisserait pas de quoi rejouer la revue (L145).
+ */
+function overBudget(c, reserve = false) {
     const l = c.lot;
     // Une réponse du lead encore en attente n'a pas été consommée : elle ne doit pas se perdre sans qu'on le dise.
     const answer = l.pendingAnswer ? ` ; la réponse du lead (« ${l.pendingAnswer} ») n'a pas été jouée` : '';
-    return stop(c, 'handed-back', `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, dérivé de l'estimate) : étape « ${l.next ?? '?'} » non jouée${answer}, à décider par le lead`);
+    const why = reserve ? `budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés (dérivé de l'estimate), il ne reste pas de quoi payer la revue qui suivrait la correction (${REVIEW_RESERVE} réservés)` : `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, dérivé de l'estimate)`;
+    // Tests rouges après une écriture : la passe fix refusée aurait suivi, le lot revient sans revue (L145) — la cause le dit.
+    const red = l.next === 'fix' && l.constats.some((k) => k.source === 'tests');
+    // Passe d'écriture qui vient d'être jouée, nommée d'après le compteur : l.pass - 1 passes de correction l'ont précédée (minorPass reste vrai après la passe des mineurs).
+    const played = l.pass - 1;
+    const after = l.minorPass && played === (l.minorPassAt ?? 0) ? 'la passe des mineurs' : played > 0 ? `la passe fix ${played}` : "l'implémentation";
+    const prefix = red ? `tests rouges après ${after}, correction suivante non abordable : ` : '';
+    const unreviewed = red ? ' ; le lot revient sans revue, avec ses constats' : '';
+    return stop(c, 'handed-back', `${prefix}${why} : étape « ${l.next ?? '?'} » non jouée${answer}${unreviewed}, à décider par le lead`);
 }
 function suspend(c, why) {
     transition(c, 'suspended', why);
@@ -687,10 +725,6 @@ async function review(c, kind) {
         suspend(c, halt); // la session n'aurait pas lieu : l'application ne se lance pas pour rien
         return;
     }
-    if (lotOver(l)) {
-        overBudget(c);
-        return;
-    }
     c.wave.log(`${lotKey(l.project, l.lot)} · lancement de l'application (${ux.url})`);
     const app = await startApp({ command: ux.command, url: ux.url, cwd: l.repo, nodeBin: l.node?.link, log: join(c.wave.store.lotDir(l.project, l.lot), 'ux-app.log'), timeoutMs: (ux.timeout ?? APP_TIMEOUT_S) * 1000 });
     try {
@@ -752,10 +786,10 @@ async function reviewStep(c, kind) {
     // Revue conforme avec mineurs : une seule passe de correction des mineurs, avant de conclure (rien sous le tapis).
     // Budget épuisé : la passe n'aurait aucune session pour la jouer, le lot conclut sur la revue conforme et rend les mineurs.
     const wanted = summary.conforme && uxOk && !l.minorPass && !l.light && minors.length > 0; // lot léger : les mineurs restent des notes (L108)
-    const noBudget = wanted && (w.budget.exhausted || lotOver(l)) && !w.incident && !w.quota.hit;
+    const noBudget = wanted && (w.budget.exhausted || !fixAffordable(l)) && !w.incident && !w.quota.hit;
     const minorPass = wanted && !noBudget;
     if (noBudget)
-        l.warnings.push(`${w.budget.exhausted ? 'budget' : 'budget du lot'} atteint : la passe des mineurs n'a pas eu lieu, mineurs rendus en propositions`);
+        l.warnings.push(`${w.budget.exhausted ? 'budget atteint' : 'budget du lot trop juste pour payer la revue qui suivrait'} : la passe des mineurs n'a pas eu lieu, mineurs rendus en propositions`);
     // Les mineurs confiés à la passe ont pu être proposés par une revue non conforme antérieure : si la revue qui la suit est
     // conforme, ils sont traités et ne restent pas en propositions (ceux que cette revue signale encore sont ajoutés juste après).
     if (l.minorPass && !minorPass && summary.conforme && uxOk && l.minorLines?.length) {
@@ -777,6 +811,7 @@ async function reviewStep(c, kind) {
     addProposals(c, rep, 'code', !minorPass);
     if (minorPass) {
         l.minorPass = true;
+        l.minorPassAt = l.pass;
         l.minorLines = rep.constats.filter((k) => k.gravite === 'mineur').map((k) => minorLine('code', k));
         l.minorFix = true;
         l.constats = minors;

package/dist/orchestrate/launch.js

@@ -40,8 +40,11 @@ function agentsFor(spec, agents) {
         return agents;
     return { ...agents, [spec.agent]: { ...a, tools: [...a.tools, ...(a.tools.includes(PLAYWRIGHT_TOOLS) ? [] : [PLAYWRIGHT_TOOLS])] } };
 }
+function effortArgs(spec) {
+    return spec.effort && spec.effort !== 'default' ? ['--effort', spec.effort] : [];
+}
 export function buildArgs(spec, agents) {
-    const args = ['-p', spec.brief, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model];
+    const args = ['-p', spec.brief, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
     if (spec.agent) {
         if (!agents[spec.agent])
             throw new RafError(`agent introuvable dans le paquet : ${spec.agent}`);
@@ -81,7 +84,7 @@ export function readAgents(dir) {
 export const FORMAT_RETRY_PROMPT = 'Return your report now in the required format (the JSON structure of the schema), exactly as you concluded it. Do not do any further work, do not add anything else.';
 /** Arguments de la relance : même session (--resume), mêmes schéma, modèle, agent (outils restreints), mode de permission, dossiers et interdits. */
 export function buildRetryArgs(spec, sessionId, agents) {
-    const args = ['-p', FORMAT_RETRY_PROMPT, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model];
+    const args = ['-p', FORMAT_RETRY_PROMPT, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
     if (spec.agent) {
         if (!agents[spec.agent])
             throw new RafError(`agent introuvable dans le paquet : ${spec.agent}`);

package/dist/orchestrate/registry.js

@@ -44,6 +44,16 @@ export function liveWaves(home) {
     }
     return out.sort((a, b) => a.started.localeCompare(b.started));
 }
+/**
+ * Les créneaux que le lead peut encore donner à des sous-agents : `total` moins, pour chaque vague vivante, le
+ * plus petit de son plafond et du nombre de dépôts qu'elle tient encore (ses pas prennent un créneau et le
+ * rendent entre deux étapes : les sessions vivantes à l'instant ne disent pas ce que la vague va reprendre).
+ * Une vague sans plafond connu compte pour `total`.
+ */
+export function freeSlots(waves, total) {
+    const held = waves.reduce((n, w) => n + Math.min(w.cap ?? total, w.repos.length), 0);
+    return Math.max(0, total - held);
+}
 /** Inscrit la vague ; écarte au passage les entrées de processus morts (les `.tmp` d'une inscription en cours ne sont pas touchés). */
 export function registerWave(home, given) {
     const w = { ...given, start: given.start ?? processStart(given.pid) ?? undefined };

package/dist/orchestrate/state.js

@@ -53,15 +53,19 @@ export class RunStore {
     static runsDir(launchDir) {
         return join(launchDir, '.cadence', 'runs');
     }
-    /** La dernière vague (par identifiant) ; avec `unfinished`, la dernière qui n'est pas terminée. */
+    /** La dernière vague lancée (par date de lancement : un identifiant libre comme `ol-gains-1` ne se range pas par ordre alphabétique) ; avec `unfinished`, la dernière qui n'est pas terminée. */
     static last(launchDir, opts = {}) {
         const base = RunStore.runsDir(launchDir);
         if (!existsSync(base))
             return null;
-        const ids = readdirSync(base).filter((n) => existsSync(join(base, n, 'wave.json'))).sort().reverse();
-        for (const id of ids) {
-            const store = new RunStore(launchDir, id);
-            if (!opts.unfinished || store.readWave()?.status !== 'done')
+        const stores = readdirSync(base)
+            .filter((n) => existsSync(join(base, n, 'wave.json')))
+            .map((id) => new RunStore(launchDir, id))
+            .map((store) => ({ store, wave: store.readWave() }))
+            // lancement le plus récent d'abord ; à date égale (ou illisible), l'identifiant le plus grand
+            .sort((a, b) => (b.wave?.created ?? '').localeCompare(a.wave?.created ?? '') || b.store.id.localeCompare(a.store.id));
+        for (const { store, wave } of stores) {
+            if (!opts.unfinished || wave?.status !== 'done')
                 return store;
         }
         return null;