@sylad/cadence 1.23.0 → 1.25.1

package/dist/orchestrate/command.js

@@ -27,7 +27,7 @@ import { costlyHypotheses, specScreen, specText } from './spec.js';
 import { fichesDuDossier } from '../spec.js';
 import { candidates, parsePriority, parseUntil, drawSettingsReport, readPriority, stopReason } from './continue.js';
 import { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, leadReviewedHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
-import { canInstallPrePush, gitProcessRunning, indexLockRefusal, installPrePush, longDuration, removePrePush, snapshot } from './guard.js';
+import { canInstallPrePush, gitProcessRunning, indexLockRefusal, installPrePush, keepGateGuard, longDuration, removePrePush, snapshot } from './guard.js';
 import { buildArgs, buildLocalArgs, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude, enabledPlugins, settingsFiles } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { groupLots, runPool } from './pool.js';
@@ -37,8 +37,10 @@ import { schemaFor } from './schemas.js';
 import { resolveLotRepos } from '../repos.js';
 import { excludeState, lotFinished, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
 import { linkNodeBin, nvmVersionsDir, resolveNode } from './node-env.js';
-import { quotaText, renderTable, resumeCommand } from './table.js';
+import { quotaText, renderDetail, renderTable, resumeCommand } from './table.js';
 import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, repairSnapshotModules, snapshotExists, waveReadsControl, waveReadsIntegrate, waveReadsLotBudget, waveReadsReplay, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
+const REPO_WAIT_MS = 3 * 60 * 60_000;
+const REPO_WAIT_POLL_MS = 5_000;
 export const DEFAULT_BUDGET = 2_000_000;
 /**
  * Budget d'un lot ordinaire (L78, L128, recalibré L194). Mesuré sur le TOTAL de chaque lot dans `.cadence/runs` (toutes les vagues
@@ -159,6 +161,8 @@ export function parseOrchestrateArgs(argv) {
             if (!isDay(a.since))
                 throw new RafError(`--since invalide : ${a.since} (AAAA-MM-JJ)`);
         }
+        else if (t === '--detail')
+            a.detail = value(t);
         else if (t === '--watch')
             a.watch = true;
         else if (t === '--interval')
@@ -643,7 +647,15 @@ function statusView(args, launch, cap, now) {
     // `running` : la vague suivie tourne — pour un <id> explicite, elle seule compte, pas les autres vagues de la machine
     const running = id !== undefined ? liveWaves(cadenceHome()).some((w) => w.wave === store.readWave().id) : waveLive;
     const lots = store.lots();
-    return { live, table: [...renderTable(store.readWave(), lots), ...keptLines(lots.map((l) => l.repo), now.getTime())], running };
+    if (args.detail !== undefined) {
+        try {
+            return { live: [], table: renderDetail(lots, args.detail), running };
+        }
+        catch (e) {
+            throw new RafError(e.message);
+        }
+    }
+    return { live, table: [...renderTable(store.readWave(), lots, { compact: true }), ...keptLines(lots.map((l) => l.repo), now.getTime())], running };
 }
 /** La vague que `--status` suit (L395) : `--status <id>` ou `--status --wave <id>` ; aucune : la dernière du dossier. Deux ids différents : refus. */
 function statusWave(args) {
@@ -711,6 +723,10 @@ export async function orchestrate(argv, io, deps) {
         priorityOf(args, launch); // une clé priority: illisible du cadence.yaml : refus avant d'agir, lots donnés ou non
     if (args.watch && args.status === undefined)
         throw new RafError('--watch s\'utilise avec --status');
+    if (args.detail !== undefined && args.status === undefined)
+        throw new RafError('--detail s\'utilise avec --status');
+    if (args.detail !== undefined && args.watch)
+        throw new RafError('--detail ne se combine pas avec --watch (il donne le détail d\'un lot, pas le tableau)');
     if (args.interval !== undefined && !args.watch)
         throw new RafError('--interval s\'utilise avec --status --watch');
     // --drop / --stop-after-current (L79) pilotent une vague VIVANTE : ni avec --status (rien à piloter), ni --stop-after-current avec --resume (il le contredit). --resume --drop retire le lot avant de rejouer la vague arrêtée.
@@ -790,7 +806,7 @@ export async function orchestrate(argv, io, deps) {
     if (args.drop.length || args.stopAfterCurrent)
         return control(args, io);
     if (args.lots.length === 0 && !args.continue)
-        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] [--continue [--until 18:00] [--priority a,b]] | --waits [--since AAAA-MM-JJ] | --status [vague] [--watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"] [--integrate projet:lot] [--replay projet:lot] | --drop projet:lot | --stop-after-current | --remove-worktree projet:lot [--abandon-commits]');
+        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] [--continue [--until 18:00] [--priority a,b]] | --waits [--since AAAA-MM-JJ] | --status [vague] [--detail projet:lot | --watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"] [--integrate projet:lot] [--replay projet:lot] | --drop projet:lot | --stop-after-current | --remove-worktree projet:lot [--abandon-commits]');
     const refusals = [];
     const targets = resolveTargets(args, io, refusals);
     const pre = await preflight(args, targets, io, deps, launch);
@@ -1093,14 +1109,17 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     const repos = [...new Set(lots.flatMap(lotRepoPaths))];
     /** Libère un dépôt : son verrou et sa garde de push (L132 : dès que ses lots sont finis, pas à la fin de la vague). */
     const freed = new Set();
-    /** Lots que la vague joue à la fois sur les dépôts qu'elle tient encore (un par dépôt, un par lot en worktree) : ce que le registre compte pour les créneaux libres. Absent (undefined) tant qu'aucun lot ne joue dans un worktree : le calcul reste celui des dépôts tenus. */
-    const lanes = () => ctxs.some((c) => c.tree) ? groupLots(ctxs).filter((g) => g.every((c) => lotRepoPaths(c.lot).every((r) => !freed.has(r)))).reduce((n, g) => n + (g.every((c) => c.tree) ? g.length : 1), 0) : undefined; // hors mode worktree, rien n'est écrit : le registre compte les dépôts tenus, comme avant L279
+    /** Lots dont la vague a fini de jouer (prêts, rendus, en échec ou suspendus) : ils ne tiennent plus de créneau. */
+    const settled = new Set();
+    /** Lots que la vague a encore à jouer, en cours ou en attente, sur les dépôts qu'elle tient encore (un par dépôt, un par lot en worktree) : ce que le registre compte pour les créneaux libres (L433 : un lot fini ne garde plus de créneau, 0 quand plus rien n'est à jouer). Absent (undefined) tant qu'aucun lot ne joue dans un worktree : le calcul reste celui des dépôts tenus. */
+    const lanes = () => ctxs.some((c) => c.tree) ? groupLots(ctxs).filter((g) => g.every((c) => lotRepoPaths(c.lot).every((r) => !freed.has(r)))).reduce((n, g) => { const todo = g.filter((c) => !settled.has(c)).length; return n + (g.every((c) => c.tree) ? todo : Math.min(1, todo)); }, 0) : undefined; // hors mode worktree, rien n'est écrit : le registre compte les dépôts tenus, comme avant L279
     const freeRepo = (r) => {
         freed.add(r);
         const file = join(sharedStateDir(r), REPO_LOCK);
         releaseLock(file, process.pid);
         held.splice(0, held.length, ...held.filter((f) => f !== file));
         removePrePush(r, wave.id);
+        keepGateGuard(r);
         try {
             updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)), lanes());
         }
@@ -1112,9 +1131,12 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         for (const f of held)
             releaseLock(f, process.pid);
         held.length = 0;
-        for (const r of repos)
-            if (!freed.has(r))
-                removePrePush(r, wave.id);
+        for (const r of repos) {
+            if (freed.has(r))
+                continue;
+            removePrePush(r, wave.id);
+            keepGateGuard(r);
+        }
         try {
             unregisterWave(home, process.pid);
         }
@@ -1125,13 +1147,14 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     for (const r of repos) {
         const file = join(sharedStateDir(r), REPO_LOCK);
         const l = takeLock(file, { pid: process.pid, wave: wave.id, started: new Date().toISOString() });
-        if (!l.ok) {
+        // Le verrou déjà à ce pid : pris par la reprise qui a attendu l'autre vague (L443).
+        if (!l.ok && l.held.pid !== process.pid) {
             io.err(`orchestrate : ${basename(r)} : une orchestration y est déjà en cours (${l.held.wave}, pid ${l.held.pid})`);
             release();
             return 2;
         }
         held.push(file);
-        if (l.stale)
+        if (l.ok && l.stale)
             io.err(`orchestrate : verrou de dépôt périmé retiré (${basename(r)}, pid ${l.stale.pid} mort)`);
         const hook = installPrePush(r, wave.id);
         if (!hook.ok) {
@@ -1159,7 +1182,10 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
                     return DROPPED;
                 return ctl.stopAfterCurrent ? STOP_REQUESTED : null;
             },
-            onWait: (h, ms, limit) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}en attente d'un créneau de session depuis ${duration(ms)} (${h.length}/${limit} en cours : ${[...new Set(h.map((x) => x.wave))].join(', ')})`),
+            onWait: (h, ms, limit, lead) => {
+                const who = [...new Set(h.map((x) => x.wave)), ...lead.map((x) => `session du lead ${x.label}`)];
+                wctx.log(`${o.lot ? `${o.lot} · ` : ''}en attente d'un créneau de session depuis ${duration(ms)} (${h.length + lead.length}/${limit} en cours : ${who.join(', ')})`);
+            },
             onGot: (ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}créneau de session obtenu après ${duration(ms)} d'attente`),
         });
         try {
@@ -1247,6 +1273,13 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
             if (c.tree?.active && c.lot.status === 'handed-back' && c.lot.next === 'integrate')
                 wctx.log(`orchestrate : ${lotKey(c.lot.project, c.lot.lot)} : rendu à l'intégration : reprise par ${resumeCommand(wctx.id, '--integrate', lotKey(c.lot.project, c.lot.lot))}`);
             // Un dépôt dont tous les lots de la vague (reprise comprise) sont prêts ou rendus peut être livré pendant que la vague continue ailleurs.
+            settled.add(c);
+            try {
+                updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)), lanes());
+            }
+            catch {
+                // registre illisible : le décompte reste celui du dernier écrit
+            }
             if (wctx.incident)
                 return;
             for (const r of lotRepoPaths(c.lot)) {
@@ -1510,133 +1543,193 @@ async function resume(args, argv, io, deps, launch, today) {
         (drops.includes(lotKey(l.project, l.lot)) ? removed : live).push(l);
     }
     // Comme au départ : un dépôt tenu par une autre orchestration vivante est refusé avant toute écriture.
-    for (const repo of new Set(live.flatMap(lotRepoPaths))) {
-        const busy = activeLock(join(sharedStateDir(repo), REPO_LOCK));
-        if (busy && busy.pid !== process.pid)
-            refusals.push(`${basename(repo)} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})`);
+    // L443 : une reprise d'intégration (--integrate, --replay) attend la fin de l'autre vague au lieu de sortir en 2 ; toute autre reprise refuse comme avant.
+    // Un refus déjà connu (vague qui tourne encore, claude introuvable, session en vie…) sort en 2 tout de suite : attendre 3 h ne le lèverait pas.
+    const waitFor = integ.length && !refusals.length ? { waitMs: deps.repoWait?.waitMs ?? REPO_WAIT_MS, pollMs: deps.repoWait?.pollMs ?? REPO_WAIT_POLL_MS } : null;
+    const deadline = Date.now() + (waitFor?.waitMs ?? 0);
+    // Pendant l'attente (jusqu'à 3 h) la reprise est inscrite parmi les vagues vivantes : le garde « la vague tourne encore » d'une seconde reprise la voit, et ne vient pas attendre à son tour.
+    let waiting = false;
+    // Verrous pris à la fin de l'attente : tenus jusqu'à `execute` (qui les retrouve à son pid), pour qu'une autre reprise qui attendait le même dépôt ne le voie pas libre pendant le .nvmrc, l'arbre et l'écriture des lots.
+    const taken = [];
+    const stopBefore = store.control().stopAfterCurrent;
+    try {
+        for (const repo of new Set(live.flatMap(lotRepoPaths))) {
+            const file = join(sharedStateDir(repo), REPO_LOCK);
+            let announced = null;
+            for (;;) {
+                let busy = activeLock(file);
+                if (waitFor && (!busy || busy.pid === process.pid)) {
+                    const t = takeLock(file, { pid: process.pid, wave: wave.id, started: new Date().toISOString() });
+                    if (t.ok) {
+                        taken.push(file);
+                        if (t.stale)
+                            io.err(`orchestrate : verrou de dépôt périmé retiré (${basename(repo)}, pid ${t.stale.pid} mort)`);
+                        break;
+                    }
+                    busy = t.held;
+                }
+                if (!busy || busy.pid === process.pid)
+                    break;
+                // Le verrou porte l'id de la vague : tenu par un processus vivant de CETTE vague, c'est une autre reprise de la même vague,
+                // entre son verrou et son inscription par `execute` (le garde « tourne encore » ci-dessus ne la voit pas encore) : refus, pas d'attente.
+                if (busy.wave === wave.id) {
+                    refusals.push(`la vague ${wave.id} tourne encore (pid ${busy.pid}, verrou de ${basename(repo)})`);
+                    break;
+                }
+                // Un refus déjà posé sur un dépôt précédent (même vague, attente échue) : les suivants ne font plus attendre, la reprise sort en 2.
+                if (!waitFor || refusals.length || Date.now() >= deadline) {
+                    refusals.push(`${basename(repo)} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})`);
+                    break;
+                }
+                if (!waiting) {
+                    registerWave(cadenceHome(), { pid: process.pid, wave: wave.id, started: new Date().toISOString(), cwd: launch, repos: [] });
+                    waiting = true;
+                }
+                if (announced !== busy.wave)
+                    io.out(`orchestrate : ${basename(repo)} : tenu par la vague ${busy.wave} (pid ${busy.pid}) : attente de sa fin avant de reprendre l'intégration`);
+                announced = busy.wave;
+                await new Promise((res) => setTimeout(res, Math.min(waitFor.pollMs, Math.max(1, deadline - Date.now()))));
+            }
+        }
     }
-    // Comme au départ : le .nvmrc est relu à chaque reprise (version désinstallée, .nvmrc changé, vague d'avant L80),
-    // et un Node introuvable refuse le lot — jamais de repli silencieux sur le Node par défaut.
-    const nodes = new Map();
-    for (const l of live) {
-        const node = resolveNode(l.repo, nvmVersionsDir(io.env));
-        if (node.kind === 'missing')
-            refusals.push(`${lotKey(l.project, l.lot)} : ${node.message}`);
-        else
-            nodes.set(l, node);
+    finally {
+        if (waiting)
+            unregisterWave(cadenceHome(), process.pid);
     }
-    // Tous les refus avant la moindre écriture (l'arbre sale compris) : une reprise refusée ne change pas l'état de la vague.
-    const dirty = new Set();
-    for (const repo of live.flatMap(lotRepoPaths))
-        if (!dirty.has(repo)) {
-            dirty.add(repo);
-            const d = await trackedDirty(repo);
+    // Avant `execute`, tout refus ou échec rend les verrous pris ; `execute` les garde ensuite et les rend à sa fin.
+    let played = false;
+    try {
+        // Comme au départ : le .nvmrc est relu à chaque reprise (version désinstallée, .nvmrc changé, vague d'avant L80),
+        // et un Node introuvable refuse le lot — jamais de repli silencieux sur le Node par défaut.
+        const nodes = new Map();
+        for (const l of live) {
+            const node = resolveNode(l.repo, nvmVersionsDir(io.env));
+            if (node.kind === 'missing')
+                refusals.push(`${lotKey(l.project, l.lot)} : ${node.message}`);
+            else
+                nodes.set(l, node);
+        }
+        // Tous les refus avant la moindre écriture (l'arbre sale compris) : une reprise refusée ne change pas l'état de la vague.
+        const dirty = new Set();
+        for (const repo of live.flatMap(lotRepoPaths))
+            if (!dirty.has(repo)) {
+                dirty.add(repo);
+                const d = await trackedDirty(repo);
+                if (d.length)
+                    refusals.push(`${basename(repo)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
+            }
+        // Les worktrees des lots repris suivent les mêmes gardes qu'un dépôt (R11) : un fichier suivi modifié refuse la reprise.
+        for (const l of live) {
+            const dir = lotTreeDir(store.dir, l.project, l.lot, l.repo);
+            if (!existsSync(join(dir, '.git')))
+                continue;
+            const d = await trackedDirty(dir);
             if (d.length)
-                refusals.push(`${basename(repo)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
+                refusals.push(`${basename(dir)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
         }
-    // Les worktrees des lots repris suivent les mêmes gardes qu'un dépôt (R11) : un fichier suivi modifié refuse la reprise.
-    for (const l of live) {
-        const dir = lotTreeDir(store.dir, l.project, l.lot, l.repo);
-        if (!existsSync(join(dir, '.git')))
-            continue;
-        const d = await trackedDirty(dir);
-        if (d.length)
-            refusals.push(`${basename(dir)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
-    }
-    if (refusals.length) {
-        for (const r of refusals)
-            io.err(`orchestrate : ${r}`);
-        return 2;
-    }
-    for (const [l, node] of nodes) {
-        if (node.kind === 'ok')
-            l.node = { version: node.version, wanted: node.wanted, bin: node.bin, link: (deps.linkNode ?? linkNodeBin)(store.dir, node.version, node.bin) };
-        else
-            delete l.node;
-    }
-    // Une étape interrompue (signal, crash) dont les tokens n'ont pas été comptés : relue dans le journal de sa session.
-    const recovered = new Budget(0);
-    // La session d'un lot en worktree a travaillé dans son worktree : c'est là que son journal se range.
-    const workdirOf = (l) => {
-        const dir = lotTreeDir(store.dir, l.project, l.lot, l.repo);
-        return existsSync(join(dir, '.git')) ? dir : l.repo;
-    };
-    for (const l of [...live, ...removed])
-        for (const s of l.steps)
-            if (s.status === 'interrupted')
-                countInterrupted(deps.claudeHome, workdirOf(l), s, recovered);
-    wave.consumed += recovered.consumed;
-    wave.cacheRead += recovered.cacheRead;
-    if (recovered.consumed || recovered.cacheRead)
-        store.writeWave(wave);
-    for (const [l, r] of raised) {
-        const k = lotKey(l.project, l.lot);
-        const text = `budget relevé de ${r.from} à ${r.to} (--resume --budget)`;
-        l.budget = r.to;
-        l.status = 'suspended';
-        l.next = r.step;
-        l.outcome = null;
-        l.warnings.push(text);
-        store.journal(`${k} → suspended — ${text}`);
-        io.out(`${k} → suspended — ${text}`);
-    }
-    for (const l of integ) {
-        const k = lotKey(l.project, l.lot);
-        const lead = leadReviewed.get(l);
-        if (lead) {
-            // La revue du lead tient lieu de revue du lot : le rebase reporte son verdict (même patch-id) ou joue la revue courte du diff rebasé.
-            l.next = 'integrate';
-            l.code = { conforme: true, bloquants: 0, majeurs: 0, mineurs: 0, verdict: lead.verdict, sousTaches: [], nonVerifie: [], head: lead.head };
-            l.verdict = lead.verdict;
-            l.constats = [];
-        }
-        const planNote = l.next !== 'integrate'; // rendu sur une écriture de plan refusée (--replay) : le lot repart de l'étape gardée
-        if (planNote && l.outcome?.startsWith(HYPOTHESES_HANDBACK))
-            l.hypotheses = undefined; // les notes d'hypothèses se posent de nouveau (sans doublon) à l'entrée de l'étape
-        l.status = 'suspended';
-        l.outcome = null;
-        const text = lead ? `intégration reprise (--resume --integrate) : revue conforme du lead hors vague, ${lead.head.slice(0, 7)}` : planNote ? `écriture du plan reprise à l'étape ${l.next} (--resume --replay)` : 'intégration reprise (--resume --integrate)';
-        store.journal(`${k} → suspended — ${text}`);
-        io.out(`${k} → suspended — ${text}`);
-    }
-    for (const l of live) {
-        if (l.status === 'implementing' || l.status === 'reviewing' || l.status === 'fixing')
-            l.status = 'suspended';
-        store.writeLot(l);
-    }
-    if (args.budget !== undefined)
-        wave.budget = wave.consumed + args.budget;
-    store.clearStopRequest(); // un arrêt demandé à la vague d'avant ne doit pas arrêter celle-ci
-    for (const l of removed) {
-        const k = lotKey(l.project, l.lot);
-        store.requestDrop(k);
-        store.journal(`demande : retirer ${k} de la vague (--resume --drop)`);
-        io.out(`${k} : retrait demandé — le lot est rendu au lead sans être rejoué`);
-        l.next = null;
-        l.status = 'handed-back';
-        l.outcome = DROPPED;
-        store.writeLot(l);
-        store.journal(`${k} → handed-back — ${DROPPED}`);
-        // Un lot retiré garde son worktree et sa branche (R12) : le journal en donne le chemin.
-        const branch = lotBranch(wave.id, l.project, l.lot);
-        if (baseBranchOf(l.repo, branch)) {
-            const line = `orchestrate : ${k} : worktree conservé : ${lotTreeDir(store.dir, l.project, l.lot, l.repo)} (branche ${branch})`;
-            io.out(line);
-            store.journal(line);
+        if (refusals.length) {
+            for (const r of refusals)
+                io.err(`orchestrate : ${r}`);
+            return 2;
         }
-    }
-    if (live.length === 0) {
-        if (lots.every(lotFinished)) {
-            wave.status = 'done';
+        for (const [l, node] of nodes) {
+            if (node.kind === 'ok')
+                l.node = { version: node.version, wanted: node.wanted, bin: node.bin, link: (deps.linkNode ?? linkNodeBin)(store.dir, node.version, node.bin) };
+            else
+                delete l.node;
+        }
+        // Une étape interrompue (signal, crash) dont les tokens n'ont pas été comptés : relue dans le journal de sa session.
+        const recovered = new Budget(0);
+        // La session d'un lot en worktree a travaillé dans son worktree : c'est là que son journal se range.
+        const workdirOf = (l) => {
+            const dir = lotTreeDir(store.dir, l.project, l.lot, l.repo);
+            return existsSync(join(dir, '.git')) ? dir : l.repo;
+        };
+        for (const l of [...live, ...removed])
+            for (const s of l.steps)
+                if (s.status === 'interrupted')
+                    countInterrupted(deps.claudeHome, workdirOf(l), s, recovered);
+        wave.consumed += recovered.consumed;
+        wave.cacheRead += recovered.cacheRead;
+        if (recovered.consumed || recovered.cacheRead)
             store.writeWave(wave);
+        for (const [l, r] of raised) {
+            const k = lotKey(l.project, l.lot);
+            const text = `budget relevé de ${r.from} à ${r.to} (--resume --budget)`;
+            l.budget = r.to;
+            l.status = 'suspended';
+            l.next = r.step;
+            l.outcome = null;
+            l.warnings.push(text);
+            store.journal(`${k} → suspended — ${text}`);
+            io.out(`${k} → suspended — ${text}`);
         }
-        for (const line of renderTable(wave, lots))
-            io.out(line);
-        for (const line of keptLines(lots.map((l) => l.repo)))
-            io.out(line);
-        return removed.length && !lots.every((l) => l.status === 'ready') ? 1 : 0;
+        for (const l of integ) {
+            const k = lotKey(l.project, l.lot);
+            const lead = leadReviewed.get(l);
+            if (lead) {
+                // La revue du lead tient lieu de revue du lot : le rebase reporte son verdict (même patch-id) ou joue la revue courte du diff rebasé.
+                l.next = 'integrate';
+                l.code = { conforme: true, bloquants: 0, majeurs: 0, mineurs: 0, verdict: lead.verdict, sousTaches: [], nonVerifie: [], head: lead.head };
+                l.verdict = lead.verdict;
+                l.constats = [];
+            }
+            const planNote = l.next !== 'integrate'; // rendu sur une écriture de plan refusée (--replay) : le lot repart de l'étape gardée
+            if (planNote && l.outcome?.startsWith(HYPOTHESES_HANDBACK))
+                l.hypotheses = undefined; // les notes d'hypothèses se posent de nouveau (sans doublon) à l'entrée de l'étape
+            l.status = 'suspended';
+            l.outcome = null;
+            const text = lead ? `intégration reprise (--resume --integrate) : revue conforme du lead hors vague, ${lead.head.slice(0, 7)}` : planNote ? `écriture du plan reprise à l'étape ${l.next} (--resume --replay)` : 'intégration reprise (--resume --integrate)';
+            store.journal(`${k} → suspended — ${text}`);
+            io.out(`${k} → suspended — ${text}`);
+        }
+        for (const l of live) {
+            if (l.status === 'implementing' || l.status === 'reviewing' || l.status === 'fixing')
+                l.status = 'suspended';
+            store.writeLot(l);
+        }
+        if (args.budget !== undefined)
+            wave.budget = wave.consumed + args.budget;
+        // Un arrêt demandé à la vague d'avant ne doit pas arrêter celle-ci ; celui demandé pendant l'attente (la reprise est alors visible de --stop-after-current) est gardé.
+        if (!(waiting && !stopBefore && store.control().stopAfterCurrent))
+            store.clearStopRequest();
+        for (const l of removed) {
+            const k = lotKey(l.project, l.lot);
+            store.requestDrop(k);
+            store.journal(`demande : retirer ${k} de la vague (--resume --drop)`);
+            io.out(`${k} : retrait demandé — le lot est rendu au lead sans être rejoué`);
+            l.next = null;
+            l.status = 'handed-back';
+            l.outcome = DROPPED;
+            store.writeLot(l);
+            store.journal(`${k} → handed-back — ${DROPPED}`);
+            // Un lot retiré garde son worktree et sa branche (R12) : le journal en donne le chemin.
+            const branch = lotBranch(wave.id, l.project, l.lot);
+            if (baseBranchOf(l.repo, branch)) {
+                const line = `orchestrate : ${k} : worktree conservé : ${lotTreeDir(store.dir, l.project, l.lot, l.repo)} (branche ${branch})`;
+                io.out(line);
+                store.journal(line);
+            }
+        }
+        if (live.length === 0) {
+            if (lots.every(lotFinished)) {
+                wave.status = 'done';
+                store.writeWave(wave);
+            }
+            for (const line of renderTable(wave, lots))
+                io.out(line);
+            for (const line of keptLines(lots.map((l) => l.repo)))
+                io.out(line);
+            return removed.length && !lots.every((l) => l.status === 'ready') ? 1 : 0;
+        }
+        played = true;
+        return continueRounds(await execute(wave, live, store, io, deps, today, maxSessions(args, io), lots), wave, lots, store, io, deps, today, args, launch);
+    }
+    finally {
+        if (!played)
+            for (const f of taken)
+                releaseLock(f, process.pid);
     }
-    return continueRounds(await execute(wave, live, store, io, deps, today, maxSessions(args, io), lots), wave, lots, store, io, deps, today, args, launch);
 }
 /** `loggedIn` de la sortie JSON de `claude auth status` ; null si elle n'est pas lisible (versions sans cette commande : pas de refus). */
 export function parseAuthStatus(text) {

package/dist/orchestrate/guard.js

@@ -2,8 +2,18 @@ import { chmodSync, existsSync, lstatSync, readdirSync, statSync, readFileSync,
 import { execFile, execFileSync } from 'node:child_process';
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { dirname, isAbsolute, join, relative } from 'node:path';
+import { readOrchestrateConfig } from '../config.js';
 import { gitCommonDir, gitRoot, hooksDir, indexLockPath } from '../git.js';
 const MARK = '# cadence orchestrate — hook pre-push temporaire (retiré à la fin de la vague)';
+/** Le hook que la vague laisse derrière elle quand le projet déclare une porte (L426) : il ne garde que le verdict de la porte au push. */
+const GATE_MARK = '# cadence — hook pre-push de la porte (L426) : refuse un push sans verdict vert de `cadence verify --gate`';
+const gateHook = `#!/bin/sh
+${GATE_MARK}
+if command -v raf >/dev/null 2>&1; then raf hook pre-push "$@"; [ $? -ne 3 ] || exit 1; fi
+exit 0
+`;
+/** Un hook de cadence (de la vague ou de la porte) : le remplacer ne touche à aucune règle du projet. */
+const ours = (text) => text.includes(MARK) || text.includes(GATE_MARK);
 const waveLine = (wave) => `# wave: ${wave}`;
 const hook = (wave) => `#!/bin/sh
 ${MARK}
@@ -204,7 +214,7 @@ export function cleanPlaywrightOutput(repo) {
  */
 export function installPrePush(repo, wave = '?') {
     const file = hookPath(repo);
-    if (existsSync(file) && !readFileSync(file, 'utf8').includes(MARK)) {
+    if (existsSync(file) && !ours(readFileSync(file, 'utf8'))) {
         return { ok: false, reason: `un hook pre-push existe déjà (${file}) : l'orchestrateur ne le remplace pas` };
     }
     mkdirSync(dirname(file), { recursive: true });
@@ -234,10 +244,32 @@ export function removePrePush(repo, wave) {
     removePlaywrightExclude(repo);
     restoreExclude(repo);
 }
+/**
+ * Fin de la garde de la vague sur un dépôt (L426) : quand le projet déclare une porte (`orchestrate.test` ou `orchestrate.build`), le hook de la vague
+ * est remplacé par un hook qui ne garde que la porte, sinon le push de livraison, qui vient après la fin des lots du dépôt, ne serait plus contrôlé.
+ * Rien n'est laissé quand aucune porte n'est déclarée (ou la config illisible), quand un autre hook pre-push est en place (celui du projet, ou celui d'une autre
+ * vague vivante : il reste), ni quand le dossier des hooks est dans l'arbre suivi (le fichier y serait un fichier non suivi du dépôt).
+ */
+export function keepGateGuard(repo) {
+    try {
+        const config = readOrchestrateConfig(join(gitRoot(repo) ?? repo, 'cadence.yaml'));
+        if (!config.test && !config.build)
+            return;
+    }
+    catch {
+        return;
+    }
+    const file = hookPath(repo);
+    if (existsSync(file) || excludeLine(repo) !== null)
+        return;
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, gateHook);
+    chmodSync(file, 0o755);
+}
 /** Pourrait-on poser le hook ? (préconditions, sans écrire) */
 export function canInstallPrePush(repo) {
     const file = hookPath(repo);
-    return existsSync(file) && !readFileSync(file, 'utf8').includes(MARK) ? `un hook pre-push existe déjà (${file}) : l'orchestrateur ne le remplace pas` : null;
+    return existsSync(file) && !ours(readFileSync(file, 'utf8')) ? `un hook pre-push existe déjà (${file}) : l'orchestrateur ne le remplace pas` : null;
 }
 /** git sans bloquer la boucle d'événements (un `ls-remote` peut durer 20 s) ; null en cas d'échec ou de délai. */
 function out(repo, args, timeout = 20_000) {

package/dist/orchestrate/integrate.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, 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 { releaseLock, takeLock } from './lock.js';
 import { mergeUnreleased, moveToUnreleased, settleLotEntries, unreleasedSections } from './changelog-merge.js';
 import { mutexFor } from './mutex.js';
 import { Plan } from '../plan.js';
@@ -19,20 +19,17 @@ export const MAX_REPLAYS = 2;
 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.
+ * vague partagent un pid, `takeLock` rendrait chacun déjà porteur), puis le verrou fichier, qui ne départage que les autres processus. La file en mémoire
+ * s'attend sans borne (L425) : son porteur est un lot de ce processus, qui libère toujours, et une intégration (rebase rejoué + porte) dure plus que la borne.
+ * L'attente du verrou fichier d'un autre processus est bornée par `waitMs` (R25), comptée à partir du tour ; 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 turn = (await mutexFor(`integrate:${gitCommonDir(repo)}`).acquire());
     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);

package/dist/orchestrate/registry.js

@@ -192,7 +192,7 @@ export class SlotAbandoned extends Error {
 }
 /**
  * Attend que le nombre de sessions vivantes, TOUTES vagues confondues et quel que soit l'index de leur créneau,
- * soit sous le plafond commun — `cap` (le plafond de cette vague) ou, s'il est plus bas, celui d'une autre vague vivante
+ * — plus les sessions du lead inscrites par `lead hold` (L424), qu'aucune vague ne porte — soit sous le plafond commun — `cap` (le plafond de cette vague) ou, s'il est plus bas, celui d'une autre vague vivante
  * (`commonCap`, relu à chaque tour, L395) —, puis prend le premier créneau libre (un pid mort est repris) et
  * rend sa libération. Toutes les vagues appliquent le même plafond : jamais « 4/3 en cours ».
  * Deux vagues qui prennent en même temps se départagent au recomptage : si le total dépasse `cap` une fois
@@ -221,13 +221,15 @@ export async function acquireSlot(home, cap, opts) {
         const limit = commonCap(liveWaves(home), cap); // relu à chaque tour : une vague au plafond bas qui s'arrête le relève
         if (reportedAt !== null)
             checkAbandon(); // pas à la première tentative : un créneau libre est pris même si une demande est posée
-        if (live(home).length < limit) {
+        // 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) {
             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() });
                 if (!got.ok)
                     continue;
-                if (live(home).length <= limit) {
+                if (taken() <= limit) {
                     if (reportedAt !== null)
                         opts.onGot?.(now() - t0);
                     return () => releaseLock(file, process.pid);
@@ -240,7 +242,7 @@ export async function acquireSlot(home, cap, opts) {
             checkAbandon(); // la première tentative a échoué : l'attente commence, la demande déjà posée l'interrompt sans attendre un tour
         if (reportedAt === null || now() - reportedAt >= (opts.reportMs ?? WAIT_REPORT_MS)) {
             reportedAt = now();
-            opts.onWait?.(live(home), reportedAt - t0, limit);
+            opts.onWait?.(live(home), reportedAt - t0, limit, liveHolds(home, new Date()));
         }
         await new Promise((r) => setTimeout(r, pollMs + Math.random() * pollMs * 0.25));
     }