@sylad/cadence 1.8.0 → 1.10.0

package/dist/orchestrate/command.js

@@ -3,7 +3,7 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
-import { planLoader, readOrchestrateConfig } from '../config.js';
+import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readOrchestrateConfig } from '../config.js';
 import { isDay, toDay } from '../dates.js';
 import { gitRoot } from '../git.js';
 import { onTermination } from '../proc.js';
@@ -11,25 +11,30 @@ import { stopApps } from './app.js';
 import { RafError, isOpen } from '../plan.js';
 import { AGENTS_DIR } from '../skills.js';
 import { pidAlive, sharedStateDir } from '../state.js';
-import { acquireSlot, cadenceHome, freeSlots, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
-import { loadTemplates, newsText, objective, renderBrief } from './briefs.js';
+import { findProjects, isProject as isLeadProject } from '../lead.js';
+import { freeLine, readyFree } from '../ready-free.js';
+import { acquireSlot, cadenceHome, expiredHolds, freeSlots, liveHolds, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
+import { headline, loadTemplates, newsText, objective, renderBrief } from './briefs.js';
 import { readWaits, renderWaits } from './waits.js';
 import { acceptationFile, acceptText } from './accept.js';
+import { noTestGate, noTestText } from './no-test.js';
 import { ficheReviewText } from './fiche.js';
 import { maquetteText } from './maquette.js';
 import { specScreen, specText } from './spec.js';
 import { candidates, parsePriority, parseUntil, readPriority, stopReason } from './continue.js';
-import { Budget, DROPPED, MAX_PASSES, REVIEW_RESERVE, budgetStep, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, handBackDroppedQuestions, needsPrecheck } from './cycle.js';
+import { precheckNothingToFind, Budget, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
 import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
 import { buildArgs, buildLocalArgs, killSessions, mcpServersFor, readAgents, realClaude } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
-import { runPool } from './pool.js';
+import { groupLots, runPool } from './pool.js';
+import { repoBranch } from './integrate.js';
+import { baseBranchOf, keptLines, keptTrees, lotBranch, lotTreeDir, planFileSet, recoverTree, removeTree } from './worktree.js';
 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 } from './table.js';
-import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, snapshotExists, waveReadsControl, waveReadsLotBudget, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
+import { quotaText, 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';
 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
@@ -37,8 +42,11 @@ export const DEFAULT_BUDGET = 2_000_000;
  * 1,09 M), au-delà d'un jour p90 1,14 M pour les 10 lots de 1,25 à 2 j (570 k par jour d'estimate), max 1,7 M (L188). Le plafond
  * de L78 (400 k par jour) rendait au lead, au deuxième tour, un lot de 1 j (L188 : 483 k puis 495 k).
  * Plancher relevé de 450 k à 540 k (L218) avec la réserve de la passe fix (155 k) : 14 k + 282 k + 80 k + 155 k = 531 k arrondis, la marge avant refus du fix reste 385 k.
+ * Relevé à 600 k (L247), mesuré sur 16–22-10 : 145 lots à 540 k, p90 451 k, 3 au-dessus (tous maritime-atlas : 12 lots, p90 556 k, max 609 k) ; la marge
+ * avant refus du fix passe à 445 k. Les lots à 750 k (60 lots, p90 571 k, 0 dépassement) et à 1,3 M (20 lots, p90 904 k, 1 dépassement) tiennent : inchangés.
+ * Remesuré sur 17–23-10 (L280, `docs/perf/recalage-2026-10-24.md`) : 0 lot sur 309 au-dessus de son budget, p90 452 k à 600 k, 563 k à 750 k, 875 k à 1,3 M : tous inchangés, avec au moins 10 % de marge.
  */
-const LOT_BUDGET_FLOOR = 540_000;
+const LOT_BUDGET_FLOOR = 600_000;
 /** Lot de plus de 0,5 j et d'au plus 1 j : p90 mesuré du total, 732 k arrondis à 750 k. */
 const LOT_BUDGET_ONE_DAY = 750_000;
 /** Tokens par jour d'estimate au-delà d'un jour : p90 1,14 M pour 2 j. */
@@ -121,7 +129,7 @@ function lotBudgetArg(text) {
     return { project: target.project, lot: target.lot, raise, text: m[2] };
 }
 export function parseOrchestrateArgs(argv) {
-    const a = { lots: [], lotBudgets: [], dryRun: false, waits: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false };
+    const a = { lots: [], lotBudgets: [], dryRun: false, waits: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false, integrate: [], abandonCommits: false };
     const optional = (i) => (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-') && !LOT_LIKE.test(argv[i + 1]) ? argv[i + 1] : undefined);
     for (let i = 0; i < argv.length; i++) {
         const t = argv[i];
@@ -158,12 +166,29 @@ export function parseOrchestrateArgs(argv) {
         }
         else if (t === '--max-sessions')
             a.maxSessions = parseMaxSessions(value(t));
+        else if (t === '--goal') {
+            // Un texte oublié ne doit pas avaler l'option suivante (`--goal --dry-run` lancerait une vraie vague payante).
+            const next = argv[i + 1];
+            if (next?.startsWith('--'))
+                throw new RafError(`--goal attend un texte, pas l'option ${next}`);
+            a.goal = value(t).trim();
+            if (a.goal === '')
+                throw new RafError('--goal attend un texte non vide');
+        }
         else if (t === '--wave')
             a.wave = value(t);
         else if (t === '--drop')
             a.drop.push(lotArg(value(t)));
         else if (t === '--stop-after-current')
             a.stopAfterCurrent = true;
+        else if (t === '--integrate')
+            a.integrate.push(lotArg(value(t)));
+        else if (t === '--replay')
+            a.integrate.push({ ...lotArg(value(t)), replay: true });
+        else if (t === '--remove-worktree')
+            a.removeWorktree = lotArg(value(t));
+        else if (t === '--abandon-commits')
+            a.abandonCommits = true;
         else if (t === '--continue')
             a.continue = true;
         else if (t === '--until')
@@ -179,6 +204,13 @@ export function parseOrchestrateArgs(argv) {
         else
             a.lots.push(lotArg(t));
     }
+    // L309 : --wave <id> après un --resume sans valeur désigne la vague à reprendre ; sans cela le --resume reprenait en silence une AUTRE vague.
+    if (a.resume !== undefined && a.wave !== undefined) {
+        if (a.resume === true)
+            a.resume = a.wave;
+        else if (a.resume !== a.wave)
+            throw new RafError(`--resume ${a.resume} et --wave ${a.wave} désignent deux vagues : une seule (${resumeCommand('<vague>')})`);
+    }
     return a;
 }
 /** Ce qu'un projet fournit à l'orchestrateur : sa configuration et la lecture de son plan (comme le CLI). */
@@ -187,7 +219,7 @@ export function projectEnv(repo) {
     const loadPlan = planLoader(repo);
     return { config: readOrchestrateConfig(configPath), loadPlan, configPath };
 }
-const isProject = (dir) => existsSync(join(dir, 'docs/plan/raf.yaml')) || (existsSync(join(dir, 'cadence.yaml')) && /^plan\s*:/m.test(readFileSync(join(dir, 'cadence.yaml'), 'utf8')));
+const isProject = (dir) => existsSync(join(dir, PLAN_DEFAULT)) || existsSync(join(dir, PLAN_LEGACY)) || (existsSync(join(dir, 'cadence.yaml')) && /^plan\s*:/m.test(readFileSync(join(dir, 'cadence.yaml'), 'utf8')));
 function resolveTargets(args, io, refusals) {
     const out = [];
     const seen = new Set();
@@ -205,7 +237,7 @@ function resolveTargets(args, io, refusals) {
             continue;
         }
         if (!isProject(projectDir)) {
-            refusals.push(`${key} : ${projectDir} n'est pas un projet cadence (docs/plan/raf.yaml, ou cadence.yaml avec une clé plan:)`);
+            refusals.push(`${key} : ${projectDir} n'est pas un projet cadence (${PLAN_DEFAULT}, ${PLAN_LEGACY}, ou cadence.yaml avec une clé plan:)`);
             continue;
         }
         const repo = gitRoot(projectDir);
@@ -312,10 +344,12 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             continue;
         }
         const small = lot.estimate <= 0.5 || lot.quickwin;
+        const goal = args.goal ?? lot.goal;
         const screen = specScreen(t.repo, env.config.spec.dir, lot);
-        const state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, visible: lot.visible, small, ...(screen ? { screen } : {}), ...(lot.spec && !screen ? { specLot: true } : {}), model: t.model, readOnlyPlan: plan.readonly });
+        const state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, ...(goal ? { goal } : {}), visible: lot.visible, small, ...(screen ? { screen } : {}), ...(lot.spec && !screen ? { specLot: true } : {}), model: t.model, readOnlyPlan: plan.readonly });
         if (neighbours.repos.length)
             state.repos = neighbours.repos;
+        state.estimate = lot.estimate;
         state.light = lot.estimate <= env.config.review.threshold;
         state.budget = lotBudget(lot.estimate, screen ? 'screen' : lot.spec ? 'spec' : undefined);
         state.dependsOn = lot.after.filter((d) => earlier.includes(d));
@@ -349,13 +383,18 @@ function dryRun(lots, io, deps, budget, id) {
     const agents = agentsOf(deps);
     io.out(`vague ${id} — simulation, rien n'est lancé (budget ${budget} tokens comptés)`);
     const repos = [...new Set(lots.map((l) => l.repo))];
+    const noTestSaid = new Set();
     for (const l of lots) {
         const env = projectEnv(l.repo);
         const lot = env.loadPlan().lot(l.lot);
         const slot = repos.indexOf(l.repo);
         io.out(`${lotKey(l.project, l.lot)} — ${l.title}`);
+        if (l.goal)
+            io.out(`  objectif donné : ${l.goal} (à la place du titre dans les briefs)`);
         io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, l.screen ? 'screen' : l.specLot ? 'spec' : undefined)})`);
-        io.out(`  file ${basename(l.repo)} · ${slot < 2 ? `créneau ${slot + 1}` : 'en attente d\'un créneau'}`);
+        const mine = lots.filter((o) => o.repo === l.repo);
+        const together = env.config.worktrees && mine.length > 1 && !mine.some((o) => o.repos?.length) && !!repoBranch(l.repo);
+        io.out(together ? `  file ${basename(l.repo)} · en parallèle des autres lots du dépôt, dans son worktree (cadence/${id}/${lotSlug(l.project, l.lot)}, créé à la prise du créneau)` : `  file ${basename(l.repo)} · ${slot < 2 ? `créneau ${slot + 1}` : 'en attente d\'un créneau'}`);
         if (l.repos?.length)
             io.out(`  dépôts voisins : ${l.repos.map((r) => r.rel).join(', ')} (verrou, garde de push et --add-dir ; leurs commits citent ${l.lot})`);
         if (l.node) {
@@ -373,8 +412,13 @@ function dryRun(lots, io, deps, budget, id) {
             steps.unshift({ kind: 'fiche', model: 'sonnet' });
         if (specStage)
             steps.unshift({ kind: 'spec', model: 'sonnet' });
-        if (needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot, l.repos))
-            steps.unshift({ kind: 'precheck', model: env.config.precheckLocal ? 'local' : 'sonnet' });
+        if (needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot, l.repos, l.goal)) {
+            const nothingToFind = precheckNothingToFind(env.loadPlan(), l.repo, l.lot, l.repos, l.goal);
+            if (nothingToFind)
+                io.out(`  contrôle préalable sauté : ${nothingToFind}`);
+            else
+                steps.unshift({ kind: 'precheck', model: env.config.precheckLocal ? 'local' : 'sonnet' });
+        }
         const { light, full } = env.config.review;
         if (l.small)
             steps.push({ kind: l.visible ? 'review-small' : 'review', model: l.light ? light : full });
@@ -384,11 +428,15 @@ function dryRun(lots, io, deps, budget, id) {
                 steps.push({ kind: 'ux', model: full }); // L221 : l'UX est jouée une fois, après la revue de code conforme
         }
         io.out(`  étapes : ${steps.map((s) => `${s.kind} (${s.model})`).join(' → ')}${l.small ? ' — petit lot' : ''}${l.light ? ` — revue légère (${light}, pas de passe des mineurs ; un bloquant ou un majeur → correction puis revue ${full})` : ''}${l.visible && !env.config.ux ? ' — UX à faire par le lead (orchestrate.ux absent)' : ''}`);
+        const noTest = noTestSaid.has(l.repo) ? null : noTestGate(l.repo);
+        noTestSaid.add(l.repo);
+        if (noTest)
+            io.out(`  ${basename(l.repo)} · ${noTestText(noTest)}`);
         io.out(`  corrections : ${MAX_PASSES} passe(s) au plus (${MAX_PASSES_CONVERGING} si la revue converge), en session neuve`);
         io.out(l.light ? '  revue conforme avec mineurs : pas de passe des mineurs, ils sont rendus en notes' : '  revue conforme avec mineurs : une passe de correction des mineurs (session neuve), puis une revue courte ; les mineurs refusés sont rendus en « choix »');
         const pwDir = join(resolve(RunStore.runsDir(io.cwd)), id, lotSlug(l.project, l.lot), 'playwright');
         // brief écrit par --dry-run = base d'une délégation à la main : aucun dossier de vague (il n'existe pas)
-        const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '' };
+        const vars = { chemin: l.repo, lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '' };
         if (specStage)
             vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, back: !!l.specLot });
         if (l.screen && env.config.maquette)
@@ -434,38 +482,100 @@ function duration(ms) {
     const s = Math.round(ms / 1000);
     return s < 60 ? `${s} s` : `${Math.floor(s / 60)} min ${String(s % 60).padStart(2, '0')} s`;
 }
-/** Vagues vivantes (toutes, quel que soit leur dossier de départ), créneaux libres et dépôts qu'elles tiennent. */
-export function liveLines(cap = DEFAULT_MAX_SESSIONS) {
+/** Vagues vivantes (toutes, quel que soit leur dossier de départ), sessions du lead (L255), créneaux libres et dépôts qu'elles tiennent. Rien sans vague ni session du lead. */
+export function liveLines(cap = DEFAULT_MAX_SESSIONS, now = new Date()) {
     const home = cadenceHome();
     const waves = liveWaves(home);
-    if (waves.length === 0)
+    const holds = liveHolds(home, now);
+    if (waves.length === 0 && holds.length === 0)
         return [];
     const slots = liveSlots(home).length;
-    const lines = [`vagues en cours : ${waves.length} · sessions en cours : ${slots} · créneaux libres : ${freeSlots(waves, cap)} sur ${cap}`];
+    const lead = holds.length ? ` · sessions du lead : ${holds.length} (${holds.map((h) => h.label).join(', ')})` : '';
+    const lines = [`vagues en cours : ${waves.length} · sessions en cours : ${slots}${lead} · créneaux libres : ${freeSlots(waves, cap, holds.length)} sur ${cap}`];
     for (const w of waves)
         lines.push(`  ${w.wave} (pid ${w.pid}, depuis ${w.started}) lancée depuis ${w.cwd} · plafond ${w.cap ?? '?'} · dépôts : ${w.repos.join(', ')}`);
     return lines;
 }
+/** Durée à la minute : « 12 min », « 5 h 10 min », « 2 j 3 h ». */
+function longDuration(ms) {
+    const m = Math.max(0, Math.floor(ms / 60_000));
+    if (m < 60)
+        return `${m} min`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h} h ${String(m % 60).padStart(2, '0')} min`;
+    return `${Math.floor(h / 24)} j ${h % 24} h`;
+}
+/** Une ligne ⚠ par session du lead dont le TTL est échu et qui n'a pas été rendue (L278) : vide sans session échue. */
+export function expiredHoldLines(now = new Date()) {
+    return expiredHolds(cadenceHome(), now).map((h) => {
+        const since = Date.parse(h.since);
+        const age = Number.isFinite(since) ? `inscrite depuis ${longDuration(now.getTime() - since)}, ` : '';
+        return `⚠ session du lead échue : ${h.label} (${age}échue depuis ${longDuration(now.getTime() - Date.parse(h.expires))}) — la reprendre (cadence lead hold ${h.label} --ttl <minutes>) ou l'arrêter (cadence lead release ${h.label})`;
+    });
+}
+/** `--continue` (L252) : la ligne des lots prêts dont aucune ressource n'est prise par un lot en cours ni par une vague, sans les lots du premier tirage `drawn` ni les ressources qu'ils tiennent. Vide si aucun. */
+function freeLines(launch, drawn) {
+    const dirs = isLeadProject(launch) ? [launch] : findProjects(launch);
+    const free = readyFree(dirs, cadenceHome(), drawn);
+    const line = freeLine(dirs.filter((d) => free.has(d)).map((d) => ({ project: basename(d), free: free.get(d) })), 60);
+    return line ? [line] : [];
+}
 /** Efface l'écran et replace le curseur en haut : l'entrée d'un rendu de `--status --watch`. */
 const CLEAR_SCREEN = '\x1b[H\x1b[2J';
 const DEFAULT_WATCH_INTERVAL = 10;
 /** Ce que `--status` montre à un instant : les vagues vivantes, puis le tableau (absent si seules les vagues vivantes comptent). */
-function statusView(args, launch, cap) {
+function statusView(args, launch, cap, now) {
     const store = typeof args.status === 'string' ? RunStore.find(launch, args.status) : RunStore.last(launch);
-    const live = liveLines(cap);
+    const live = [...liveLines(cap, now), ...expiredHoldLines(now)];
+    const waveLive = liveWaves(cadenceHome()).length > 0;
     if (!store && live.length && args.status === true)
-        return { live, running: true };
+        return { live, running: waveLive };
     if (!store)
         throw new RafError(typeof args.status === 'string' ? `vague inconnue : ${args.status}` : 'aucune vague dans ce dossier');
     // `running` : la vague suivie tourne — pour un <id> explicite, elle seule compte, pas les autres vagues de la machine
-    const running = typeof args.status === 'string' ? liveWaves(cadenceHome()).some((w) => w.wave === store.readWave().id) : live.length > 0;
-    return { live, table: renderTable(store.readWave(), store.lots()), running };
+    const running = typeof args.status === 'string' ? 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 };
 }
 /** Refus d'une `--wave` déjà existante, identique en simulation et au vrai lancement. */
 function waveExists(wave, io) {
     io.err(`orchestrate : --wave ${wave} : cette vague existe déjà`);
     return 2;
 }
+/**
+ * `--remove-worktree projet:lot` (L279, R20) : seule commande qui retire un worktree conservé. Refus (code 2, rien retiré) pour le worktree d'une vague vivante (même avec `--abandon-commits`), et tant qu'un commit du lot n'est ni
+ * intégré à la branche du dépôt ni confirmé abandonné par `--abandon-commits` ; un worktree entièrement intégré se retire sans option. `--wave` désigne la vague
+ * quand plusieurs ont laissé un worktree pour ce lot.
+ */
+function removeWorktree(args, io) {
+    const t = args.removeWorktree;
+    const key = `${t.project ?? basename(io.cwd)}:${t.lot}`;
+    const projectDir = t.project ? resolve(io.cwd, t.project) : io.cwd;
+    const repo = existsSync(projectDir) ? gitRoot(projectDir) : null;
+    const kept = repo ? keptTrees(repo, { includeActive: true }).filter((k) => k.lot === key && (args.wave === undefined || k.wave === args.wave)) : [];
+    if (!repo || kept.length === 0) {
+        io.err(`orchestrate : ${key} : aucun worktree conservé`);
+        return 2;
+    }
+    if (kept.length > 1) {
+        io.err(`orchestrate : ${key} : plusieurs worktrees conservés (vagues ${kept.map((k) => k.wave).join(', ')}) : précisez --wave`);
+        return 2;
+    }
+    const k = kept[0];
+    if (k.active) {
+        // une vague vivante joue encore ce lot (ses sessions travaillent dans ce dossier) : refus sans rien retirer, même avec --abandon-commits
+        io.err(`orchestrate : ${key} : la vague ${k.wave} est vivante et joue ce lot : worktree non retirable (arrêter la vague d'abord)`);
+        return 2;
+    }
+    const gone = removeTree({ repo, dir: k.dir ?? '', branch: k.branch, base: k.base }, { abandon: args.abandonCommits });
+    if (!gone.ok) {
+        io.err(gone.dirty ? `orchestrate : ${key} : fichiers suivis modifiés dans le worktree (${gone.dirty.join(', ')}), --abandon-commits pour les abandonner` : gone.untracked ? `orchestrate : ${key} : fichiers non suivis dans le worktree (${gone.untracked.join(', ')}), --abandon-commits pour les abandonner` : `orchestrate : ${key} : ${gone.unintegrated} commit(s) non intégré(s), --abandon-commits pour les abandonner`);
+        return 2;
+    }
+    io.out(`orchestrate : ${key} : worktree retiré (${gone.abandoned} commit(s) abandonné(s))`);
+    return 0;
+}
 /** Point d'entrée de `cadence orchestrate`. 0 prêts · 1 rendus au lead · 2 refus avant d'agir · 3 suspendue (budget, quota). */
 export async function orchestrate(argv, io, deps) {
     const args = parseOrchestrateArgs(argv);
@@ -487,10 +597,27 @@ export async function orchestrate(argv, io, deps) {
     if (args.resume !== undefined && args.stopAfterCurrent)
         throw new RafError('--resume ne se combine pas avec --stop-after-current (il reprend la vague, il ne l\'arrête pas)');
     // L228 : la reprise n'a pas de simulation — elle relève le budget, réécrit wave.json et relance les sessions. Refusée ici, avant le réexec de l'instantané (une vague ancienne ne connaît pas ce refus).
+    // L309 : la reprise rejoue les lots de la vague ; des lots à lancer seraient ignorés en silence (--continue, lui, tire la suite du plan après la reprise : L147).
+    if (args.resume !== undefined && args.lots.length) {
+        // Un id de vague qui ressemble à un lot (`--resume suite2`) est lu comme un lot à lancer : le refus donne la forme qui le désigne comme vague.
+        const asWave = args.lots.find((l) => l.project === undefined && l.model === undefined && RunStore.find(launch, l.lot));
+        const hint = asWave ? `« ${asWave.lot} » est une vague de ce dossier : ${resumeCommand(asWave.lot)}` : `pour désigner la vague : ${resumeCommand('<vague>')}`;
+        throw new RafError(`--resume ne se combine pas avec des lots à lancer (il reprend les lots de la vague ; --answer, --drop, --integrate, --replay et --budget projet:lot=+N nomment ceux qu'ils visent) ; ${hint}`);
+    }
     if (args.resume !== undefined && args.dryRun)
         throw new RafError('--resume ne se combine pas avec --dry-run (la reprise écrit l\'état de la vague et relance les sessions, elle ne se simule pas)');
     if (args.lotBudgets.length && args.resume === undefined)
         throw new RafError("--budget projet:lot=+N ne vaut qu'avec --resume");
+    // L279 : --integrate rejoue une intégration rendue, donc une vague arrêtée ; --abandon-commits ne vaut qu'avec --remove-worktree.
+    if (args.integrate.length && args.resume === undefined)
+        throw new RafError(`${args.integrate.some((t) => !t.replay) ? '--integrate' : '--replay'} ne vaut qu'avec --resume`);
+    if (args.abandonCommits && !args.removeWorktree)
+        throw new RafError("--abandon-commits ne vaut qu'avec --remove-worktree");
+    if (args.removeWorktree && (args.lots.length || args.resume !== undefined || args.status !== undefined || args.continue || args.dryRun || args.drop.length || args.stopAfterCurrent || args.waits))
+        throw new RafError("--remove-worktree ne se combine avec aucune autre action");
+    // L258 : l'objectif donné ne vaut que pour UN lot lancé (la clé goal: du lot sert quand plusieurs partent ; --continue tire ses lots lui-même).
+    if (args.goal !== undefined && (args.lots.length !== 1 || args.continue || args.resume !== undefined || args.status !== undefined || args.waits || args.drop.length || args.stopAfterCurrent))
+        throw new RafError("--goal s'applique à un seul lot lancé : <projet>:<lot> --goal \"…\" (plusieurs lots : la clé goal: de chacun)");
     if (args.since !== undefined && !args.waits)
         throw new RafError('--since s\'utilise avec --waits');
     if (args.waits) {
@@ -503,7 +630,7 @@ export async function orchestrate(argv, io, deps) {
     if (args.status !== undefined) {
         maxSessions(args, io); // une valeur invalide est refusée ici aussi
         if (!args.watch) {
-            const { live, table } = statusView(args, launch, configuredCap(io.env, args.maxSessions));
+            const { live, table } = statusView(args, launch, configuredCap(io.env, args.maxSessions), io.now());
             for (const line of live)
                 io.out(line);
             if (!table)
@@ -517,7 +644,7 @@ export async function orchestrate(argv, io, deps) {
         // --watch : le même tableau, rafraîchi ; il s'arrête seul quand plus aucune vague ne tourne (le dernier rendu reste affiché)
         const sleep = deps.watchSleep ?? ((ms) => new Promise((res) => setTimeout(res, ms)));
         for (;;) {
-            const { live, table, running } = statusView(args, launch, configuredCap(io.env, args.maxSessions));
+            const { live, table, running } = statusView(args, launch, configuredCap(io.env, args.maxSessions), io.now());
             io.out(CLEAR_SCREEN);
             for (const line of live)
                 io.out(line);
@@ -534,12 +661,14 @@ export async function orchestrate(argv, io, deps) {
             await sleep((args.interval ?? DEFAULT_WATCH_INTERVAL) * 1000);
         }
     }
+    if (args.removeWorktree)
+        return removeWorktree(args, io);
     if (args.resume !== undefined)
         return resume(args, argv, io, deps, launch, today);
     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"] | --drop projet:lot | --stop-after-current');
+        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]');
     const refusals = [];
     const targets = resolveTargets(args, io, refusals);
     const pre = await preflight(args, targets, io, deps, launch);
@@ -565,6 +694,9 @@ export async function orchestrate(argv, io, deps) {
         if (args.wave && existsSync(join(RunStore.runsDir(launch), id)))
             return waveExists(args.wave, io);
         dryRun(pre.lots, io, deps, budget, id);
+        if (args.continue)
+            for (const l of freeLines(launch, pre.lots))
+                io.out(l);
         if (args.continue)
             await continueDryRun(args, io, deps, launch, pre.lots, budget, firstSkipped);
         return 0;
@@ -604,6 +736,9 @@ export async function orchestrate(argv, io, deps) {
         }
     }
     const id = store.id;
+    if (args.continue)
+        for (const l of freeLines(launch, pre.lots))
+            io.out(l);
     // Les candidats refusés au premier tirage : leur cause dit pourquoi ils ne jouent pas (même ligne que celles des tirages suivants).
     for (const s of firstSkipped) {
         io.err(`orchestrate : lot sauté — ${s}`);
@@ -781,6 +916,45 @@ async function continueRounds(first, wave, all, store, io, deps, today, args, la
 function contexts(lots, envs, wctx) {
     return lots.map((lot, i) => ({ wave: wctx, lot, config: envs[i].config, loadPlan: envs[i].loadPlan }));
 }
+/**
+ * Quels lots jouent dans un worktree (L279). Un groupe de lots du même dépôt (`groupLots`) y joue si `orchestrate.worktrees` est vrai, s'il a au moins deux lots,
+ * si le dépôt est sur une branche et si aucun de ses lots n'a de dépôt voisin (`repos:`, R2) ; sinon les lots restent à la suite, avec un avertissement qui dit pourquoi.
+ * Un lot dont la branche existe déjà (reprise, R11) retrouve son worktree quel que soit le groupe ; un lot rendu à l'intégration dont la branche a disparu n'en reçoit pas. La branche de départ est celle du dépôt du lead à cet instant,
+ * ou celle que la branche du lot a notée à sa création.
+ */
+function planTrees(ctxs, store, wave, log) {
+    for (const group of groupLots(ctxs)) {
+        const repo = group[0].lot.repo;
+        const branch = repoBranch(repo);
+        const requested = group.length > 1 && group.every((c) => c.config.worktrees);
+        const why = !requested ? null : group.some((c) => c.lot.repos?.length) ? 'des lots du groupe ont des dépôts voisins (repos:)' : !branch ? 'le dépôt est en HEAD détaché' : null;
+        if (why)
+            log(`orchestrate : ${basename(repo)} : worktrees demandés mais ${why} : lots joués à la suite`);
+        for (const c of group) {
+            const lotBr = lotBranch(wave, c.lot.project, c.lot.lot);
+            // Chemin de reprise d'un lot rendu hors intégration : sa branche d'une vague passée devient celle de cette vague (recoverTree), puis se retrouve comme une reprise (R11).
+            const dir = lotTreeDir(store.dir, c.lot.project, c.lot.lot, repo);
+            const recovered = !baseBranchOf(repo, lotBr) && c.lot.next !== 'integrate' && branch && c.config.worktrees ? recoverTree(repo, lotBr, dir, branch, planFileSet(c.loadPlan(), repo)) : null;
+            if (recovered && 'refused' in recovered)
+                log(`orchestrate : ${lotKey(c.lot.project, c.lot.lot)} : branche ${recovered.from} d'une vague précédente non reprise : ${recovered.refused} ; le lot repart de zéro (à nettoyer à la main, ou intégration à la main documentée)`);
+            else if (recovered) {
+                log(`orchestrate : ${lotKey(c.lot.project, c.lot.lot)} : branche ${recovered.from} d'une vague précédente reprise (${recovered.unintegrated} commit(s) non intégré(s)) : le lot repart de son travail`);
+                // L311 : le lot repris ne repasse pas par le contrôle préalable. Il reprend les constats de sa dernière revue (état de la vague qui l'a rendu) et repart à leur correction, ou à la revue quand il en a déjà passé une sans constat ; rendu avant sa première revue (ou état illisible ; les constats `tests` d'un lot rendu pour tests rouges ne font pas une revue, L318), il repart à l'écriture.
+                const old = new RunStore(store.launchDir, recovered.from.split('/')[1]).readLot(c.lot.project, c.lot.lot);
+                c.lot.resumedFrom = recovered.from.split('/')[1];
+                c.lot.constats = old?.constats ?? [];
+                c.lot.resumedReviewed = !!old && (old.constats.some((k) => k.source === 'code') || old.steps.some((s) => s.kind.startsWith('review')));
+            }
+            const known = baseBranchOf(repo, lotBr);
+            const base = known ?? branch;
+            // Un lot repris à l'intégration dont la branche n'existe plus (retirée par --remove-worktree --abandon-commits) n'a plus de commits à intégrer : pas de worktree recréé au sommet, `integrateLot` le rend.
+            if (c.lot.next === 'integrate' && !known)
+                continue;
+            if (((requested && !why) || known) && base)
+                c.tree = { dir, branch: lotBr, base, active: false };
+        }
+    }
+}
 /** Pose les verrous et les hooks, joue la vague, range l'état, rend le tableau et le code de sortie. */
 async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     const launch = store.launchDir;
@@ -795,6 +969,8 @@ 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
     const freeRepo = (r) => {
         freed.add(r);
         const file = join(sharedStateDir(r), REPO_LOCK);
@@ -802,7 +978,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         held.splice(0, held.length, ...held.filter((f) => f !== file));
         removePrePush(r, wave.id);
         try {
-            updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)));
+            updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)), lanes());
         }
         catch {
             // registre illisible : `--status` garde la liste de départ, le verrou est bien tombé
@@ -852,6 +1028,13 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         const free = await acquireSlot(home, cap, {
             wave: wave.id,
             pollMs: deps.slotPollMs,
+            // L332 : une demande écrite pendant l'attente (`--drop` de ce lot, `--stop-after-current`) l'interrompt ; la session ne part pas.
+            abandon: () => {
+                const ctl = store.control();
+                if (o.lot && ctl.drops.includes(o.lot))
+                    return DROPPED;
+                return ctl.stopAfterCurrent ? STOP_REQUESTED : null;
+            },
             onWait: (h, ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}en attente d'un créneau de session depuis ${duration(ms)} (${h.length}/${cap} en cours : ${[...new Set(h.map((x) => x.wave))].join(', ')})`),
             onGot: (ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}créneau de session obtenu après ${duration(ms)} d'attente`),
         });
@@ -887,11 +1070,19 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
             store.journal(line);
         },
         saveWave,
+        integrate: deps.integrate,
     };
     wave.status = 'running';
     wave.pid = process.pid;
     saveWave();
     const ctxs = contexts(lots, envs, wctx);
+    planTrees(ctxs, store, wave.id, wctx.log);
+    try {
+        updateWaveRepos(home, process.pid, repos, lanes());
+    }
+    catch {
+        // registre illisible : le décompte des créneaux libres reste celui des dépôts
+    }
     // Ctrl-C, SIGTERM : les sessions sont tuées en bloc, les étapes marquées interrompues, les verrous et hooks libérés.
     const forget = onTermination(async () => {
         killSessions();
@@ -902,11 +1093,18 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
                     s.status = 'interrupted';
                 // Les tokens d'une session tuée comptent : relus dans son journal.
                 if (s.status === 'interrupted')
-                    countInterrupted(deps.claudeHome, c.lot.repo, s, budget);
+                    countInterrupted(deps.claudeHome, workDir(c), s, budget);
             }
             if (c.lot.status === 'implementing' || c.lot.status === 'reviewing' || c.lot.status === 'fixing')
                 c.lot.status = 'suspended';
             store.writeLot(c.lot);
+            // Le TMPDIR court de la session tuée (L243) est hors de la vague : sans cela il resterait dans /tmp.
+            try {
+                store.removeTmpDir(c.lot.project, c.lot.lot);
+            }
+            catch {
+                // nettoyage de confort
+            }
         }
         wave.status = 'interrupted';
         saveWave();
@@ -915,6 +1113,12 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     const finished = lotFinished;
     try {
         await runPool(ctxs, cap, all, (c) => {
+            // Un lot rendu ou en échec garde son worktree et sa branche (R12) : le journal en donne le chemin.
+            if (c.tree?.active && c.lot.status !== 'ready')
+                wctx.log(`orchestrate : ${lotKey(c.lot.project, c.lot.lot)} : worktree conservé : ${c.tree.dir} (branche ${c.tree.branch})`);
+            // Un lot rendu à l'étape d'intégration (`next: integrate`) : la ligne donne la commande qui le reprend (L279, R27).
+            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.
             if (wctx.incident)
                 return;
@@ -922,7 +1126,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
                 if (held.includes(join(sharedStateDir(r), REPO_LOCK)) && all.filter((l) => lotRepoPaths(l).includes(r)).every(finished))
                     freeRepo(r);
             }
-        });
+        }, (lots) => lots.every((c) => c.tree));
         handBackDroppedQuestions(ctxs); // un lot en question retiré pendant la vague : rendu avant de fixer le statut de la vague
     }
     finally {
@@ -938,6 +1142,8 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         io.err(`orchestrate : quota atteint — ${quotaText(wctx.quota.message ?? '')}`.trim());
     for (const line of renderTable(wave, all))
         io.out(line);
+    for (const line of keptLines(all.map((l) => l.repo)))
+        io.out(line); // les worktrees conservés, avec leur chemin (R19)
     if (wave.status === 'suspended-budget' || wave.status === 'suspended-quota')
         return 3;
     return all.every((l) => l.status === 'ready') ? 0 : 1;
@@ -990,21 +1196,72 @@ function control(args, io) {
     if (args.stopAfterCurrent) {
         store.requestStopAfterCurrent();
         store.journal('demande : arrêt après les sessions en cours');
-        io.out(`vague ${store.id} : arrêt demandé — les sessions en cours finissent, aucune autre ne part ; reprise par « cadence orchestrate --resume ${store.id} »`);
+        io.out(`vague ${store.id} : arrêt demandé — les sessions en cours finissent, aucune autre ne part ; reprise par « ${resumeCommand(store.id)} »`);
     }
     return 0;
 }
+/** La seule vague non terminée du dossier (L309) ; plusieurs : refus qui les liste, aucune : refus (jamais le choix silencieux de la plus récente). */
+function singleUnfinished(launch) {
+    const open = RunStore.unfinished(launch);
+    if (open.length === 0)
+        throw new RafError('aucune vague à reprendre dans ce dossier');
+    if (open.length > 1)
+        throw new RafError(`plusieurs vagues non terminées dans ce dossier, laquelle reprendre ?\n${open.map((s) => `  ${s.id} (${s.readWave()?.status ?? 'illisible'}, lancée ${s.readWave()?.created ?? '?'})`).join('\n')}\nreprise : ${resumeCommand('<vague>')}`);
+    return open[0];
+}
+/**
+ * L309 : l'instantané d'une vague antérieure relit `--wave <id>` comme un simple nom et `--resume` seul comme « la dernière vague non terminée » :
+ * on lui transmet la vague choisie en clair (`--resume <id>`, sans `--wave`), quel que soit le parseur qui la lira.
+ */
+export function resumeArgv(argv, id) {
+    const out = [];
+    for (let i = 0; i < argv.length; i++) {
+        const t = argv[i];
+        if (t === '--wave')
+            i++;
+        else if (t === '--resume') {
+            out.push(t, id);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith('-') && !LOT_LIKE.test(next))
+                i++;
+        }
+        else if (t === '--answer')
+            out.push(t, argv[++i] ?? '', argv[++i] ?? '');
+        else
+            out.push(t);
+    }
+    return out;
+}
 async function resume(args, argv, io, deps, launch, today) {
-    const store = typeof args.resume === 'string' ? RunStore.find(launch, args.resume) : RunStore.last(launch, { unfinished: true });
+    const store = typeof args.resume === 'string' ? RunStore.find(launch, args.resume) : singleUnfinished(launch);
     if (!store)
-        throw new RafError(typeof args.resume === 'string' ? `vague inconnue : ${args.resume}` : 'aucune vague à reprendre dans ce dossier');
+        throw new RafError(`vague inconnue : ${args.resume}`);
     if (deps.snapshot) {
         // La reprise tourne sur l'instantané de la vague, jamais sur le dist/ courant ; une vague d'avant L61 n'en a pas.
-        if (snapshotExists(store.dir)) {
+        if (LOT_LIKE.test(store.id) && snapshotExists(store.dir)) {
+            // L309 : `--resume suite2` serait relu par n'importe quel parseur comme un lot à lancer ; `--wave suite2`, un instantané d'avant L309 le prendrait pour un simple nom et reprendrait une autre vague.
+            io.err(`orchestrate : vague ${store.id} : son nom ressemble à un lot, l'instantané ne saurait pas le relire comme une vague : reprise avec le dist/ et les gabarits courants`);
+        }
+        else if (snapshotExists(store.dir)) {
             // Une vague d'avant L223 refuserait « projet:lot=+N » comme budget invalide : seul le lot visé justifie de la rejouer avec le dist/ courant.
-            if (!args.lotBudgets.length || waveReadsLotBudget(store.dir))
-                return deps.snapshot.reexec(toolDirOf(store.dir), argv, io.env, io);
-            io.err(`orchestrate : vague ${store.id} : son instantané ne connaît pas --budget projet:lot=+N (antérieur à L223) : reprise avec le dist/ et les gabarits courants`);
+            if ((!args.lotBudgets.length || waveReadsLotBudget(store.dir)) && (!args.integrate.length || waveReadsIntegrate(store.dir)) && (!args.integrate.some((t) => t.replay) || waveReadsReplay(store.dir))) {
+                // L330 : la copie dont l'instantané lie le node_modules a pu être purgée par une mise en service ; on relie, on le journalise, ou on refuse proprement.
+                try {
+                    const healed = repairSnapshotModules(store.dir, deps.snapshot.packageRoot);
+                    if (healed) {
+                        store.journal(healed);
+                        io.err(`orchestrate : vague ${store.id} : ${healed}`);
+                    }
+                }
+                catch (e) {
+                    if (!(e instanceof SnapshotRefusal))
+                        throw e;
+                    io.err(`orchestrate : vague ${store.id} : ${e.message}`);
+                    return 2;
+                }
+                return deps.snapshot.reexec(toolDirOf(store.dir), resumeArgv(argv, store.id), io.env, io);
+            }
+            io.err(`orchestrate : vague ${store.id} : son instantané ne connaît pas ${args.lotBudgets.length && !waveReadsLotBudget(store.dir) ? '--budget projet:lot=+N (antérieur à L223)' : `${args.integrate.some((t) => t.replay) && waveReadsIntegrate(store.dir) ? '--replay' : '--integrate'} (antérieur à L279)`} : reprise avec le dist/ et les gabarits courants`);
         }
         else {
             io.err(`orchestrate : vague ${store.id} sans instantané (antérieure à L61) : reprise avec le dist/ et les gabarits courants`);
@@ -1019,7 +1276,7 @@ async function resume(args, argv, io, deps, launch, today) {
     if (alive)
         refusals.push(`la vague ${alive.wave} tourne encore (pid ${alive.pid})`);
     // Une vague terminée ne se reprend que pour rejouer un lot visé par --budget projet:lot=+N (L223) ; ce lot est vérifié plus bas.
-    if (wave.status === 'done' && !args.lotBudgets.length)
+    if (wave.status === 'done' && !args.lotBudgets.length && !args.integrate.length)
         refusals.push(`la vague ${wave.id} est terminée`);
     const lots = store.lots();
     for (const a of args.answers) {
@@ -1072,11 +1329,37 @@ async function resume(args, argv, io, deps, launch, today) {
         else
             raised.set(l, { from: l.budget ?? lotSpent(l), to: lotSpent(l) + b.raise, step: budgetStep(l) });
     }
+    // --resume --integrate projet:lot (L279, R27) : un lot rendu à l'étape d'intégration (next: integrate) n'est rejoué que si le lead le nomme. Ni --resume seul, ni --drop, --answer ou --budget ne le rejouent.
+    const integ = [];
+    const budgeted = args.lotBudgets.map((b) => lots.filter((x) => x.lot === b.lot && (b.project ? x.project === b.project : true))).filter((m) => m.length === 1).map((m) => m[0]);
+    for (const t of args.integrate) {
+        const matches = lots.filter((x) => x.lot === t.lot && (t.project ? x.project === t.project : true));
+        const opt = t.replay ? '--replay' : '--integrate';
+        const where = `${t.project ? `${t.project}:` : ''}${t.lot}`;
+        if (matches.length !== 1) {
+            refusals.push(matches.length ? `${opt} ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `${opt} ${where} : lot inconnu dans la vague ${wave.id}`);
+            continue;
+        }
+        const l = matches[0];
+        const key = lotKey(l.project, l.lot);
+        if (integ.includes(l))
+            refusals.push(`${opt} ${key} : lot visé deux fois`);
+        else if (dropped.includes(l))
+            refusals.push(`${opt} ${key} : lot aussi retiré par --drop`);
+        else if (answered.includes(l))
+            refusals.push(`${opt} ${key} : lot aussi visé par --answer`);
+        else if (budgeted.includes(l))
+            refusals.push(`${opt} ${key} : lot aussi visé par --budget`);
+        else if (l.status !== 'handed-back' || (l.next !== 'integrate' && !(t.replay && planNoteHandBack(l))))
+            refusals.push(`${opt} ${key} : le lot n'est pas rendu ${t.replay ? "à l'étape d'intégration ni sur une écriture de plan refusée" : "à l'étape d'intégration"} (${l.status}, étape ${l.next ?? 'aucune'} : ${l.outcome ?? 'sans cause'})`);
+        else
+            integ.push(l);
+    }
     // Un lot retiré ne jouera rien : il ne subit ni le verrou du dépôt, ni le .nvmrc, ni l'arbre sale — un refus pour LUI ne doit pas faire échouer la reprise des autres.
     const live = [];
     const removed = [];
     for (const l of lots) {
-        if (lotFinished(l) && !raised.has(l))
+        if (lotFinished(l) && !raised.has(l) && !integ.includes(l))
             continue;
         for (const s of l.steps) {
             if (s.status !== 'running')
@@ -1113,6 +1396,15 @@ async function resume(args, argv, io, deps, launch, today) {
             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(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}`);
@@ -1126,10 +1418,15 @@ async function resume(args, argv, io, deps, launch, today) {
     }
     // 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, l.repo, s, recovered);
+                countInterrupted(deps.claudeHome, workdirOf(l), s, recovered);
     wave.consumed += recovered.consumed;
     wave.cacheRead += recovered.cacheRead;
     if (recovered.consumed || recovered.cacheRead)
@@ -1145,6 +1442,17 @@ async function resume(args, argv, io, deps, launch, today) {
         store.journal(`${k} → suspended — ${text}`);
         io.out(`${k} → suspended — ${text}`);
     }
+    for (const l of integ) {
+        const k = lotKey(l.project, l.lot);
+        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 = 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';
@@ -1163,6 +1471,13 @@ async function resume(args, argv, io, deps, launch, today) {
         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)) {
@@ -1171,6 +1486,8 @@ async function resume(args, argv, io, deps, launch, today) {
         }
         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;
     }
     return continueRounds(await execute(wave, live, store, io, deps, today, maxSessions(args, io), lots), wave, lots, store, io, deps, today, args, launch);