@sylad/cadence 1.8.0 → 1.9.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,85 @@
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+import { gitCommonDir } from '../git.js';
+import { sharedStateDir } from '../state.js';
+import { activeLock, releaseLock, takeLock } from './lock.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}`);
+/**
+ * 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 — 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' };
+    try {
+        execFileSync('git', ['rebase', `refs/heads/${base}`], { cwd: work, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, GIT_EDITOR: 'true', GIT_SEQUENCE_EDITOR: 'true' } });
+    }
+    catch (e) {
+        const files = (tryGit(work, 'diff', '--name-only', '--diff-filter=U') ?? '').split('\n').filter(Boolean);
+        tryGit(work, 'rebase', '--abort');
+        return { kind: 'conflict', files, detail: gitFailure(e) };
+    }
+    return { kind: 'rebased', before, after: git(work, 'rev-parse', 'HEAD') };
+}
+/**
+ * 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

@@ -34,8 +34,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 +48,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 +105,10 @@ export function readAgents(dir) {
     }
     return out;
 }
+/** Étapes en lecture seule : seules relancées à neuf après une coupure (une étape d'écriture a pu laisser un travail à moitié fait). */
+const READ_ONLY = new Set(['review', 'review-small', 'ux', 'precheck', 'maquette', 'fiche']);
+/** 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,14 +132,30 @@ 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
+        const again = await launch(buildArgs({ ...spec, sessionId: fresh }, deps.agents));
+        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;
@@ -175,6 +197,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 +206,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 +252,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 +268,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/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);
+    }
 }

package/dist/orchestrate/registry.js

@@ -1,4 +1,4 @@
-import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { processStart } from '../proc.js';
@@ -7,7 +7,8 @@ import { lotFinished, lotKey, lotRepoPaths, RunStore } from './state.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
- * des vagues vivantes (`waves/<pid>.json`) et les créneaux de sessions simultanées (`slots/slot-<n>.lock`).
+ * des vagues vivantes (`waves/<pid>.json`), les créneaux de sessions simultanées (`slots/slot-<n>.lock`) et les
+ * sessions lancées à la main par le lead (`holds/<étiquette>.json`, L255).
  * Les verrous de DÉPÔT restent dans le dépôt (`.git/cadence/orchestrate.lock`).
  */
 export function cadenceHome(env = process.env) {
@@ -21,6 +22,8 @@ function readWave(file) {
         const w = { pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), cwd: String(raw.cwd), repos: Array.isArray(raw.repos) ? raw.repos.map(String) : [] };
         if (raw.cap !== undefined)
             w.cap = Number(raw.cap);
+        if (raw.lanes !== undefined)
+            w.lanes = Number(raw.lanes);
         if (raw.start !== undefined)
             w.start = String(raw.start);
         return w;
@@ -48,13 +51,82 @@ export function liveWaves(home) {
 }
 /**
  * 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
+ * plus petit de son plafond et du nombre de lots qu'elle joue à la fois — un par dépôt qu'elle tient encore, un par lot pour des lots en worktrees (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);
+export function freeSlots(waves, total, leadSessions = 0) {
+    const held = waves.reduce((n, w) => n + Math.min(w.cap ?? total, w.lanes ?? w.repos.length), 0);
+    return Math.max(0, total - held - leadSessions);
+}
+const holdsDir = (home) => join(home, 'holds');
+/** Le libellé est libre (espaces, « / »), le nom de fichier l'encode. */
+const holdFile = (home, label) => join(holdsDir(home), `${encodeURIComponent(label)}.json`);
+/** Inscrit la session `label` pour `ttlMinutes` minutes à partir de `now` ; la poser de nouveau la renouvelle. */
+export function addHold(home, label, ttlMinutes, now) {
+    mkdirSync(holdsDir(home), { recursive: true });
+    const file = holdFile(home, label);
+    const hold = { label, since: now.toISOString(), expires: new Date(now.getTime() + ttlMinutes * 60_000).toISOString() };
+    writeFileSync(`${file}.tmp`, JSON.stringify(hold));
+    renameSync(`${file}.tmp`, file);
+}
+/** Retire la session `label` ; faux quand elle n'était pas inscrite. */
+export function releaseHold(home, label) {
+    const file = holdFile(home, label);
+    if (!existsSync(file))
+        return false;
+    rmSync(file, { force: true });
+    return true;
+}
+/** Une session échue reste lisible (et signalée en ⚠) jusqu'à son `release` ou, oubliée, ce délai après son échéance. */
+const EXPIRED_HOLD_KEEP_MS = 24 * 3600_000;
+/** Lit les sessions du lead : celles dont l'échéance n'est pas passée à `now`, et celles échues depuis moins de 24 h ; le reste, et les fichiers illisibles, sont écartés au passage. */
+function scanHolds(home, now) {
+    let names;
+    try {
+        names = readdirSync(holdsDir(home)).filter((n) => n.endsWith('.json'));
+    }
+    catch {
+        return { live: [], expired: [] };
+    }
+    const live = [];
+    const expired = [];
+    for (const n of names) {
+        const file = join(holdsDir(home), n);
+        let hold = null;
+        let overdue = false;
+        try {
+            const raw = JSON.parse(readFileSync(file, 'utf8'));
+            const end = Date.parse(raw.expires);
+            if (typeof raw.label === 'string' && Number.isFinite(end)) {
+                hold = { label: raw.label, since: String(raw.since), expires: String(raw.expires) };
+                overdue = end <= now.getTime();
+                if (now.getTime() - end >= EXPIRED_HOLD_KEEP_MS)
+                    hold = null;
+            }
+        }
+        catch {
+            // illisible : écarté
+        }
+        if (!hold)
+            rmSync(file, { force: true });
+        else
+            (overdue ? expired : live).push(hold);
+    }
+    const byAge = (a, b) => a.since.localeCompare(b.since) || a.label.localeCompare(b.label);
+    return { live: live.sort(byAge), expired: expired.sort(byAge) };
+}
+/** Les sessions du lead dont l'échéance n'est pas passée à `now` : seules elles comptent dans les créneaux. */
+export function liveHolds(home, now) {
+    return scanHolds(home, now).live;
+}
+/**
+ * Les sessions du lead dont le TTL est échu à `now` (L278) et que personne n'a rendues : plus de créneau pris, mais la
+ * session tourne peut-être encore. `lead tour`, `orchestrate --status` et la bande les signalent en ⚠ : le lead la
+ * reprend (`lead hold`) ou l'arrête (`lead release`). Rien ne l'arrête ici.
+ */
+export function expiredHolds(home, now) {
+    return scanHolds(home, now).expired;
 }
 /** 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) {
@@ -71,13 +143,13 @@ export function registerWave(home, given) {
     writeFileSync(`${file}.tmp`, JSON.stringify(w));
     renameSync(`${file}.tmp`, file);
 }
-/** Met à jour la liste des dépôts tenus par la vague (un dépôt libéré en cours de vague n'y figure plus). */
-export function updateWaveRepos(home, pid, repos) {
+/** Met à jour la liste des dépôts tenus par la vague (un dépôt libéré en cours de vague n'y figure plus) et, quand elle la donne, le nombre de lots qu'elle joue à la fois. */
+export function updateWaveRepos(home, pid, repos, lanes) {
     const file = join(wavesDir(home), `${pid}.json`);
     const w = readWave(file);
     if (!w)
         return;
-    writeFileSync(`${file}.tmp`, JSON.stringify({ ...w, repos }));
+    writeFileSync(`${file}.tmp`, JSON.stringify({ ...w, repos, ...(lanes === undefined ? {} : { lanes }) }));
     renameSync(`${file}.tmp`, file);
 }
 export function unregisterWave(home, pid) {
@@ -139,26 +211,63 @@ export async function acquireSlot(home, cap, opts) {
         await new Promise((r) => setTimeout(r, pollMs + Math.random() * pollMs * 0.25));
     }
 }
-/** .git commun du dépôt `dir` (partagé par ses worktrees) ; null si `dir` n'est pas un dépôt. */
+/** .git commun du dépôt `dir` (partagé par ses worktrees), chemin réel (un lien symbolique vers le dépôt désigne le même) ; null si `dir` n'est pas un dépôt. */
 const commonDir = (dir) => {
     try {
-        return gitCommonDir(dir);
+        return realpathSync(gitCommonDir(dir));
     }
     catch {
         return null;
     }
 };
-/** Lots de la vague `pid` qui travaillent encore dans `repo` (en cours, en file ou suspendus) ; null si l'état de la vague est illisible. */
-export function openLotsIn(home, pid, repo) {
+/** Lots de la vague `pid` qui travaillent dans `repo` (ou l'un de ses worktrees), finis ou non ; null si l'état de la vague est illisible. */
+export function waveLotsIn(home, pid, repo) {
     try {
         const w = liveWaves(home).find((x) => x.pid === pid);
         const store = w && RunStore.find(w.cwd, w.wave);
         if (!store)
             return null;
         const mine = commonDir(repo);
-        return store.lots().filter((l) => !lotFinished(l) && lotRepoPaths(l).some((r) => r === repo || (mine !== null && commonDir(r) === mine))).map((l) => lotKey(l.project, l.lot));
+        return store.lots().filter((l) => lotRepoPaths(l).some((r) => r === repo || (mine !== null && commonDir(r) === mine)));
     }
     catch {
         return null;
     }
 }
+/** Lots de la vague `pid` qui travaillent encore dans `repo` (en cours, en file ou suspendus) ; null si l'état de la vague est illisible. */
+export function openLotsIn(home, pid, repo) {
+    return waveLotsIn(home, pid, repo)?.filter((l) => !lotFinished(l)).map((l) => lotKey(l.project, l.lot)) ?? null;
+}
+/**
+ * Vagues non terminées (`done` exclu : interrompues, suspendues, ou vivantes) lancées depuis `launchDir` qui gardent ouvert (état non terminal : question, suspendu, en file, en cours...)
+ * au moins un lot DU MÊME DÉPÔT que `repo` pour lequel `doing(lot)` est vrai (L238, `doing` : le lot est encore en cours au plan de ce dépôt). Un `--resume` rejouera ces lots sur ce dépôt :
+ * un rescellé commité entre-temps leur serait rendu comme « premier commit fautif ». Un lot livré au plan (vieille vague abandonnée) ou absent du plan ne compte jamais.
+ * Le dépôt d'un lot est celui de son projet (`lot.repo`), pas ses dépôts voisins : l'id d'un lot est propre au plan de son projet.
+ */
+export function openWavesIn(launchDir, repo, doing, live = []) {
+    const base = RunStore.runsDir(launchDir);
+    if (!existsSync(base))
+        return [];
+    const mine = commonDir(repo);
+    const out = [];
+    for (const id of readdirSync(base).sort()) {
+        try {
+            const store = RunStore.find(launchDir, id);
+            if (!store || store.readWave()?.status === 'done')
+                continue;
+            const open = store
+                .lots()
+                .filter((l) => !lotFinished(l) && (l.repo === repo || (mine !== null && commonDir(l.repo) === mine)))
+                .map((l) => ({ in: doing(l), key: lotKey(l.project, l.lot), status: l.status }));
+            const lots = open.filter((l) => l.in).map(({ key, status }) => ({ key, status }));
+            const others = open.filter((l) => !l.in).map(({ key, status }) => ({ key, status }));
+            const alive = live.find((w) => w.wave === id && w.cwd === launchDir);
+            if (lots.length)
+                out.push({ wave: id, launchDir, live: !!alive, ...(alive ? { pid: alive.pid } : {}), lots, others });
+        }
+        catch {
+            // état illisible : une vague qu'on ne sait pas lire ne bloque pas un rescellé du lead
+        }
+    }
+    return out;
+}

package/dist/orchestrate/result.js

@@ -51,7 +51,7 @@ export function parseSession(stdout, opts) {
 }
 /** Le message d'une session arrêtée par la limite d'usage (quota) ; l'heure de remise suit « | » quand elle est donnée. */
 export function isQuotaMessage(text) {
-    return /usage limit|limit reached|rate limit|quota/i.test(text);
+    return /usage limit|limit reached|hit your .{0,20}limit|rate limit|quota/i.test(text);
 }
 /** Heure de remise (epoch s) lue dans « …limit reached|1759600000 », sinon null. */
 export function quotaReset(text) {

package/dist/orchestrate/snapshot.js

@@ -103,6 +103,20 @@ export function waveReadsLotBudget(waveDir) {
         return false;
     }
 }
+/**
+ * L'instantané de la vague connaît-il `--resume --integrate` (L279) ? Un instantané plus ancien refuserait l'option comme inconnue.
+ * Sans instantané : rien à relire, on suppose que oui.
+ */
+export function waveReadsIntegrate(waveDir) {
+    if (!snapshotExists(waveDir))
+        return true;
+    try {
+        return readFileSync(join(toolDirOf(waveDir), 'dist', 'orchestrate', 'command.js'), 'utf8').includes('abandonCommits');
+    }
+    catch {
+        return false;
+    }
+}
 /** Relance réelle : un processus node sur la copie, signaux transmis, code de sortie rendu. */
 export function spawnReexec(toolDir, argv, env, sink) {
     return new Promise((resolve, reject) => {
@@ -125,3 +139,14 @@ export function spawnReexec(toolDir, argv, env, sink) {
         });
     });
 }
+/** L'instantané de la vague connaît-il `--resume --replay` (L279, reprise d'un lot rendu sur une écriture de plan refusée) ? Sans instantané : on suppose que oui. */
+export function waveReadsReplay(waveDir) {
+    if (!snapshotExists(waveDir))
+        return true;
+    try {
+        return readFileSync(join(toolDirOf(waveDir), 'dist', 'orchestrate', 'command.js'), 'utf8').includes("'--replay'");
+    }
+    catch {
+        return false;
+    }
+}