@sylad/cadence 1.41.0 → 1.43.0

package/dist/orchestrate/integration-vivante.js

@@ -0,0 +1,138 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { planLoader } from '../config.js';
+import { leadReviewedHandBack } from './cycle.js';
+import { trackedDirty } from './depot.js';
+import { cadenceHome, liveWaves } from './registry.js';
+import { waveReadsIntegrateQueue } from './snapshot.js';
+import { lotKey } from './state.js';
+import { resumeCommand } from './table.js';
+import { lotTreeDir } from './worktree.js';
+/**
+ * Un lot rendu que `--integrate` peut reprendre (L279, L370) : rendu à l'étape d'intégration (`next: integrate`), ou rendu ailleurs puis corrigé et revu conforme par le lead dans son worktree (la revue porte le dernier commit).
+ * Rend le verdict du lead dans ce second cas (`lead`), `{ lead: null }` dans le premier, null si le lot n'est pas reprenable.
+ */
+export function integrationHandBack(store, l) {
+    if (l.status !== 'handed-back')
+        return null;
+    if (l.next === 'integrate')
+        return { lead: null };
+    // 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 lead = existsSync(join(tree, '.git')) ? leadReviewedHandBack(l, planLoader(tree)(), tree) : null;
+    return lead ? { lead } : null;
+}
+/** 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é. */
+export function adoptLeadReview(l, lead) {
+    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 = [];
+}
+/** La ligne de journal d'une intégration reprise (à la reprise comme sur la vague vivante). */
+export const integrationText = (lead) => (lead ? `intégration reprise (--resume --integrate) : revue conforme du lead hors vague, ${lead.head.slice(0, 7)}` : 'intégration reprise (--resume --integrate)');
+/** Le contrôle d'une cible de `--integrate` : sa clé `projet:lot`, ou le refus. */
+function checkTarget(store, t, seen) {
+    const matches = store.lots().filter((l) => l.lot === t.lot && (t.project ? l.project === t.project : true));
+    const where = `${t.project ? `${t.project}:` : ''}${t.lot}`;
+    if (matches.length !== 1)
+        return { refusal: matches.length ? `--integrate ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--integrate ${where} : lot inconnu dans la vague ${store.id}` };
+    const l = matches[0];
+    const key = lotKey(l.project, l.lot);
+    if (seen.includes(key))
+        return { refusal: `--integrate ${key} : lot visé deux fois` };
+    if (!integrationHandBack(store, l))
+        return { refusal: `--integrate ${key} : le lot n'est pas rendu à l'étape d'intégration (${l.status}, étape ${l.next ?? 'aucune'} : ${l.outcome ?? 'sans cause'})` };
+    return { key };
+}
+/**
+ * `--resume --integrate` sur une vague VIVANTE (L532) : l'intégration est déposée dans la file de la vague (`integrates.log`), qui la reprend entre deux étapes, comme un `--add`.
+ * Sans cela le lead attendait la fin de la vague (qui dure des heures sous `--continue`). Les lots visés sont contrôlés comme à la reprise : connus, rendus à l'intégration ou revus par le lead.
+ */
+export function depositIntegrations(targets, io, store) {
+    const refusals = [];
+    const keys = [];
+    for (const t of targets) {
+        const r = checkTarget(store, t, keys);
+        if ('key' in r)
+            keys.push(r.key);
+        else
+            refusals.push(r.refusal);
+    }
+    if (!waveReadsIntegrateQueue(store.dir))
+        refusals.push(`la vague ${store.id} ne lit pas la file d'intégrations (lancée avec une version de cadence d'avant L532) : attendre sa fin, puis ${resumeCommand(store.id, '--integrate', '<projet>:<lot>')}`);
+    if (refusals.length) {
+        for (const r of refusals)
+            io.err(`orchestrate : ${r}`);
+        return 2;
+    }
+    for (const key of keys) {
+        const id = store.requestIntegrate(key);
+        // La vague a pu finir entre le contrôle et le dépôt : sa file ne sera plus lue, la demande est retirée et le lead reprend à la main.
+        if (!liveWaves(cadenceHome()).some((w) => w.wave === store.id)) {
+            store.markIntegrateTaken(id);
+            io.err(`orchestrate : ${key} : la vague ${store.id} vient de finir, intégration non prise : ${resumeCommand(store.id, '--integrate', key)}`);
+            return 2;
+        }
+        store.journal(`demande : intégration du lot ${key}`);
+        io.out(`${key} : intégration déposée — la vague ${store.id} la reprend entre deux étapes dès qu'un créneau est libre`);
+    }
+    return 0;
+}
+/** Pourquoi la demande ne peut plus être jouée (lot inconnu, déjà repris, revue du lead perdue), ou le lot et ce qui le reprend. */
+function eligible(store, ctxs, lot) {
+    const c = ctxs.find((x) => lotKey(x.lot.project, x.lot.lot) === lot);
+    if (!c)
+        return { why: 'lot inconnu' };
+    if (c.lot.status !== 'handed-back')
+        return { why: `le lot n'est plus rendu (${c.lot.status})` };
+    const back = integrationHandBack(store, c.lot);
+    return back ? { c, back } : { why: "le lot n'est pas rendu à l'étape d'intégration ni revu par le lead au dernier commit de son worktree" };
+}
+/**
+ * La vague vivante prend les intégrations déposées (L532) : le lot rendu repart à l'étape `integrate` comme sous `--resume --integrate`, quand `canRun` l'accepte ; une demande dont le lot ne qualifie plus
+ * (déjà repris, commit après la revue du lead, fichier suivi modifié) est écartée et dite au journal. Rend les lots à jouer ; `settled` est la liste des lots qui ont fini de jouer.
+ */
+export async function takeIntegrations(w, canRun) {
+    const { store, wctx } = w;
+    const taken = [];
+    const drop = (id, lot, why) => {
+        wctx.log(`${lot} : intégration écartée (${why})`);
+        store.markIntegrateTaken(id);
+    };
+    for (const e of store.integrateQueue()) {
+        const r = eligible(store, w.ctxs, e.lot);
+        if ('why' in r) {
+            drop(e.id, e.lot, r.why);
+            continue;
+        }
+        const { c, back } = r;
+        if (!canRun(c))
+            continue;
+        const dirty = await trackedDirty(lotTreeDir(store.dir, c.lot.project, c.lot.lot, c.lot.repo));
+        if (dirty.length) {
+            drop(e.id, e.lot, `arbre sale, ${dirty.length} fichier(s) suivi(s) modifié(s) : ${dirty.join(', ')}`);
+            continue;
+        }
+        if (back.lead)
+            adoptLeadReview(c.lot, back.lead);
+        c.lot.next = 'integrate';
+        c.lot.status = 'suspended';
+        c.lot.outcome = null;
+        store.writeLot(c.lot);
+        store.markIntegrateTaken(e.id);
+        wctx.log(`${e.lot} → suspended — ${integrationText(back.lead)}`);
+        // Le lot avait fini de jouer (`settled`) : il rejoue, il tient de nouveau un créneau (L433).
+        w.settled.delete(c);
+        taken.push(c);
+    }
+    return taken;
+}
+/** `--resume --integrate` seul (sans --replay, --answer, --budget, --drop ni --continue) sur une vague qui tourne encore : l'intégration est déposée, pas refusée. */
+export function depositsOnly(a, live) {
+    return live && a.integrate.length > 0 && a.integrate.every((t) => !t.replay) && !a.answers.length && !a.lotBudgets.length && !a.drop.length && a.budget === undefined && !a.continue;
+}
+/** La vague tourne dans un autre processus de ce dossier, et joue (« running ») : une reprise qui attend le dépôt (L443) est inscrite vivante sans rien jouer encore, elle ne lit pas la file. */
+export function runsElsewhere(store, launch) {
+    return store.readWave()?.status === 'running' && liveWaves(cadenceHome()).some((w) => w.wave === store.id && w.cwd === launch && w.pid !== process.pid);
+}

package/dist/orchestrate/launch.js

@@ -88,14 +88,15 @@ export function enabledPlugins(files) {
  * En argument, pas dans un fichier : des identifiants seulement (`nom@marketplace`, aucun secret), 1 000 plugins pèsent 50 ko sous la limite d'un argument Linux (128 ko).
  */
 const settingsArgs = (spec) => (spec.disablePlugins?.length ? ['--settings', JSON.stringify({ enabledPlugins: Object.fromEntries(spec.disablePlugins.map((id) => [id, false])) })] : []);
-export function buildArgs(spec, agents) {
-    const args = ['-p', spec.brief, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
+/** Le corps commun d'une session `claude -p` et de sa relance : prompt, schéma, modèle, effort, agent restreint, puis (après `session`) mode de permission, dossiers, plugins désactivés, interdits et MCP. `session` : `--session-id <id>` ou `--resume <id>`. */
+function claudeArgs(spec, agents, prompt, session) {
+    const args = ['-p', 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}`);
         args.push('--agents', JSON.stringify(agentsFor(spec, agents)), '--agent', spec.agent);
     }
-    args.push('--session-id', spec.sessionId, '--permission-mode', spec.permissionMode);
+    args.push(...session, '--permission-mode', spec.permissionMode);
     for (const d of spec.addDirs)
         args.push('--add-dir', d);
     args.push(...settingsArgs(spec), '--disallowedTools', ...DISALLOWED);
@@ -103,6 +104,7 @@ export function buildArgs(spec, agents) {
         args.push('--strict-mcp-config', '--mcp-config', spec.mcpConfig);
     return args;
 }
+export const buildArgs = (spec, agents) => claudeArgs(spec, agents, spec.brief, ['--session-id', spec.sessionId]);
 /**
  * Arguments de `claude-local` (L146) : le prompt vient en premier, le script ajoute lui-même `--bare`, `--model` et le
  * serveur Ollama. Le harnais `--bare` ne charge pas `--agents` : le prompt de l'agent est joint au brief et ses outils
@@ -150,21 +152,7 @@ const isCut = (out) => !out.timedOut && out.code > 128 && out.stdout.trim() ===
 /** Consigne de la relance de mise en forme : rendre le rapport déjà établi au format demandé, rien d'autre. */
 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, ...effortArgs(spec)];
-    if (spec.agent) {
-        if (!agents[spec.agent])
-            throw new RafError(`agent introuvable dans le paquet : ${spec.agent}`);
-        args.push('--agents', JSON.stringify(agentsFor(spec, agents)), '--agent', spec.agent);
-    }
-    args.push('--resume', sessionId, '--permission-mode', spec.permissionMode);
-    for (const d of spec.addDirs)
-        args.push('--add-dir', d);
-    args.push(...settingsArgs(spec), '--disallowedTools', ...DISALLOWED);
-    if (spec.mcpConfig)
-        args.push('--strict-mcp-config', '--mcp-config', spec.mcpConfig);
-    return args;
-}
+export const buildRetryArgs = (spec, sessionId, agents) => claudeArgs(spec, agents, FORMAT_RETRY_PROMPT, ['--resume', sessionId]);
 /**
  * Lance une session et range son issue : ok, quota atteint, ou échec nommé (jamais de nouvel essai ici), à une
  * exception près : une session réussie qui finit en texte sans `structured_output` est relancée UNE fois, par

package/dist/orchestrate/lock.js

@@ -1,7 +1,7 @@
-import { linkSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { linkSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { processStart } from '../proc.js';
-import { pidAlive } from '../state.js';
+import { pidAlive, readLockJson } from '../state.js';
 /**
  * Le porteur vit encore : son pid existe ET, quand l'heure de démarrage est connue des deux côtés, c'est la même.
  * Un pid repris par un autre processus est un porteur mort.
@@ -18,24 +18,7 @@ export function holderAlive(pid, start) {
 export const REPO_LOCK = 'orchestrate.lock';
 /** Un champ facultatif du verrou, tel qu'écrit ; absent : absent. */
 const optional = (v) => (v === undefined ? undefined : String(v));
-function read(file) {
-    let text;
-    let ageMs;
-    try {
-        ageMs = Date.now() - statSync(file).mtimeMs;
-        text = readFileSync(file, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    try {
-        const raw = JSON.parse(text);
-        return { pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), start: optional(raw.start), until: optional(raw.until), ageMs };
-    }
-    catch {
-        return { pid: 0, wave: '?', started: '?', unreadable: true, ageMs };
-    }
-}
+const read = (file) => readLockJson(file, (raw) => ({ pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), start: optional(raw.start), until: optional(raw.until) }), { pid: 0, wave: '?', started: '?' });
 const alive = (l) => (l.unreadable ? l.ageMs < 5_000 : l.until !== undefined || holderAlive(l.pid, l.start));
 /** Un verrou déclaré dont l'échéance est passée à `now` ; faux pour un verrou de processus (il n'a pas d'échéance). */
 export const lockOverdue = (l, now) => l.until !== undefined && Date.parse(l.until) <= now.getTime();

package/dist/orchestrate/pool.js

@@ -1,6 +1,6 @@
 import { runLot } from './cycle.js';
 import { lotKey, lotRepoPaths } from './state.js';
-/** Valeur de repli de `runPool` quand l'appelant ne donne pas de plafond ; le réglage réel est DEFAULT_MAX_SESSIONS, `--max-sessions` ou CADENCE_MAX_SESSIONS (command.ts). */
+/** Valeur de repli de `runPool` quand l'appelant ne donne pas de plafond ; le réglage réel est DEFAULT_MAX_SESSIONS, `--max-sessions` ou CADENCE_MAX_SESSIONS (command-args.ts). */
 export const SLOTS = 2;
 /**
  * Les groupes de lots qui partagent un dépôt (le leur, ou un dépôt voisin déclaré par `repos:`, L62), chacun dans l'ordre donné : deux lots qui partagent un dépôt sont dans

package/dist/orchestrate/preflight.js

@@ -0,0 +1,190 @@
+import { gateProgress, gateText } from '../audit.js';
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readOrchestrateConfig } from '../config.js';
+import { gitRoot } from '../git.js';
+import { localLotRefusal } from '../local-task.js';
+import { isOpen } from '../plan.js';
+import { budgetStage, stageScreen } from './spec.js';
+import { ESCALATION_RESERVE } from './cycle.js';
+import { projectName } from './ajout.js';
+import { repoRefusals } from './depot.js';
+import { resolveLotRepos } from '../repos.js';
+import { lotKey, newLot } from './state.js';
+import { isExpress } from './express.js';
+import { nvmVersionsDir, resolveNode } from './node-env.js';
+import { lotBudget } from './lot-budget.js';
+import { readAgents } from './launch.js';
+/** 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 loadPlan = planLoader(repo);
+    return { config: readOrchestrateConfig(configPath), loadPlan, configPath };
+}
+const isProject = (dir) => existsSync(join(dir, PLAN_DEFAULT)) || existsSync(join(dir, PLAN_LEGACY)) || (existsSync(join(dir, 'cadence.yaml')) && /^plan\s*:/m.test(readFileSync(join(dir, 'cadence.yaml'), 'utf8')));
+export function resolveTargets(args, io, refusals) {
+    const out = [];
+    const seen = new Set();
+    for (const l of args.lots) {
+        const projectDir = l.project ? resolve(io.cwd, l.project) : io.cwd;
+        const project = projectName(io.cwd, l.project); // L421 : `.:L2` depuis le dépôt et `L2` désignent le même projet que les lots de la vague
+        const key = lotKey(project, l.lot);
+        if (seen.has(key)) {
+            refusals.push(`${key} : lot donné deux fois`);
+            continue;
+        }
+        seen.add(key);
+        if (!existsSync(projectDir) || !statSync(projectDir).isDirectory()) {
+            refusals.push(`${key} : ${l.project ? `dossier ${projectDir} introuvable (le projet est un sous-dossier du dossier courant ; dans un dépôt, \`.:${l.lot}\`)` : 'dossier courant illisible'}`);
+            continue;
+        }
+        if (!isProject(projectDir)) {
+            refusals.push(`${key} : ${projectDir} n'est pas un projet cadence (${PLAN_DEFAULT}, ${PLAN_LEGACY}, ou cadence.yaml avec une clé plan:)`);
+            continue;
+        }
+        const repo = gitRoot(projectDir);
+        if (!repo) {
+            refusals.push(`${key} : ${projectDir} n'est pas dans un dépôt git`);
+            continue;
+        }
+        out.push({ project, projectDir, repo, lot: l.lot, model: l.model ?? 'sonnet' });
+    }
+    return out;
+}
+/** `--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)));
+}
+/** L378 : claude installé mais non connecté échoue à la première session, après le démarrage du lot dans le plan. Null si connecté ou état illisible. */
+export function notLoggedIn(deps) {
+    return deps.claudeAuth?.()?.loggedIn === false ? "claude n'est pas connecté : lancer `claude` puis /login (état : `claude auth status`)" : null;
+}
+/** Préconditions : tout ce qui peut être refusé l'est ici, avant d'agir, sans verrou ni écriture. */
+export async function preflight(args, targets, io, deps, launch, opts = {}) {
+    const refusals = [];
+    if (io.env.CADENCE_ORCHESTRATED)
+        refusals.push(`orchestrate ne se lance pas depuis une session orchestrée (vague ${io.env.CADENCE_ORCHESTRATED})`);
+    const info = deps.claudeInfo();
+    if (!info)
+        refusals.push('claude introuvable (CADENCE_CLAUDE_BIN, ou claude dans le PATH)');
+    else if (!info.jsonSchema)
+        refusals.push(`claude ${info.version} n'a pas --json-schema : mettre claude à jour`);
+    const login = info && !args.dryRun ? notLoggedIn(deps) : null; // la simulation n'ouvre pas de session : elle le signale (dryRun) sans refuser
+    if (login)
+        refusals.push(login);
+    const lots = [];
+    const repoChecked = new Set();
+    const byProject = new Map();
+    // L421 : les lots déjà portés par la vague qui reçoit l'ajout comptent comme « plus tôt dans la vague » pour les dépendances.
+    for (const l of opts.addTo?.lots ?? [])
+        byProject.set(l.project, [...(byProject.get(l.project) ?? []), l.lot]);
+    for (const t of targets) {
+        const key = lotKey(t.project, t.lot);
+        const already = opts.addTo?.lots.find((l) => l.project === t.project && l.lot === t.lot);
+        if (already) {
+            refusals.push(`${key} : lot déjà ${already.queued ? "en file d'ajout dans" : 'dans'} la vague ${opts.addTo.wave}`);
+            continue;
+        }
+        let env;
+        let plan;
+        try {
+            env = projectEnv(t.repo);
+            plan = env.loadPlan();
+        }
+        catch (e) {
+            refusals.push(`${key} : ${e.message}`);
+            continue;
+        }
+        if (info && olderThanEffort(info.version) && Object.entries(env.config.effort).some(([step, e]) => e !== 'default' && (step !== 'probe' || env.config.probe))) {
+            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`);
+            continue;
+        }
+        const shut = !isOpen(lot.status) ? `le lot est ${lot.status}` : localLotRefusal(lot); // un lot local (L519) est au lead, jamais à une vague
+        if (shut) {
+            refusals.push(`${key} : ${shut}`);
+            continue;
+        }
+        if (plan.readonly && lot.status === 'todo' && !env.config.start) {
+            refusals.push(`${key} : plan en lecture seule : démarrer le lot avec l'outil du projet (ou déclarer orchestrate.start dans cadence.yaml)`);
+            continue;
+        }
+        const earlier = byProject.get(t.project) ?? [];
+        const open = lot.after.filter((d) => {
+            const dep = plan.lots().find((x) => x.id === d);
+            return dep && isOpen(dep.status) && !earlier.includes(d);
+        });
+        if (open.length) {
+            refusals.push(`${key} : dépendance(s) ni terminée(s) ni plus tôt dans la vague : ${open.join(', ')}`);
+            continue;
+        }
+        // Condition de tirage (L219) : seuls les lots done du plan la lèvent, jamais un lot de la même vague ; un lot déjà doing n'est pas refusé pour elle.
+        const gate = lot.status === 'todo' ? gateProgress(plan.lots(), lot) : undefined;
+        if (gate && !gate.met) {
+            refusals.push(`${key} : condition de tirage non remplie : ${gate.n === 0 ? 'gate invalide (raf check)' : gateText(gate)}`);
+            continue;
+        }
+        // Dépôts voisins du lot (L62) : chacun doit exister et être un dépôt git, sinon refus avant d'agir comme pour le dépôt du projet.
+        const neighbours = resolveLotRepos(t.repo, lot);
+        if (neighbours.problems.length) {
+            refusals.push(...neighbours.problems.map((p) => `${key} : ${p}`));
+            continue;
+        }
+        byProject.set(t.project, [...earlier, t.lot]);
+        for (const repo of [t.repo, ...neighbours.repos.map((r) => r.path)]) {
+            if (repoChecked.has(repo))
+                continue;
+            repoChecked.add(repo);
+            refusals.push(...(await repoRefusals(repo, t, { io, deps, launch }, opts)));
+        }
+        const node = resolveNode(t.repo, nvmVersionsDir(io.env));
+        if (node.kind === 'missing') {
+            refusals.push(`${key} : ${node.message}`);
+            continue;
+        }
+        const small = lot.estimate <= 0.5 || lot.quickwin;
+        const goal = args.goal ?? lot.goal;
+        const screen = stageScreen(t.repo, env.config.spec.dir, lot, env.config.maquette);
+        const state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, ...(goal ? { goal } : {}), visible: lot.visible, small, ...(screen ? { screen } : {}), ...(lot.spec && !screen ? { specLot: true } : {}), model: t.model, readOnlyPlan: plan.readonly });
+        if (neighbours.repos.length)
+            state.repos = neighbours.repos;
+        state.estimate = lot.estimate;
+        if (isExpress({ estimate: lot.estimate, screen, specLot: state.specLot }))
+            state.express = true;
+        state.light = lot.estimate <= env.config.review.threshold;
+        const escalating = !!env.config.escalation;
+        state.budget = lotBudget(lot.estimate, budgetStage(lot, screen, env.config.maquette, t.repo, env.config.spec.dir), 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 } : {}) };
+        lots.push(state);
+    }
+    return { refusals, lots };
+}
+/** 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. */
+export 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`) ? */
+export function matchesNvmrc(version, wanted) {
+    const v = version.replace(/^v/, '');
+    const w = wanted.replace(/^v/, '');
+    return v === w || v.startsWith(`${w}.`);
+}
+export const agentsOf = (deps) => readAgents(deps.agentsDir);

package/dist/orchestrate/registry.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { processStart } from '../proc.js';
 import { gitCommonDir } from '../git.js';
 import { lotFinished, lotKey, lotRepoPaths, RunStore } from './state.js';
+import { hasRoom, whileWaiting } from './attente.js';
 import { activeLock, holderAlive, releaseLock, takeLock } from './lock.js';
 /**
  * État commun à toutes les vagues de l'utilisateur, quel que soit le dossier d'où elles partent : le registre
@@ -198,6 +199,9 @@ export class SlotAbandoned extends Error {
  * Deux vagues qui prennent en même temps se départagent au recomptage : si le total dépasse `cap` une fois
  * le créneau pris, il est rendu et l'attente reprend.
  *
+ * `fresh`/`rank` (L531) : quand plusieurs sessions attendent, le créneau qui se libère va à l'étape suivante d'un lot déjà en cours (`fresh` faux, défaut) avant un nouveau tirage (`fresh`),
+ * puis au projet le plus haut dans `priority:` (`rank` le plus petit), puis à l'attente la plus ancienne, toutes vagues confondues ; une session ne prend un créneau que si aucune attente vivante ne la précède (`attente.ts`).
+ *
  * `onWait(holders, waitedMs)` : appelé quand on commence à attendre (0 ms), puis toutes les minutes.
  * `onGot(waitedMs)` : appelé à l'obtention, seulement si on a attendu.
  * `abandon()` : relu seulement pendant une VRAIE attente, c'est-à-dire une fois qu'une première tentative n'a pas trouvé de créneau libre,
@@ -206,6 +210,9 @@ export class SlotAbandoned extends Error {
  * la relance d'une session coupée n'est pas une attente, la demande d'arrêt s'applique ensuite.
  */
 export async function acquireSlot(home, cap, opts) {
+    return whileWaiting(home, opts, (myTurn) => takeSlot(home, cap, opts, myTurn));
+}
+async function takeSlot(home, cap, opts, myTurn) {
     mkdirSync(slotsDir(home), { recursive: true });
     const now = opts.now ?? Date.now; // injectable : les tests pilotent l'horloge
     const t0 = now();
@@ -223,7 +230,7 @@ export async function acquireSlot(home, cap, opts) {
             checkAbandon(); // pas à la première tentative : un créneau libre est pris même si une demande est posée
         // Les sessions du lead (`lead hold`) tournent hors de toute vague mais prennent un créneau : relues à chaque comptage (L424).
         const taken = () => live(home).length + liveHolds(home, new Date()).length;
-        if (taken() < limit) {
+        if (hasRoom(taken, limit, myTurn)) {
             for (let k = 0; k < MAX_SLOT_INDEX; k++) {
                 const file = join(slotsDir(home), `slot-${k}.lock`);
                 const got = takeLock(file, { pid: process.pid, wave: opts.wave, started: new Date().toISOString() });