@sylad/cadence 1.9.0 → 1.10.0

package/dist/orchestrate/changelog-merge.js

@@ -0,0 +1,94 @@
+/** Ordre des sections de Keep a Changelog ; un titre inconnu vient après, dans l'ordre où il apparaît. */
+const SECTION_ORDER = ['Added', 'Changed', 'Deprecated', 'Removed', 'Fixed', 'Security'];
+/** Découpe le fichier autour de `## [Unreleased]` : ce qui précède (titre compris), le bloc, ce qui suit à partir de la version suivante. */
+function split(text) {
+    const lines = text.split('\n');
+    const at = lines.findIndex((l) => /^## \[Unreleased\]/i.test(l));
+    if (at < 0)
+        return null;
+    let end = lines.findIndex((l, i) => i > at && l.startsWith('## '));
+    if (end < 0)
+        end = lines.length;
+    return { head: lines.slice(0, at + 1).join('\n'), block: lines.slice(at + 1, end), tail: lines.slice(end).join('\n') };
+}
+/** Sections du bloc `[Unreleased]` : une entrée est une ligne `- ` et ses lignes de suite. Deux titres identiques sont fondus. Du texte hors entrée : null. */
+function sections(block) {
+    const out = new Map();
+    let current = null;
+    for (const line of block) {
+        if (line.trim() === '')
+            continue;
+        const title = /^### (.+?)\s*$/.exec(line)?.[1];
+        if (title) {
+            current = out.get(title) ?? [];
+            out.set(title, current);
+        }
+        else if (!current) {
+            return null;
+        }
+        else if (line.startsWith('- ')) {
+            current.push(line);
+        }
+        else if (current.length > 0) {
+            current[current.length - 1] += `\n${line}`;
+        }
+        else {
+            return null;
+        }
+    }
+    return out;
+}
+/** `base` est une sous-suite de `side` : rien n'a été retiré ni modifié, seul de l'ajout s'y est glissé. */
+function onlyAdds(base, side) {
+    let i = 0;
+    for (const e of side)
+        if (i < base.length && e === base[i])
+            i++;
+    return i === base.length;
+}
+/** Un côté qui n'a pas bougé laisse l'autre gagner ; deux côtés qui ont bougé de la même façon aussi ; sinon, pas de réponse. */
+function pick(base, ours, theirs) {
+    if (ours === theirs)
+        return ours;
+    if (ours === base)
+        return theirs;
+    if (theirs === base)
+        return ours;
+    return null;
+}
+/**
+ * Fusion à trois du CHANGELOG quand deux lots y ont chacun ajouté une entrée sous `[Unreleased]` (L314) : union par section, un seul titre par section,
+ * sections dans l'ordre de Keep a Changelog, les entrées de `ours` puis celles de `theirs` qui n'y sont pas déjà. Le reste du fichier suit le côté qui l'a
+ * changé. Rend null quand ce n'est pas de l'ajout pur — une entrée de base retirée ou modifiée, du texte libre sous `[Unreleased]`, le reste du fichier
+ * changé des deux côtés, pas de section `[Unreleased]` — : le conflit reste alors à la main.
+ *
+ * `start` est le CHANGELOG du point de départ de la branche rejouée (L323). Une entrée de `base` qui n'y était pas a été ajoutée par un commit précédent du
+ * lot lui-même : `theirs` peut la modifier ou la retirer, sa version gagne (l'ancienne est écartée de `ours`). Sans `start`, aucune entrée n'est au lot.
+ */
+export function mergeUnreleased(base, ours, theirs, start) {
+    const [b, o, t] = [split(base), split(ours), split(theirs)];
+    if (!b || !o || !t)
+        return null;
+    const head = pick(b.head, o.head, t.head);
+    const tail = pick(b.tail, o.tail, t.tail);
+    const [bs, os, ts] = [sections(b.block), sections(o.block), sections(t.block)];
+    if (head === null || tail === null || !bs || !os || !ts)
+        return null;
+    const st = start === undefined ? null : split(start);
+    const startEntries = new Set([...(st ? (sections(st.block)?.values() ?? []) : [])].flat());
+    const own = new Set(start === undefined || !st ? [] : [...bs.values()].flat().filter((e) => !startEntries.has(e)));
+    for (const [title, entries] of bs) {
+        const kept = entries.filter((e) => !own.has(e));
+        if (!onlyAdds(kept, (os.get(title) ?? []).filter((e) => !own.has(e))) || !onlyAdds(entries, os.get(title) ?? []) || !onlyAdds(kept, ts.get(title) ?? [])) {
+            return null;
+        }
+    }
+    const titles = [...new Set([...os.keys(), ...ts.keys()])];
+    const rank = (s) => (SECTION_ORDER.includes(s) ? SECTION_ORDER.indexOf(s) : SECTION_ORDER.length);
+    titles.sort((x, y) => rank(x) - rank(y));
+    const body = titles.map((title) => {
+        const entries = [...new Set([...(os.get(title) ?? []).filter((e) => !own.has(e)), ...(ts.get(title) ?? [])])];
+        return `### ${title}\n\n${entries.join('\n')}\n`;
+    });
+    return `${head}\n\n${body.join('\n')}\n${tail}`;
+}

package/dist/orchestrate/command.js

@@ -17,11 +17,12 @@ import { acquireSlot, cadenceHome, expiredHolds, freeSlots, liveHolds, liveSlots
 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, planNoteHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } 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';
@@ -32,8 +33,8 @@ 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, waveReadsIntegrate, waveReadsLotBudget, waveReadsReplay, 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
@@ -203,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). */
@@ -252,23 +260,6 @@ function olderThanEffort(version) {
     const [a, b, c] = [Number(m[1]), Number(m[2]), Number(m[3])];
     return a < 2 || (a === 2 && (b < 1 || (b === 1 && c < 284)));
 }
-/** Variable d'environnement qui lève le refus de `orchestrate.worktrees: true` (mode expérimental, L279 ; lots L299–L301). Posée par le harnais des tests du mode. */
-export const EXPERIMENTAL_WORKTREES_ENV = 'CADENCE_EXPERIMENTAL_WORKTREES';
-/**
- * Seule décision d'activation du mode worktree (L279) : le départ (`preflight`), la file des lots (`planTrees`, `dryRun`) et la reprise (`resume`) passent tous par elle.
- * Le mode joue si la configuration le demande (ou si le lot repris a une branche `cadence/<vague>/…` à retrouver, `branchKept`) ET si la variable vaut exactement `1`.
- */
-export function worktreesEnabled(config, env, branchKept = false) {
-    return (config.worktrees || branchKept) && env[EXPERIMENTAL_WORKTREES_ENV] === '1';
-}
-/** Le refus de la garde d'activation, ou null : le mode est demandé (configuration, ou branche de lot à retrouver) sans que la variable le permette. */
-function worktreesRefusal(key, config, env, keptBranch) {
-    const wanted = config.worktrees || !!keptBranch;
-    if (!wanted || worktreesEnabled(config, env, !!keptBranch))
-        return null;
-    const what = config.worktrees ? 'orchestrate.worktrees: true' : `la branche ${keptBranch} (lot joué dans un worktree)`;
-    return `${key} : ${what} est refusé : le mode worktree par lot est EXPÉRIMENTAL et non activable tant que les lots L299, L300 et L301 ne sont pas faits (retirer la clé, ou poser ${EXPERIMENTAL_WORKTREES_ENV}=1 pour les tests du mode)`;
-}
 /** Préconditions : tout ce qui peut être refusé l'est ici, avant d'agir, sans verrou ni écriture. */
 async function preflight(args, targets, io, deps, launch, opts = {}) {
     const refusals = [];
@@ -294,12 +285,6 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             refusals.push(`${key} : ${e.message}`);
             continue;
         }
-        // L279 : le mode worktree est une infrastructure expérimentale, non activable tant que L299–L301 ne sont pas faits (refus avant d'agir, `--dry-run` compris).
-        const refused = worktreesRefusal(key, env.config, io.env);
-        if (refused) {
-            refusals.push(refused);
-            continue;
-        }
         if (info && olderThanEffort(info.version) && Object.values(env.config.effort).some((e) => e !== 'default')) {
             refusals.push(`${key} : claude ${info.version} n'a pas --effort (2.1.284 requise) : mettre claude à jour, ou orchestrate.effort à « default » pour chaque passe`);
             continue;
@@ -398,6 +383,7 @@ 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);
@@ -407,7 +393,7 @@ function dryRun(lots, io, deps, budget, id) {
             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)})`);
         const mine = lots.filter((o) => o.repo === l.repo);
-        const together = worktreesEnabled(env.config, io.env) && mine.length > 1 && !mine.some((o) => o.repos?.length) && !!repoBranch(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})`);
@@ -426,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, l.goal))
-            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 });
@@ -437,6 +428,10 @@ 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');
@@ -602,6 +597,13 @@ 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)
@@ -920,11 +922,11 @@ function contexts(lots, envs, wctx) {
  * 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, env) {
+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) => worktreesEnabled(c.config, env));
+        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`);
@@ -932,17 +934,23 @@ function planTrees(ctxs, store, wave, log, env) {
             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 && worktreesEnabled(c.config, env, true) ? recoverTree(repo, lotBr, dir, branch, planFileSet(c.loadPlan(), repo)) : null;
+            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)
+            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 && worktreesEnabled(c.config, env, true))) && base)
+            if (((requested && !why) || known) && base)
                 c.tree = { dir, branch: lotBr, base, active: false };
         }
     }
@@ -1020,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`),
         });
@@ -1061,7 +1076,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     wave.pid = process.pid;
     saveWave();
     const ctxs = contexts(lots, envs, wctx);
-    planTrees(ctxs, store, wave.id, wctx.log, io.env);
+    planTrees(ctxs, store, wave.id, wctx.log);
     try {
         updateWaveRepos(home, process.pid, repos, lanes());
     }
@@ -1103,7 +1118,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
                 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 cadence orchestrate --resume ${wctx.id} --integrate ${lotKey(c.lot.project, c.lot.lot)}`);
+                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;
@@ -1181,20 +1196,71 @@ 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)) && (!args.integrate.length || waveReadsIntegrate(store.dir)) && (!args.integrate.some((t) => t.replay) || waveReadsReplay(store.dir)))
-                return deps.snapshot.reexec(toolDirOf(store.dir), argv, io.env, io);
+            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 {
@@ -1289,24 +1355,6 @@ async function resume(args, argv, io, deps, launch, today) {
         else
             integ.push(l);
     }
-    // L279 : la garde d'activation du mode worktree vaut aussi à la reprise (--resume, --integrate, --replay) : un lot repris dont la configuration demande les worktrees, ou dont la branche est à retrouver, est refusé sans la variable, avant toute écriture.
-    for (const l of lots) {
-        if (lotFinished(l) && !raised.has(l) && !integ.includes(l))
-            continue;
-        if (drops.includes(lotKey(l.project, l.lot)))
-            continue;
-        let config;
-        try {
-            config = projectEnv(l.repo).config;
-        }
-        catch {
-            continue; // un cadence.yaml illisible est refusé par execute, comme avant
-        }
-        const br = lotBranch(wave.id, l.project, l.lot);
-        const refused = worktreesRefusal(lotKey(l.project, l.lot), config, io.env, baseBranchOf(l.repo, br) ? br : undefined);
-        if (refused)
-            refusals.push(refused);
-    }
     // 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 = [];