@sylad/cadence 1.8.0 → 1.10.0

package/dist/orchestrate/guard.js

@@ -260,8 +260,8 @@ export async function snapshot(repo, opts = {}) {
         opts.remote === false ? Promise.resolve(null) : out(repo, ['ls-remote', '--heads']),
     ]);
     const lines = (status ?? '').split('\n').filter(Boolean);
-    // .cadence/ (état de l'outil) et .playwright-mcp/ (sorties du MCP Playwright, écrites dans le dossier courant, qu'un dépôt déjà initialisé n'ignore pas forcément) ne comptent jamais comme un dépôt sale.
-    const keep = (l) => !/^.. "?(\.cadence|\.playwright-mcp)\//.test(l);
+    // .cadence/runs/ et .cadence/corrections.json (état et cache de l'outil ; le plan et les notes de .cadence/ sont versionnés) et .playwright-mcp/ (sorties du MCP Playwright, écrites dans le dossier courant, qu'un dépôt déjà initialisé n'ignore pas forcément) ne comptent jamais comme un dépôt sale.
+    const keep = (l) => !/^.. "?(\.cadence\/runs\/|\.cadence\/corrections\.json|\.playwright-mcp\/)/.test(l);
     return {
         head: head?.trim() || null,
         tracked: lines.filter((l) => !l.startsWith('??') && keep(l)),

package/dist/orchestrate/integrate.js

@@ -0,0 +1,129 @@
+import { execFileSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { gitCommonDir } from '../git.js';
+import { sharedStateDir } from '../state.js';
+import { activeLock, releaseLock, takeLock } from './lock.js';
+import { mergeUnreleased } from './changelog-merge.js';
+import { mutexFor } from './mutex.js';
+import { git, gitFailure, tryGit } from './worktree.js';
+/** Verrou d'intégration d'un dépôt (L279, R10) : dans l'état commun aux worktrees, au format du verrou d'orchestration, sous un autre nom. */
+export const INTEGRATION_LOCK = 'orchestrate-integration.lock';
+/** Attente du verrou d'intégration (R25) : une intégration dure un rebase et la relance des tests. */
+export const INTEGRATE_WAIT_MS = 10 * 60_000;
+export const INTEGRATE_POLL_MS = 1_000;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Prend la main sur le dépôt pour une intégration ou une écriture de plan du programme (R10, R21, R26) : d'abord la file en mémoire du dépôt (les lots d'une
+ * vague partagent un pid, `takeLock` rendrait chacun déjà porteur), puis le verrou fichier, qui ne départage que les autres processus. L'attente est bornée
+ * par `waitMs` (R25) ; au-delà, le porteur est rendu et rien n'est pris. Une attente ne retient aucun créneau de session : ce verrou n'a rien à voir avec eux.
+ */
+export async function takeRepoWrite(repo, who, o = {}) {
+    const waitMs = o.waitMs ?? INTEGRATE_WAIT_MS;
+    const pollMs = o.pollMs ?? INTEGRATE_POLL_MS;
+    const file = join(sharedStateDir(repo), INTEGRATION_LOCK);
+    const deadline = Date.now() + waitMs;
+    const turn = await mutexFor(`integrate:${gitCommonDir(repo)}`).acquire(waitMs);
+    if (!turn) {
+        // Un autre lot de ce processus tient la main : c'est lui le porteur (il a posé le verrou fichier).
+        const holder = activeLock(file);
+        return { ok: false, holder: { wave: holder?.wave ?? who.wave, pid: holder?.pid ?? process.pid } };
+    }
+    for (;;) {
+        const lock = { pid: process.pid, wave: who.wave, started: new Date().toISOString() };
+        const got = takeLock(file, lock);
+        if (got.ok) {
+            return {
+                ok: true,
+                release: () => {
+                    releaseLock(file, process.pid);
+                    turn();
+                },
+            };
+        }
+        if (Date.now() >= deadline) {
+            turn();
+            return { ok: false, holder: { wave: got.held.wave, pid: got.held.pid } };
+        }
+        await sleep(pollMs);
+    }
+}
+/** Branche courante du dépôt (`main`), null en HEAD détaché (R24). */
+export const repoBranch = (repo) => tryGit(repo, 'symbolic-ref', '--short', '-q', 'HEAD') || null;
+/** Point de départ de `rev` par rapport à la branche `base` : le dernier ancêtre commun. */
+export const mergeBase = (cwd, rev, base) => git(cwd, 'merge-base', rev, `refs/heads/${base}`);
+const CHANGELOG = 'CHANGELOG.md';
+const REBASE_ENV = { ...process.env, GIT_EDITOR: 'true', GIT_SEQUENCE_EDITOR: 'true' };
+const run = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: REBASE_ENV });
+/**
+ * Résout le conflit en cours quand c'est le CHANGELOG seul et de l'ajout pur sous `[Unreleased]` (L314) : écrit l'union, l'ajoute à l'index. Faux, sans rien
+ * toucher, pour tout autre conflit (un autre fichier avec lui, une entrée de base modifiée, une étape de base absente). `start` : le CHANGELOG au point de
+ * départ de la branche (L323), pour qu'un commit puisse réécrire l'entrée qu'un commit précédent du lot a ajoutée.
+ */
+function resolveChangelog(work, start) {
+    const files = (tryGit(work, 'diff', '--name-only', '--diff-filter=U') ?? '').split('\n').filter(Boolean);
+    if (files.length !== 1 || files[0] !== CHANGELOG)
+        return false;
+    try {
+        // Pendant un rebase, l'étape 2 est la branche du dépôt (« ours »), l'étape 3 le commit du lot rejoué (« theirs »).
+        const merged = mergeUnreleased(run(work, 'show', `:1:${CHANGELOG}`), run(work, 'show', `:2:${CHANGELOG}`), run(work, 'show', `:3:${CHANGELOG}`), start);
+        if (merged === null)
+            return false;
+        writeFileSync(join(work, CHANGELOG), merged);
+        run(work, 'add', '--', CHANGELOG);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Rebase le worktree `work` sur la branche `base` (R6). Une branche qui descend déjà du sommet de `base` n'a rien à rebaser (fast-forward pur : aucun sha ne
+ * change). Un conflit d'ajout pur dans le CHANGELOG est résolu par union à chaque commit qui le porte (L314, `changelog` les compte). Tout autre conflit — ou
+ * tout autre échec du rebase — est abandonné (`rebase --abort`) : la branche du lot et son arbre restent tels qu'avant, la branche du dépôt n'a pas été
+ * touchée, personne ne résout le conflit à l'aveugle.
+ */
+export function rebaseOnto(work, base) {
+    const before = git(work, 'rev-parse', 'HEAD');
+    if (tryGit(work, 'merge-base', '--is-ancestor', `refs/heads/${base}`, 'HEAD') !== null)
+        return { kind: 'forwarded' };
+    let changelog = 0;
+    const start = tryGit(work, 'show', `${mergeBase(work, 'HEAD', base)}:${CHANGELOG}`) ?? undefined;
+    try {
+        run(work, 'rebase', `refs/heads/${base}`);
+    }
+    catch (first) {
+        let failure = first;
+        // Chaque tour règle le commit sur lequel le rebase s'est arrêté ; un lot ne porte pas des centaines de commits, la borne évite seulement une boucle sans fin.
+        for (let turn = 0;; turn++) {
+            if (turn >= 200 || !resolveChangelog(work, start)) {
+                const files = (tryGit(work, 'diff', '--name-only', '--diff-filter=U') ?? '').split('\n').filter(Boolean);
+                tryGit(work, 'rebase', '--abort');
+                return { kind: 'conflict', files, detail: gitFailure(failure) };
+            }
+            changelog++;
+            try {
+                run(work, 'rebase', '--continue');
+                break;
+            }
+            catch (e) {
+                failure = e;
+            }
+        }
+    }
+    return { kind: 'rebased', before, after: git(work, 'rev-parse', 'HEAD'), changelog };
+}
+/**
+ * Patch-id stable (`git patch-id --stable`) du diff cumulé de `from` à `to` (R9) : le même diff reste le même quand le contexte se déplace, il change quand
+ * une ligne du lot change. Vide quand il n'y a pas de diff.
+ */
+export function patchId(cwd, from, to) {
+    const diff = execFileSync('git', ['diff', '--no-color', '--no-ext-diff', from, to], { cwd, encoding: 'utf8', maxBuffer: 1024 * 1024 * 512 });
+    if (!diff)
+        return '';
+    return execFileSync('git', ['patch-id', '--stable'], { cwd, input: diff, encoding: 'utf8' }).trim().split(/\s+/)[0] ?? '';
+}
+/** Avance la branche courante du dépôt du lead jusqu'à la branche du lot, en fast-forward seulement (R8, R24) : l'arbre du lead ne reçoit que les fichiers du lot. */
+export function advance(repo, branch) {
+    git(repo, 'merge', '--ff-only', '--quiet', `refs/heads/${branch}`);
+}

package/dist/orchestrate/launch.js

@@ -5,6 +5,7 @@ import { delimiter, join, resolve } from 'node:path';
 import { parse } from 'yaml';
 import { RafError } from '../plan.js';
 import { sandboxEnv } from './sandbox.js';
+import { SlotAbandoned } from './registry.js';
 import { killMarked, SESSION_MARK_VAR, TreeTracker } from '../proc.js';
 import { isQuotaMessage, lacksStructuredOutput, parseSession, salvageUsage, sumTokens, tokensOf } from './result.js';
 /**
@@ -34,8 +35,8 @@ export function writeMcpConfig(lotDir, kind, visible, small = false, screen = tr
     writeFileSync(file, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`);
     return file;
 }
-/** Outils interdits à toute session : pas de sous-agent, pas de push, de livraison, de verdict ni de rescellé d'un test d'acceptation (le chemin du lead, L200). */
-export const DISALLOWED = ['Agent', 'Bash(git push:*)', 'Bash(cadence deliver:*)', 'Bash(raf done:*)', 'Bash(raf review:*)', 'Bash(raf ux:*)', 'Bash(cadence spec reseal:*)', 'Bash(raf spec reseal:*)'];
+/** Outils interdits à toute session : pas de sous-agent, pas de push, de livraison, de verdict ni de rescellé d'un test d'acceptation (le chemin du lead, L200) ; pas de `Monitor` (tâche de fond que `-p` attend, L285). */
+export const DISALLOWED = ['Agent', 'Monitor', 'Bash(git push:*)', 'Bash(cadence deliver:*)', 'Bash(raf done:*)', 'Bash(raf review:*)', 'Bash(raf ux:*)', 'Bash(cadence spec reseal:*)', 'Bash(raf spec reseal:*)'];
 /** Outils MCP du serveur Playwright, par le préfixe du serveur (sonde réelle du 07-10 : `mcp__playwright` expose tous les `browser_*`). */
 export const PLAYWRIGHT_TOOLS = 'mcp__playwright';
 /** Agents passés à `--agents` : l'agent d'une étape qui charge Playwright, s'il a une liste d'outils, y gagne les outils du serveur (sinon il ne peut pas l'appeler). */
@@ -48,6 +49,8 @@ function agentsFor(spec, agents) {
 function effortArgs(spec) {
     return spec.effort && spec.effort !== 'default' ? ['--effort', spec.effort] : [];
 }
+/** Retire `run_in_background` de Bash et des sous-agents : `claude -p` attend toute tâche de fond avant de sortir (jusqu'à 10 min d'inactivité), la session finie ne rendait pas la main (L285). */
+export const NO_BACKGROUND_ENV = { CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: '1' };
 export function buildArgs(spec, agents) {
     const args = ['-p', spec.brief, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
     if (spec.agent) {
@@ -103,6 +106,10 @@ export function readAgents(dir) {
     }
     return out;
 }
+/** Étapes relancées à neuf après une coupure : celles en lecture seule, et `ref`, qui n'écrit que sa lecture (`lectures/a.json` ou `b.json`, le troisième regard n'écrit rien), que le programme valide ensuite (une étape d'écriture ordinaire a pu laisser un travail à moitié fait). */
+const READ_ONLY = new Set(['review', 'review-small', 'ux', 'precheck', 'maquette', 'fiche', 'ref']);
+/** Session tuée par un signal (code 128 + n : 143 SIGTERM, 137 SIGKILL…) sans rien écrire : la coupure, ni un quota (un message) ni un échec (une sortie). */
+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. */
@@ -126,19 +133,44 @@ export function buildRetryArgs(spec, sessionId, agents) {
  * exception près : une session réussie qui finit en texte sans `structured_output` est relancée UNE fois, par
  * `--resume` de la même session, pour qu'elle rende son rapport au format demandé. Les jetons de la relance
  * s'ajoutent à ceux de la session ; toujours rien après elle, c'est l'échec habituel.
+ * Seconde exception (L256) : une étape en lecture coupée par un signal sans rien écrire (code 143, sortie vide) est
+ * relancée UNE fois à l'identique en session NEUVE (autre `--session-id`, jamais `--resume` : la coupée n'a rien à reprendre) ;
+ * coupée de nouveau, elle rend un échec marqué `cut`. `onRelaunch` reçoit l'identifiant de la session neuve juste avant son lancement. Le quota, le délai et un code ordinaire ne sont jamais relancés.
  */
 export async function runSession(spec, deps) {
     const sandbox = sandboxEnv(!!spec.prodAccess);
-    const launch = (args) => deps.claude(args, { local: spec.local, cwd: spec.cwd, unset: sandbox.unset, env: { CADENCE_ORCHESTRATED: spec.wave, ...sandbox.set, ...(spec.nodeBin || spec.toolBin ? { PATH: [spec.toolBin, spec.nodeBin, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {}) }, timeoutMs: spec.timeoutMs, onSpawn: deps.onSpawn, lot: spec.lot });
+    const launch = (args) => deps.claude(args, { local: spec.local, cwd: spec.cwd, unset: sandbox.unset, env: { CADENCE_ORCHESTRATED: spec.wave, ...NO_BACKGROUND_ENV, ...sandbox.set, ...(spec.tmpDir ? { TMPDIR: spec.tmpDir } : {}), ...(spec.nodeBin || spec.toolBin ? { PATH: [spec.toolBin, spec.nodeBin, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {}) }, timeoutMs: spec.timeoutMs, extend: spec.extend, onSpawn: deps.onSpawn, lot: spec.lot });
+    const epoch = killEpoch;
     const out = await launch(spec.local ? buildLocalArgs(spec, deps.agents) : buildArgs(spec, deps.agents));
     const first = classify(out);
     if (spec.local)
         return first; // pas de relance de mise en forme : l'appelant se replie sur Sonnet
+    // Une session tuée par `killSessions` (arrêt de la vague) n'est pas une coupure à relancer : la neuve survivrait à l'orchestrateur.
+    if (first.kind === 'failed' && READ_ONLY.has(spec.kind) && isCut(out) && killEpoch === epoch) {
+        const relaunched = { sessionId: spec.sessionId, cause: `code ${out.code}, sortie vide`, stderr: out.stderr };
+        const fresh = randomUUID();
+        deps.onRelaunch?.(fresh); // l'appelant l'enregistre AVANT le lancement : un signal pendant la relance retrouve la session neuve
+        // Relance qui doit attendre un créneau et voit une demande d'arrêt (L332) : la session coupée ne se perd pas avec l'abandon.
+        const again = await launch(buildArgs({ ...spec, sessionId: fresh }, deps.agents)).catch((e) => {
+            if (e instanceof SlotAbandoned)
+                e.after = { relaunched };
+            throw e;
+        });
+        const next = classify(again);
+        if (next.kind === 'ok')
+            return { ...next, relaunched };
+        const tail = { ...next, sessionId: next.sessionId ?? fresh, relaunched };
+        return tail.kind === 'failed' && isCut(again) ? { ...tail, cut: true, cause: `coupée (${relaunched.cause}), relancée une fois en session neuve, coupée de nouveau` } : tail;
+    }
     const missing = first.kind === 'failed' && !out.timedOut && out.code === 0 ? lacksStructuredOutput(out.stdout) : null;
     if (!missing)
         return first;
     const spentFirst = first.kind === 'failed' ? first.tokens : undefined;
-    const second = classify(await launch(buildRetryArgs(spec, missing.sessionId, deps.agents)));
+    const second = classify(await launch(buildRetryArgs(spec, missing.sessionId, deps.agents)).catch((e) => {
+        if (e instanceof SlotAbandoned)
+            e.after = { formatting: { stdout: out.stdout, stderr: out.stderr, ...(spentFirst ? { tokens: spentFirst } : {}), sessionId: missing.sessionId } };
+        throw e;
+    }));
     const total = (t) => (spentFirst && t ? sumTokens(spentFirst, t) : (t ?? spentFirst));
     if (second.kind === 'ok')
         return { kind: 'ok', result: { ...second.result, tokens: total(second.result.tokens), formattingRetry: true }, firstStdout: out.stdout };
@@ -175,6 +207,8 @@ function classify(out) {
 const live = new Set();
 const trees = new Set();
 const marks = new Set();
+/** Compte les arrêts de la vague (`killSessions`) : une session qui finit après un arrêt n'est pas relancée. */
+let killEpoch = 0;
 /** Suit un groupe de processus lancé par l'orchestrateur (commande du projet) : tué avec les sessions au signal. */
 export function trackGroup(pid) {
     live.add(pid);
@@ -182,6 +216,7 @@ export function trackGroup(pid) {
 }
 /** Tue les groupes de processus des sessions en cours (Ctrl-C, SIGTERM de l'orchestrateur). */
 export function killSessions() {
+    killEpoch++;
     for (const pid of live) {
         try {
             process.kill(-pid, 'SIGKILL');
@@ -227,7 +262,13 @@ export function realClaude(bin, base = process.env, localBin = 'claude-local') {
         child.stdout.on('data', (d) => out.push(d));
         child.stderr.on('data', (d) => err.push(d));
         let timedOut = false;
-        const timer = setTimeout(() => {
+        let extended = 0;
+        const deadline = () => {
+            if (opts.extend && extended < opts.extend.max && opts.extend.progressed()) {
+                extended++;
+                timer = setTimeout(deadline, Math.max(1_000, opts.extend.ms));
+                return;
+            }
             timedOut = true;
             tree.kill();
             killMarked(mark);
@@ -237,7 +278,8 @@ export function realClaude(bin, base = process.env, localBin = 'claude-local') {
             catch {
                 // déjà mort
             }
-        }, Math.max(1_000, opts.timeoutMs));
+        };
+        let timer = setTimeout(deadline, Math.max(1_000, opts.timeoutMs));
         // Aucun descendant ne survit à la session, dans son groupe ou hors de lui. Dès que la racine sort (`exit`), pas
         // à `close` : un descendant qui tient stdout/stderr ouverts retarderait `close` jusqu'au délai (« délai dépassé »
         // pour une session pourtant sortie en code 0).

package/dist/orchestrate/mutex.js

@@ -0,0 +1,30 @@
+/** File d'attente en mémoire : un seul porteur à la fois, dans l'ordre des demandes (les lots d'une vague partagent un processus, donc un pid : un verrou fichier ne les départagerait pas, L279). */
+export class Mutex {
+    tail = Promise.resolve();
+    /** Rend la libération quand c'est le tour du demandeur, ou null si `timeoutMs` s'écoule avant. Un demandeur qui renonce laisse passer son tour. */
+    async acquire(timeoutMs = Infinity) {
+        const prev = this.tail;
+        let release;
+        const mine = new Promise((r) => (release = r));
+        this.tail = prev.then(() => mine);
+        let timer;
+        const late = new Promise((r) => {
+            if (timeoutMs !== Infinity)
+                timer = setTimeout(() => r(false), timeoutMs);
+        });
+        const turn = await Promise.race([prev.then(() => true), late]);
+        clearTimeout(timer);
+        if (turn)
+            return release;
+        void prev.then(release);
+        return null;
+    }
+}
+const mutexes = new Map();
+/** Le mutex nommé (un par dépôt et par usage) : même objet pour la même clé, pendant toute la vie du processus. */
+export function mutexFor(key) {
+    let m = mutexes.get(key);
+    if (!m)
+        mutexes.set(key, (m = new Mutex()));
+    return m;
+}

package/dist/orchestrate/no-test.js

@@ -0,0 +1,41 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readOrchestrateConfig } from '../config.js';
+/** Le script que `npm init` écrit quand on ne dit rien : il échoue toujours, ce n'est pas une suite. */
+const NPM_PLACEHOLDER = /no test specified/i;
+/** La commande de test que le dépôt laisse deviner : `scripts.test` de package.json, pytest de pyproject.toml, pom.xml ; null sinon. */
+export function probableTestCommand(repo) {
+    const pkg = join(repo, 'package.json');
+    if (existsSync(pkg)) {
+        try {
+            const test = JSON.parse(readFileSync(pkg, 'utf8')).scripts?.test;
+            if (typeof test === 'string' && test.trim() && !NPM_PLACEHOLDER.test(test))
+                return 'npm test';
+        }
+        catch {
+            // un package.json illisible ne donne aucune commande
+        }
+    }
+    const py = join(repo, 'pyproject.toml');
+    if (existsSync(py) && /pytest/i.test(readFileSync(py, 'utf8')))
+        return 'pytest';
+    if (existsSync(join(repo, 'pom.xml')))
+        return 'mvn test';
+    return null;
+}
+/** Le projet n'a pas de `orchestrate.test` : ce qu'on en dit, ou null quand il en a un. Un cadence.yaml illisible ne se signale pas ici (il a déjà sa propre erreur). */
+export function noTestGate(repo) {
+    let test;
+    try {
+        test = readOrchestrateConfig(join(repo, 'cadence.yaml')).test;
+    }
+    catch {
+        return null;
+    }
+    return test ? null : { probable: probableTestCommand(repo) };
+}
+/** La phrase du signalement, sans le nom du projet. */
+export function noTestText(g) {
+    const probable = g.probable ? ` · commande probable : ${g.probable} (à déclarer en orchestrate.test)` : '';
+    return `porte de tests absente : orchestrate.test n'est pas déclaré, la vague ne lancera pas la suite (seule la revue le fera si elle le décide)${probable}`;
+}

package/dist/orchestrate/pool.js

@@ -3,12 +3,10 @@ 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). */
 export const SLOTS = 2;
 /**
- * Ordonnanceur : une file par dépôt, les lots d'un dépôt l'un après l'autre dans l'ordre donné, `slots` dépôts
- * au plus en parallèle. Deux lots qui partagent un dépôt (le leur, ou un dépôt voisin déclaré par `repos:`, L62) sont dans la
- * même file : jamais deux sessions dans un même dépôt (le plafond global des sessions de toutes
- * les vagues est tenu par command.ts). `onSettled` est appelé quand un lot a fini de jouer (L132 : command.ts libère alors les dépôts que plus aucun lot ne tient). Le budget, le quota et les incidents sont vérifiés par le cycle avant chaque session.
+ * 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
+ * le même groupe. Un groupe se joue à la suite, ou — avec des worktrees (L279) — ses lots en parallèle.
  */
-export async function runPool(ctxs, slots = SLOTS, known = [], onSettled = () => { }) {
+export function groupLots(ctxs) {
     const groups = [];
     for (const c of ctxs) {
         const mine = lotRepoPaths(c.lot);
@@ -25,44 +23,84 @@ export async function runPool(ctxs, slots = SLOTS, known = [], onSettled = () =>
         group.lots.push(c);
         group.lots.sort((x, y) => ctxs.indexOf(x) - ctxs.indexOf(y));
     }
-    const pending = groups.map((g) => g.lots);
-    const worker = async () => {
-        for (let queue = pending.shift(); queue; queue = pending.shift()) {
-            // Un lot en attente est revisité tant qu'un tour de la file en fait avancer un autre (sa dépendance peut venir après lui).
-            for (let todo = queue, progress = true; todo.length && progress;) {
-                const waiting = [];
-                progress = false;
-                for (const c of todo) {
-                    const state = (id) => [...ctxs.map((o) => o.lot), ...known].find((o) => o.project === c.lot.project && o.lot === id)?.status;
-                    const missing = (c.lot.dependsOn ?? []).filter((id) => state(id) !== 'ready');
-                    if (missing.length && c.lot.steps.length === 0 && (c.lot.status === 'queued' || c.lot.status === 'suspended')) {
-                        // Une dépendance suspendue, en question ou pas encore jouée (reprise) : le lot attend, il reste reprenable.
-                        // Seule une dépendance rendue au lead ou en échec le rend aussi.
-                        const dead = missing.filter((id) => ['handed-back', 'failed'].includes(state(id) ?? 'failed'));
-                        if (dead.length === 0) {
-                            c.lot.outcome = `en attente de : ${missing.join(', ')}`;
-                            c.wave.store.writeLot(c.lot);
-                            c.wave.log(`${lotKey(c.lot.project, c.lot.lot)} — ${c.lot.outcome}`);
-                            waiting.push(c);
-                            continue;
-                        }
-                        c.lot.status = 'handed-back';
-                        c.lot.outcome = `dépendance non prête dans la vague : ${missing.join(', ')}`;
+    return groups.map((g) => g.lots);
+}
+/**
+ * Ordonnanceur : une file par dépôt, les lots d'un dépôt l'un après l'autre dans l'ordre donné, `slots` files au plus en parallèle. Deux lots qui partagent un dépôt
+ * sont dans la même file : jamais deux sessions dans un même dépôt (le plafond global des sessions de toutes les vagues est tenu par command.ts).
+ * `parallel(groupe)` (L279) : les lots de ce groupe sont chacun leur propre file — ils jouent ensemble, chacun dans son worktree, dans la limite de `slots` ;
+ * un lot qui dépend d'un lot du groupe attend qu'il soit fini (ready après son intégration) avant de partir, et le lot en attente d'une place n'est pas commencé
+ * (son worktree n'existe pas encore, R3). `onSettled` est appelé quand un lot a fini de jouer (L132 : command.ts libère alors les dépôts que plus aucun lot ne tient). Le budget, le quota et les incidents sont vérifiés par le cycle avant chaque session.
+ */
+export async function runPool(ctxs, slots = SLOTS, known = [], onSettled = () => { }, parallel = () => false) {
+    const pending = groupLots(ctxs).flatMap((g) => (parallel(g) ? g.map((c) => [c]) : [g]));
+    // Les lots pas encore finis de jouer (en file ou en cours) : un lot ne part pas tant que l'un d'eux est sa dépendance.
+    const live = new Set(ctxs);
+    const runQueue = async (queue) => {
+        // Un lot en attente est revisité tant qu'un tour de la file en fait avancer un autre (sa dépendance peut venir après lui).
+        for (let todo = queue, progress = true; todo.length && progress;) {
+            const waiting = [];
+            progress = false;
+            for (const c of todo) {
+                const state = (id) => [...ctxs.map((o) => o.lot), ...known].find((o) => o.project === c.lot.project && o.lot === id)?.status;
+                const missing = (c.lot.dependsOn ?? []).filter((id) => state(id) !== 'ready');
+                if (missing.length && c.lot.steps.length === 0 && (c.lot.status === 'queued' || c.lot.status === 'suspended')) {
+                    // Une dépendance suspendue, en question ou pas encore jouée (reprise) : le lot attend, il reste reprenable.
+                    // Seule une dépendance rendue au lead ou en échec le rend aussi.
+                    const dead = missing.filter((id) => ['handed-back', 'failed'].includes(state(id) ?? 'failed'));
+                    if (dead.length === 0) {
+                        c.lot.outcome = `en attente de : ${missing.join(', ')}`;
                         c.wave.store.writeLot(c.lot);
-                        c.wave.log(`${lotKey(c.lot.project, c.lot.lot)} → handed-back — ${c.lot.outcome}`);
-                        progress = true;
-                        onSettled(c);
+                        c.wave.log(`${lotKey(c.lot.project, c.lot.lot)} — ${c.lot.outcome}`);
+                        waiting.push(c);
                         continue;
                     }
-                    if (c.lot.outcome?.startsWith('en attente de : '))
-                        c.lot.outcome = null;
+                    c.lot.status = 'handed-back';
+                    c.lot.outcome = `dépendance non prête dans la vague : ${missing.join(', ')}`;
+                    c.wave.store.writeLot(c.lot);
+                    c.wave.log(`${lotKey(c.lot.project, c.lot.lot)} → handed-back — ${c.lot.outcome}`);
                     progress = true;
-                    await runLot(c);
+                    live.delete(c);
                     onSettled(c);
+                    continue;
                 }
-                todo = waiting;
+                if (c.lot.outcome?.startsWith('en attente de : '))
+                    c.lot.outcome = null;
+                progress = true;
+                await runLot(c);
+                live.delete(c);
+                onSettled(c);
             }
+            todo = waiting;
         }
+        for (const c of queue)
+            live.delete(c);
+    };
+    /** La file d'un lot seul (groupe en parallèle) dont une dépendance joue encore : elle ne part pas. */
+    const blocked = (queue) => queue.length === 1 &&
+        (queue[0].lot.dependsOn ?? []).some((id) => {
+            const dep = ctxs.find((o) => o.lot.project === queue[0].lot.project && o.lot.lot === id);
+            return !!dep && live.has(dep) && dep.lot.status !== 'ready';
+        });
+    const running = new Set();
+    const start = (queue) => {
+        const p = runQueue(queue).finally(() => running.delete(p));
+        running.add(p);
     };
-    await Promise.all(Array.from({ length: Math.min(slots, pending.length) }, worker));
+    for (;;) {
+        while (running.size < slots) {
+            const next = pending.findIndex((q) => !blocked(q));
+            if (next < 0)
+                break;
+            start(pending.splice(next, 1)[0]);
+        }
+        if (running.size === 0) {
+            // Plus rien ne joue et chaque file restante attend une autre : le départ forcé laisse `runQueue` rendre ou garder en attente, comme avant.
+            if (!pending.length)
+                break;
+            start(pending.shift());
+            continue;
+        }
+        await Promise.race(running);
+    }
 }