@sylad/cadence 1.24.0 → 1.26.0

package/dist/orchestrate/command.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,8 +1109,10 @@ 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);
@@ -1129,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) {
@@ -1254,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)) {
@@ -1517,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/table.js

@@ -194,7 +194,59 @@ export function resumeCommand(waveId, ...extra) {
 export function resumeAnswerHint(waveId, l) {
     return resumeCommand(waveId, '--answer', `${l.project}:${l.lot}`, '"…"');
 }
-/** Le tableau de fin de vague (ou de `--status`), une ligne par lot puis le total et les questions. */
+/** Les lignes d'un lot qui restent dans le tableau compact : une escalade et les avertissements sont des signaux, pas du détail. */
+function signalLines(l) {
+    const out = [];
+    if (l.escalation)
+        out.push(`${l.project}:${l.lot} — escalade ${l.escalation.model} : ${escalationText(l)}`);
+    for (const w of l.warnings)
+        out.push(`${l.project}:${l.lot} — ⚠ ${w}`);
+    return out;
+}
+/** Le détail d'un lot (L441) : ce que le tableau compact de `--status` n'imprime pas et que `--status --detail <lot>` donne. */
+function detailLines(l) {
+    const out = [];
+    if (l.goal)
+        out.push(`${l.project}:${l.lot} — objectif donné : ${l.goal}`);
+    if (l.uxNote)
+        out.push(`${l.project}:${l.lot} — ${l.uxNote}`);
+    if (l.uxCaptures)
+        out.push(`${l.project}:${l.lot} — captures Playwright : ${l.uxCaptures}`);
+    // Ligne de base des tests (L213) : les échecs déjà présents au sha de départ, à part de ceux du lot.
+    const base = l.baseline;
+    if (base?.failures.length) {
+        const where = `${base.sha ? ` (${base.sha.slice(0, 7)}${base.verified ? '' : ', annoncé par la session, non vérifié'})` : ''}`;
+        for (const t of base.failures.slice(0, BASELINE_LISTED))
+            out.push(`${l.project}:${l.lot} — déjà rouge au départ${where} : ${t}`);
+        if (base.failures.length > BASELINE_LISTED)
+            out.push(`${l.project}:${l.lot} — déjà rouge au départ${where} : … et ${base.failures.length - BASELINE_LISTED} autre(s)`);
+    }
+    for (const x of l.choix ?? [])
+        out.push(`${l.project}:${l.lot} — choix fait : ${x}`);
+    for (const h of l.hypotheses ?? [])
+        out.push(`${l.project}:${l.lot} — hypothèse de la fiche : ${h}`);
+    for (const p of l.proposals)
+        out.push(`${l.project}:${l.lot} — proposé : ${p}`);
+    if (l.uxVerdict && l.visible)
+        out.push(`${l.project}:${l.lot} — verdict UX pour « raf ux » : ${l.uxVerdict}`);
+    return out;
+}
+/**
+ * `--status --detail <lot>` (L441) : les lignes de détail d'un lot de la vague, lues dans l'état de la vague (le fichier de chaque lot).
+ * `sel` : `projet:lot` ou le seul `lot` s'il est unique dans la vague. Lot inconnu ou ambigu : lève.
+ */
+export function renderDetail(lots, sel) {
+    const hit = lots.filter((l) => `${l.project}:${l.lot}` === sel);
+    const found = hit.length ? hit : sel.includes(':') ? [] : lots.filter((l) => l.lot === sel);
+    if (found.length === 0)
+        throw new Error(`lot inconnu dans cette vague : ${sel} (lots : ${lots.map((l) => `${l.project}:${l.lot}`).join(', ')})`);
+    if (found.length > 1)
+        throw new Error(`lot ambigu : ${sel} (${found.map((l) => `${l.project}:${l.lot}`).join(', ')}) : donner projet:lot`);
+    const l = found[0];
+    const lines = detailLines(l);
+    return lines.length ? lines : [`${l.project}:${l.lot} — aucun détail (ni objectif, capture, choix, proposition, ni verdict UX)`];
+}
+/** Le tableau de fin de vague (ou de `--status`), une ligne par lot puis le total et les questions. `compact` (L441, `--status`) : sans le détail des lots, une seule ligne renvoie à `--status --detail`. */
 export function renderTable(wave, lots, deps = {}) {
     const rows = lots.map((l) => [`${l.project}:${l.lot}`, stateText(l, wave, deps.now ?? Date.now()), String(l.pass), review(l), ux(l), String(commits(l)), k(counted(l)), `${minutes(l)} min`]);
     const head = ['lot', 'état', 'passes', 'revue', 'UX', 'commits', 'tokens', 'durée'];
@@ -216,34 +268,14 @@ export function renderTable(wave, lots, deps = {}) {
         out.push(`${d.ready.project}:${d.ready.lot} — livrable jusqu'à ${d.sha} (dernier commit de ${d.ready.lot}, sous ${d.under.lot} ${d.under.status === 'handed-back' || d.under.status === 'failed' ? 'rendu' : LABEL[d.under.status]}) : git push origin ${d.sha}:main && cadence deliver --sha ${d.sha}`);
     }
     for (const l of lots) {
-        if (l.goal)
-            out.push(`${l.project}:${l.lot} — objectif donné : ${l.goal}`);
-        if (l.escalation)
-            out.push(`${l.project}:${l.lot} — escalade ${l.escalation.model} : ${escalationText(l)}`);
-        if (l.uxNote)
-            out.push(`${l.project}:${l.lot} — ${l.uxNote}`);
-        if (l.uxCaptures)
-            out.push(`${l.project}:${l.lot} — captures Playwright : ${l.uxCaptures}`);
-        for (const w of l.warnings)
-            out.push(`${l.project}:${l.lot} — ⚠ ${w}`);
-        // Ligne de base des tests (L213) : les échecs déjà présents au sha de départ, à part de ceux du lot.
-        const base = l.baseline;
-        if (base?.failures.length) {
-            const where = `${base.sha ? ` (${base.sha.slice(0, 7)}${base.verified ? '' : ', annoncé par la session, non vérifié'})` : ''}`;
-            for (const t of base.failures.slice(0, BASELINE_LISTED))
-                out.push(`${l.project}:${l.lot} — déjà rouge au départ${where} : ${t}`);
-            if (base.failures.length > BASELINE_LISTED)
-                out.push(`${l.project}:${l.lot} — déjà rouge au départ${where} : … et ${base.failures.length - BASELINE_LISTED} autre(s)`);
-        }
-        for (const x of l.choix ?? [])
-            out.push(`${l.project}:${l.lot} — choix fait : ${x}`);
-        for (const h of l.hypotheses ?? [])
-            out.push(`${l.project}:${l.lot} — hypothèse de la fiche : ${h}`);
-        for (const p of l.proposals)
-            out.push(`${l.project}:${l.lot} — proposé : ${p}`);
-        if (l.uxVerdict && l.visible)
-            out.push(`${l.project}:${l.lot} — verdict UX pour « raf ux » : ${l.uxVerdict}`);
+        out.push(...signalLines(l));
+        if (deps.compact)
+            continue;
+        out.push(...detailLines(l));
     }
+    const withDetail = lots.filter((l) => detailLines(l).length > 0).map((l) => `${l.project}:${l.lot}`);
+    if (deps.compact && withDetail.length)
+        out.push(`détail (objectif, captures, base de tests, choix, propositions, verdict UX) : cadence orchestrate --status --detail <projet:lot> — ${withDetail.join(', ')}`);
     return out;
 }
 const two = (n) => String(n).padStart(2, '0');

package/dist/perf.js

@@ -16,6 +16,8 @@ const BOTTLENECK_SHARE = 0.5;
 const MIN_CLASSIFIED = 10;
 /** Les étapes de la chaîne spec : un lot qui en a une est mesuré à part pour ses tokens (L240). */
 const SPEC_CHAIN = new Set(['spec', 'fiche', 'maquette', 'accept']);
+/** La classe de taille d'un lot : son estimate, « +spec » s'il est passé par la chaîne spec. Les tokens et la durée de mur (`lotMinutes`) la partagent ; le collecteur du mod (plugins/cadence-hud/hooks/collect.ts) en recopie la chaîne, `test/hud-classe-l414.test.ts` les relie. */
+const sizeClass = (estimate, steps) => `${estimate}${steps.some((x) => SPEC_CHAIN.has(x.kind)) ? '+spec' : ''}`;
 /**
  * Les deux fenêtres de 7 jours calendaires locaux : la courante finit à `today` inclus, la précédente la précède.
  * `since` (jour ISO ou instant) ignore tout ce qui le précède : la fenêtre qui commence avant lui est tronquée à lui.
@@ -272,7 +274,7 @@ export function computePerf(input) {
             if (!p || counted.length === 0)
                 continue;
             // Un lot passé par la chaîne spec (écran ou back) coûte plus que le lot ordinaire de même estimate (mesuré le 12–18-10 : +150 k à l'estimate 0,5, +30 k à 1 ; 450 k est l'écart de budget, pas l'écart mesuré) : classe à part, sinon l'arrivée de ces lots dans une fenêtre passe pour un lot ordinaire plus lourd (L240).
-            const key = `${p.estimate}${d.j.steps.some((x) => SPEC_CHAIN.has(x.kind)) ? '+spec' : ''}`;
+            const key = sizeClass(p.estimate, d.j.steps);
             const kinds = new Map();
             for (const x of counted)
                 kinds.set(carrierKind(x.kind), (kinds.get(carrierKind(x.kind)) ?? 0) + x.counted);
@@ -288,6 +290,26 @@ export function computePerf(input) {
         const vals = both(windows, (w) => median((w === windows.current ? lotsOfClass.current : lotsOfClass.previous).map((l) => l.total)));
         byEstimate[key] = { ...mk(vals, { current: lotsOfClass.current.length, previous: lotsOfClass.previous.length }, 'up', twinFirstTime), carrier: carrierOf(lotsOfClass.current.map((l) => l.kinds), lotsOfClass.previous.map((l) => l.kinds)) };
     }
+    // Durée de mur d'un lot rendu par classe d'estimate (L414) : la même clé que les tokens ; un journal sans début ni fin lisibles, ou à fin avant début, n'est pas compté
+    const minutesByClass = (w) => {
+        const classes = new Map();
+        for (const d of rendered(w)) {
+            const p = planLot(plans, d.j.project, d.j.lot);
+            const starts = d.j.steps.map((x) => Date.parse(x.started ?? '')).filter((t) => !Number.isNaN(t));
+            const ends = d.j.steps.map((x) => Date.parse(x.ended ?? '')).filter((t) => !Number.isNaN(t));
+            if (!p || starts.length === 0 || ends.length === 0 || Math.max(...ends) < Math.min(...starts))
+                continue;
+            const key = sizeClass(p.estimate, d.j.steps);
+            classes.set(key, [...(classes.get(key) ?? []), (Math.max(...ends) - Math.min(...starts)) / 60_000]);
+        }
+        return classes;
+    };
+    const minutesClasses = both(windows, minutesByClass);
+    const lotMinutes = {};
+    for (const key of classKeys) {
+        const v = both(windows, (w) => (w === windows.current ? minutesClasses.current : minutesClasses.previous).get(key) ?? []);
+        lotMinutes[key] = mk({ current: median(v.current), previous: median(v.previous) }, { current: v.current.length, previous: v.previous.length }, null, null);
+    }
     const reviewShare = both(windows, (w) => {
         let review = 0;
         let all = 0;
@@ -417,7 +439,7 @@ export function computePerf(input) {
         redDeliveries: mk(reds, deliveriesOf, 'up', 'throughput.delivered'),
         qaBlocking: mk(both(windows, blockingOf), both(windows, deliveredCount), 'up', twinEscaped, escapedNote),
     };
-    const result = { since: input.since ?? null, today, windows, throughput, corrections: correctionsInd, interventions, precheck, escalations: both(windows, (w) => escalationCounts(rendered(w))), instables: both(windows, (w) => instableCounts(rendered(w))), tokens, delays, durations, cost, quality, orphans, warnings: [] };
+    const result = { since: input.since ?? null, today, windows, throughput, corrections: correctionsInd, interventions, precheck, escalations: both(windows, (w) => escalationCounts(rendered(w))), instables: both(windows, (w) => instableCounts(rendered(w))), tokens, lotMinutes, delays, durations, cost, quality, orphans, warnings: [] };
     const bottleneck = bottleneckOf(causes.current);
     for (const [key, ind] of indicatorLines(result))
         if (ind.warn)

package/dist/plan.js

@@ -1,6 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
+import { dirtyContents } from './git.js';
 import { Document, isMap, isSeq, parseDocument } from 'yaml';
 import { isDay, toDay } from './dates.js';
 import { ARCHIVE_DIR, archiveFiles, archiveLots, archiveYear, mergeArchived, newArchiveDoc, readArchiveDoc, selectArchivable } from './archive.js';
@@ -145,6 +146,8 @@ export class Plan {
      * déplacé est au pire en double, ce que le chargement refuse en le nommant, jamais perdu — et toute exception d'écriture (EACCES, disque plein,
      * commande `plan.onWrite` en échec, L346) remet le plan, les fichiers d'année et les fichiers déclarés tels qu'avant ; l'erreur le dit.
      */
+    /** Fichiers que `plan.onWrite` a écrits sans les déclarer, relevés à chaque `save()` de ce processus (L436). */
+    writtenByHook = new Set();
     save() {
         this.writable();
         const hook = this.settings.onWrite;
@@ -193,8 +196,17 @@ export class Plan {
         if (!hook)
             return;
         const limit = hook.timeoutMs ?? ON_WRITE_TIMEOUT_MS;
+        const before = dirtyContents(hook.cwd);
         const r = spawnSync('sh', ['-c', hook.command], { cwd: hook.cwd, encoding: 'utf8', timeout: limit, stdio: ['ignore', 'pipe', 'pipe'] });
         if (r.status === 0) {
+            // Ce que la commande a réellement écrit (L436) : un fichier hors de `files` (déclaration incomplète) doit quand même être commité avec le plan,
+            // sans quoi la livraison refuse « 1 fichier modifié ». Le plan, les archives et les fichiers déclarés ont leur propre chemin.
+            const known = new Set([...written.map((p) => relative(hook.cwd, p)), ...hook.files]);
+            const undeclared = [...dirtyContents(hook.cwd)].filter(([f, content]) => before.get(f) !== content && !known.has(f)).map(([f]) => f);
+            for (const f of undeclared)
+                this.writtenByHook.add(f);
+            if (undeclared.length > 0)
+                notice(`raf: plan.onWrite a écrit ${undeclared.join(', ')}, absent de plan.onWrite.files — l'ajouter dans cadence.yaml (il est cité dans le commit proposé cette fois)`);
             // Un chemin mal déclaré laisse le vrai fichier produit hors du commit du plan (le constat d'origine du lot) : le dire.
             const missing = hook.files.filter((f) => !existsSync(resolve(hook.cwd, f)));
             if (missing.length > 0)
@@ -273,7 +285,7 @@ export class Plan {
     }
     /** Fichiers que produit `plan.onWrite` (L346), relatifs à la racine du dépôt : à commiter avec le plan, même s'ils n'étaient pas encore suivis. */
     get produced() {
-        return this.settings.onWrite?.files ?? [];
+        return [...(this.settings.onWrite?.files ?? []), ...this.writtenByHook];
     }
     /** Fichier d'attendus QA du `qa-reviewer`, relatif à la racine du dépôt. */
     get qaExpectations() {