@sylad/cadence 1.34.1 → 1.36.0

package/dist/orchestrate/command.js

@@ -27,12 +27,15 @@ import { costlyHypotheses, specScreen, specText } from './spec.js';
 import { fichesDuDossier } from '../spec.js';
 import { candidates, parsePriority, parseUntil, drawSettingsReport, readPriority, stopReason } from './continue.js';
 import { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, leadReviewedHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
-import { canInstallPrePush, gitProcessRunning, indexLockRefusal, installPrePush, keepGateGuard, longDuration, removePrePush, snapshot } from './guard.js';
+import { installPrePush, keepGateGuard, longDuration, removePrePush } from './guard.js';
 import { buildArgs, buildLocalArgs, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude, enabledPlugins, settingsFiles } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { groupLots, runPool } from './pool.js';
+import { AddFeed, addNotAlone, addToLive, openInRepo, projectName } from './ajout.js';
+import { repoRefusals, trackedDirty } from './depot.js';
+import { removeWorktree } from './retrait.js';
 import { repoBranch } from './integrate.js';
-import { baseBranchOf, keptLines, keptTrees, lotBranch, lotTreeDir, planFileSet, recoverTree, removeTree } from './worktree.js';
+import { baseBranchOf, keptLines, lotBranch, lotTreeDir, planFileSet, recoverTree } from './worktree.js';
 import { agentOf, schemaFor } from './schemas.js';
 import { resolveLotRepos } from '../repos.js';
 import { excludeState, lotFinished, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
@@ -42,55 +45,8 @@ import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveMo
 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
- * où il est passé, 250 lots, 11-10), rangé par estimate : jusqu'à 0,5 j p90 374 k (152 lots), de 0,5 à 1 j p90 732 k (88 lots, max
- * 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 = 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. */
-const LOT_BUDGET_PER_DAY = 570_000;
-/**
- * Total d'un lot à `screen:` (L194), étapes spec, maquette et accept comprises : p90 1,28 M sur 5 lots (L113 1,12 M, L25 1,28 M, L50 877 k,
- * L85 758 k, L43 238 k), arrondi à 1,3 M. Remplace l'allocation de L191 (+350 k au budget d'estimate), qui ne payait ni l'UX de
- * conformité ni les passes de correction.
- */
-const SCREEN_LOT_BUDGET = 1_300_000;
-/**
- * Allocation d'un lot à fiche `spec: true` (L188/L191), en plus du budget dérivé de l'estimate : sessions spec, fiche et accept hors de
- * l'estimate d'écriture. Relevée de 350 k à 450 k (L218) : la chaîne avant implement du lot spec warhammer L120 a coûté 388 k (350 k : pire cas
- * mesuré des étapes d'un lot à écran, ol L113 : 349 k) ; cadence L217 n'en a pris que 176 k.
- */
-export const SPEC_STAGE_ALLOCATION = 450_000;
-/** Base mesurée d'un budget, pour `--dry-run` : l'estimate (et l'étape spec) d'où il sort. */
-export function lotBudgetBasis(estimate, stage, escalationModel) {
-    const base = ordinaryBasis(estimate, stage);
-    return escalationModel ? `${base}, plus ${ESCALATION_RESERVE} réservés à l'escalade ${escalationModel}` : base;
-}
-function ordinaryBasis(estimate, stage) {
-    if (stage === 'screen' && lotBudget(estimate, stage) === SCREEN_LOT_BUDGET)
-        return "p90 mesuré du total d'un lot à écran, étapes spec, maquette et accept comprises";
-    const ordinary = lotBudget(estimate);
-    const basis = estimate <= 0.5 ? "plancher d'un lot jusqu'à 0,5 j" : estimate <= 1 ? "p90 mesuré du total d'un lot de 0,5 à 1 j" : Math.round(estimate * LOT_BUDGET_PER_DAY) <= LOT_BUDGET_ONE_DAY ? `plancher de ${LOT_BUDGET_ONE_DAY} au-delà d'un jour, l'estimate × ${LOT_BUDGET_PER_DAY} ne le dépasse pas encore` : `${LOT_BUDGET_PER_DAY} par jour, p90 mesuré du total au-delà d'un jour`;
-    if (!stage)
-        return basis;
-    return `${ordinary} dérivés de l'estimate (${basis}), plus ${SPEC_STAGE_ALLOCATION} pour les étapes spec, ${stage === 'screen' ? 'maquette' : 'fiche'} et accept`;
-}
-/** Budget d'un lot, dérivé de son estimate et de sa catégorie : empêche quelques lots d'avaler le budget de la vague au détriment des autres. Un lot à `screen:` vaut le total mesuré d'un lot à écran (L194) ; un lot à `spec: true` y ajoute l'allocation de son étape (L191) ; `escalation` (orchestrate.escalation déclarée) y ajoute la part de l'escalade (L349). */
-export const lotBudget = (estimate, stage, escalation = false) => lotBaseBudget(estimate, stage) + (escalation ? ESCALATION_RESERVE : 0);
-const lotBaseBudget = (estimate, stage) => {
-    const ordinary = estimate <= 0.5 ? LOT_BUDGET_FLOOR : Math.max(LOT_BUDGET_ONE_DAY, Math.round(estimate * LOT_BUDGET_PER_DAY));
-    if (stage === 'screen')
-        return Math.max(SCREEN_LOT_BUDGET, ordinary + SPEC_STAGE_ALLOCATION);
-    return ordinary + (stage === 'spec' ? SPEC_STAGE_ALLOCATION : 0);
-};
+export { lotBudget, lotBudgetBasis, SPEC_STAGE_ALLOCATION } from './lot-budget.js';
+import { lotBudget, lotBudgetBasis } from './lot-budget.js';
 /** Sessions simultanées, toutes vagues confondues (`--max-sessions`, ou CADENCE_MAX_SESSIONS). */
 export const DEFAULT_MAX_SESSIONS = 2;
 /** `1500000`, `1.5M`, `800k`. */
@@ -137,7 +93,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, integrate: [], abandonCommits: false };
+    const a = { lots: [], lotBudgets: [], dryRun: false, waits: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false, add: [], 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];
@@ -191,6 +147,8 @@ export function parseOrchestrateArgs(argv) {
             a.drop.push(lotArg(value(t)));
         else if (t === '--stop-after-current')
             a.stopAfterCurrent = true;
+        else if (t === '--add')
+            a.add.push(lotArg(value(t)));
         else if (t === '--integrate')
             a.integrate.push(lotArg(value(t)));
         else if (t === '--replay')
@@ -230,12 +188,12 @@ export function projectEnv(repo) {
     return { config: readOrchestrateConfig(configPath), loadPlan, configPath };
 }
 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) {
+export function resolveTargets(args, io, refusals) {
     const out = [];
     const seen = new Set();
     for (const l of args.lots) {
         const projectDir = l.project ? resolve(io.cwd, l.project) : io.cwd;
-        const project = l.project ?? basename(io.cwd);
+        const project = projectName(io.cwd, l.project); // L421 : `.:L2` depuis le dépôt et `L2` désignent le même projet que les lots de la vague
         const key = lotKey(project, l.lot);
         if (seen.has(key)) {
             refusals.push(`${key} : lot donné deux fois`);
@@ -259,9 +217,6 @@ function resolveTargets(args, io, refusals) {
     }
     return out;
 }
-async function trackedDirty(repo) {
-    return (await snapshot(repo, { remote: false })).tracked.map((l) => l.slice(3));
-}
 /** `--effort` date de claude 2.1.284 (L137). Une version illisible n'est pas refusée. */
 function olderThanEffort(version) {
     const m = /(\d+)\.(\d+)\.(\d+)/.exec(version);
@@ -275,7 +230,7 @@ function notLoggedIn(deps) {
     return deps.claudeAuth?.()?.loggedIn === false ? "claude n'est pas connecté : lancer `claude` puis /login (état : `claude auth status`)" : null;
 }
 /** 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 = {}) {
+export async function preflight(args, targets, io, deps, launch, opts = {}) {
     const refusals = [];
     if (io.env.CADENCE_ORCHESTRATED)
         refusals.push(`orchestrate ne se lance pas depuis une session orchestrée (vague ${io.env.CADENCE_ORCHESTRATED})`);
@@ -290,8 +245,16 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
     const lots = [];
     const repoChecked = new Set();
     const byProject = new Map();
+    // L421 : les lots déjà portés par la vague qui reçoit l'ajout comptent comme « plus tôt dans la vague » pour les dépendances.
+    for (const l of opts.addTo?.lots ?? [])
+        byProject.set(l.project, [...(byProject.get(l.project) ?? []), l.lot]);
     for (const t of targets) {
         const key = lotKey(t.project, t.lot);
+        const already = opts.addTo?.lots.find((l) => l.project === t.project && l.lot === t.lot);
+        if (already) {
+            refusals.push(`${key} : lot déjà ${already.queued ? "en file d'ajout dans" : 'dans'} la vague ${opts.addTo.wave}`);
+            continue;
+        }
         let env;
         let plan;
         try {
@@ -345,18 +308,7 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             if (repoChecked.has(repo))
                 continue;
             repoChecked.add(repo);
-            const dirty = await trackedDirty(repo);
-            if (dirty.length)
-                refusals.push(`${basename(repo)} : arbre sale, ${dirty.length} fichier(s) suivi(s) modifié(s) : ${dirty.join(', ')}`);
-            const locked = indexLockRefusal(repo, io.now(), deps.gitRunning ?? gitProcessRunning);
-            if (locked)
-                refusals.push(`${basename(repo)} : ${locked}`);
-            const hook = canInstallPrePush(repo);
-            if (hook)
-                refusals.push(`${basename(repo)} : ${hook}`);
-            const busy = activeLock(join(sharedStateDir(repo), REPO_LOCK));
-            if (busy && !opts.resume)
-                refusals.push(`${basename(repo)} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})`);
+            refusals.push(...(await repoRefusals(repo, t, { io, deps, launch }, opts)));
         }
         const node = resolveNode(t.repo, nvmVersionsDir(io.env));
         if (node.kind === 'missing') {
@@ -670,39 +622,6 @@ 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;
-}
 /** L382 : `claude auth status` peut durer jusqu'à 20 s ; en --continue, preflight() le relancerait pour chaque lot candidat de chaque tour. Une seule lecture par lancement (une vague). */
 function onceAuth(deps) {
     const read = deps.claudeAuth;
@@ -711,11 +630,47 @@ function onceAuth(deps) {
     let cached;
     return { ...deps, claudeAuth: () => (cached ??= { value: read() }).value };
 }
+/** `--status` (L395) : le tableau des vagues vivantes et de la vague suivie, une fois ou rafraîchi avec `--watch` jusqu'à ce que plus rien ne tourne. */
+async function statusCommand(args, io, deps, launch) {
+    maxSessions(args, io); // une valeur invalide est refusée ici aussi
+    const view = () => statusView(args, launch, configuredCap(io.env, args.maxSessions), io.now());
+    if (!args.watch) {
+        const { live, table } = view();
+        printStatus(io, live, table); // sans identifiant (pas de tableau) : les vagues vivantes suffisent
+        return 0;
+    }
+    // --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)));
+    const seconds = args.interval ?? DEFAULT_WATCH_INTERVAL;
+    for (;;) {
+        const { live, table, running } = view();
+        io.out(CLEAR_SCREEN);
+        printStatus(io, live, table);
+        if (!running)
+            return 0;
+        io.out('');
+        io.out(`rafraîchi toutes les ${seconds} s — Ctrl-C pour quitter`);
+        await sleep(seconds * 1000);
+    }
+}
+/** Les vagues vivantes, puis (s'il y en a un) le tableau de la vague suivie, séparés d'une ligne vide. */
+function printStatus(io, live, table) {
+    for (const line of live)
+        io.out(line);
+    if (!table)
+        return;
+    if (live.length)
+        io.out('');
+    for (const line of table)
+        io.out(line);
+}
 /** 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) {
     deps = onceAuth(deps);
     const args = parseOrchestrateArgs(argv);
     const launch = io.cwd;
+    if (args.add.length && addNotAlone(args))
+        throw new RafError('--add ne se combine avec aucune autre action (seul --wave désigne la vague qui reçoit les lots)');
     const today = io.env.RAF_TODAY && isDay(io.env.RAF_TODAY) ? io.env.RAF_TODAY : toDay(io.now());
     if ((args.until !== undefined || args.priority !== undefined) && !args.continue)
         throw new RafError('--until et --priority s\'utilisent avec --continue');
@@ -767,50 +722,20 @@ export async function orchestrate(argv, io, deps) {
             io.out(line);
         return 0;
     }
-    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), io.now());
-            for (const line of live)
-                io.out(line);
-            if (!table)
-                return 0; // sans identifiant : les vagues vivantes suffisent
-            if (live.length)
-                io.out('');
-            for (const line of table)
-                io.out(line);
-            return 0;
-        }
-        // --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), io.now());
-            io.out(CLEAR_SCREEN);
-            for (const line of live)
-                io.out(line);
-            if (table) {
-                if (live.length)
-                    io.out('');
-                for (const line of table)
-                    io.out(line);
-            }
-            if (!running)
-                return 0;
-            io.out('');
-            io.out(`rafraîchi toutes les ${args.interval ?? DEFAULT_WATCH_INTERVAL} s — Ctrl-C pour quitter`);
-            await sleep((args.interval ?? DEFAULT_WATCH_INTERVAL) * 1000);
-        }
-    }
+    if (args.status !== undefined)
+        return statusCommand(args, io, deps, launch);
     if (args.removeWorktree)
         return removeWorktree(args, io);
     if (args.resume !== undefined)
         return resume(args, argv, io, deps, launch, today);
+    if (args.add.length)
+        return addOnlyLive(args, io, deps, launch);
     if (args.drop.length || args.stopAfterCurrent)
         return control(args, io);
     if (args.answers.length)
         return answerOnly(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] [--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]');
+        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] | --add projet:lot [--wave vague] | --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);
@@ -1029,6 +954,8 @@ async function continueRounds(first, wave, all, store, io, deps, today, args, la
     const cap = maxSessions(args, io);
     let code = first;
     for (;;) {
+        for (const l of all)
+            exclude.add(lotKey(l.project, l.lot)); // L421 : les lots ajoutés à la main pendant la vague ne sont pas tirés une seconde fois
         const questions = all.filter((l) => l.status === 'question').length;
         const remaining = wave.status === 'suspended-budget' ? 0 : wave.budget - wave.consumed;
         const why = stopReason({ now: io.now(), until: args.untilAt, quotaHit: wave.status === 'suspended-quota', questions, streak: handedBackStreak(all), interrupted: wave.status === 'interrupted' && questions === 0, stopRequested: store.control().stopAfterCurrent, remaining });
@@ -1075,6 +1002,8 @@ function planTrees(ctxs, store, wave, log) {
         if (why)
             log(`orchestrate : ${basename(repo)} : worktrees demandés mais ${why} : lots joués à la suite`);
         for (const c of group) {
+            if (c.tree)
+                continue; // L421 : un lot ajouté en cours de vague replanifie son groupe ; les arbres déjà posés (et leur état actif) ne sont pas refaits
             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);
@@ -1240,6 +1169,22 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     catch {
         // registre illisible : le décompte des créneaux libres reste celui des dépôts
     }
+    const adds = new AddFeed({
+        store, wave, wctx, io, deps, launch, ctxs, all, lots, held, freed, repos, freeRepo, saveWave, checks: LAUNCH_CHECKS,
+        stopCause: () => (wctx.incident ? 'incident' : wctx.quota.hit ? "limite d'usage atteinte" : budget.exhausted ? 'budget de la vague épuisé' : store.control().stopAfterCurrent ? "la vague s'arrête" : null),
+        budgetLeft: () => budget.limit - budget.consumed,
+        planState: (c) => {
+            try {
+                const lot = projectEnv(c.lot.repo).loadPlan().lots().find((l) => l.id === c.lot.lot);
+                return !lot ? 'lot inconnu' : !isOpen(lot.status) ? `le lot est ${lot.status}` : null;
+            }
+            catch (e) {
+                return e.message;
+            }
+        },
+        announce: () => updateWaveReposSafe(home, repos.filter((x) => !freed.has(x)), lanes()),
+        build: (t, known) => buildAdd(t, known, { wave: wave.id, ctxs, wctx, store, io, deps, launch }),
+    });
     // 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();
@@ -1293,7 +1238,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         }, (lots) => lots.every((c) => c.tree), {
             pollMs: deps.slotPollMs ?? ANSWER_POLL_MS,
             // L407 : les réponses déposées par `--answer` pendant la vague sont prises entre deux étapes ; un lot qui n'est plus en question ne rejoue rien.
-            take: (canRun) => {
+            take: async (canRun) => {
                 const taken = [];
                 for (const e of store.answerQueue()) {
                     const c = ctxs.find((x) => lotKey(x.lot.project, x.lot.lot) === e.lot);
@@ -1322,9 +1267,11 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
                         // registre illisible : le décompte reste celui du dernier écrit
                     }
                 }
-                return taken;
+                return [...taken, ...(await adds.take(canRun))];
             },
         });
+        // L421 : un ajout encore en file quand plus rien ne joue ne sera plus lu : écarté et dit.
+        adds.drain('la vague a fini de jouer');
         handBackDroppedQuestions(ctxs); // un lot en question retiré pendant la vague : rendu avant de fixer le statut de la vague
     }
     finally {
@@ -1384,6 +1331,37 @@ function answerLive(args, io, store) {
     }
     return 0;
 }
+const LAUNCH_CHECKS = { resolveTargets, preflight: (targets, run, addTo) => preflight({ dryRun: false }, targets, run.io, run.deps, run.launch, { addTo }) };
+/** `--add` (L421) : la vague vivante de ce dossier reçoit les lots (le travail est dans `ajout.ts`). */
+async function addOnlyLive(args, io, deps, launch) {
+    const store = liveStore('--add', args, io);
+    return typeof store === 'number' ? store : addToLive(args, { io, deps, launch }, store, LAUNCH_CHECKS);
+}
+/**
+ * Le contexte d'un lot ajouté en cours de vague (L421) : le contrôle préalable d'un lot de lancement (les lots de la vague comptent pour les dépendances), le lien du Node,
+ * puis un worktree seulement si tous les lots encore à jouer de son dépôt y sont aussi ; sinon il attend la fin de ceux qui jouent dans l'arbre du dépôt.
+ */
+async function buildAdd(t, known, w) {
+    const pre = await LAUNCH_CHECKS.preflight([t], w, { wave: w.wave, lots: known });
+    const lot = pre.lots[0];
+    if (pre.refusals.length || !lot)
+        return { refusals: pre.refusals };
+    if (lot.node)
+        lot.node.link = (w.deps.linkNode ?? linkNodeBin)(w.store.dir, lot.node.version, lot.node.bin);
+    const ctx = contexts([lot], [projectEnv(lot.repo)], w.wctx)[0];
+    const open = openInRepo(w.ctxs, ctx);
+    planTrees(open.every((o) => o.tree) ? [...open, ctx] : [ctx], w.store, w.wave, w.wctx.log);
+    return { ctx };
+}
+/** Le registre des vagues vivantes : dépôts tenus et créneaux occupés ; illisible, le décompte reste celui du dernier écrit. */
+function updateWaveReposSafe(home, repos, lanes) {
+    try {
+        updateWaveRepos(home, process.pid, repos, lanes);
+    }
+    catch {
+        // registre illisible : le décompte reste celui du dernier écrit
+    }
+}
 /** La vague vivante, pour `--answer` seul (sans --resume) : la même recherche que `--drop`. */
 function answerOnly(args, io) {
     if (args.drop.length || args.stopAfterCurrent || args.budget !== undefined || args.dryRun || args.continue || args.lots.length)

package/dist/orchestrate/cycle.js

@@ -18,8 +18,11 @@ import { citedRefs } from '../link.js';
 import { repoShas, repoWork } from '../repos.js';
 import { isOpen, RafError } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
-import { compareBaseline, failedTests, hasUnnamedFailure } from './baseline.js';
-import { replayRed, TEST_WORKERS_ENV, testWorkersText } from './workers.js';
+import { compareBaseline, failedTests } from './baseline.js';
+import { noteTight, noteUnstable } from './gate-notes.js';
+import { TEST_WORKERS_ENV, testWorkersText } from './workers.js';
+import { baselineCandidates, gateLabel, gateReplayable, gateUnnamed, redAloneGate, redCandidates, replayGate, runGate } from './gate-parts.js';
+import { withPlace } from './gate-place.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
 import { capturesText, gateText, headline, integrationText, localReading, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tiersText, tmpText } from './briefs.js';
 import { SlotAbandoned } from './registry.js';
@@ -38,7 +41,7 @@ import { decisionsText, humanDecisions } from './decisions.js';
 import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
 import { advance, baseMoved, INTEGRATE_WAIT_MS, MAX_REPLAYS, mergeBase, patchId, rebaseOnto, repoBranch, takeRepoWrite } from './integrate.js';
 import { mutexFor } from './mutex.js';
-import { readTier, takeTiers, tierMoved, tierRepos, wipBranch } from './tiers.js';
+import { readTier, stillThird, takeTiers, tierMoved, tierRepos, wipBranch } from './tiers.js';
 import { branchExists, git, gitFailure, integrated, linkIgnored, lotBranch, planFileSet, planSeenFrom, prepareTree, removeTree, trackedDirty } from './worktree.js';
 /** Passes de correction au plus, puis la main est rendue au lead. */
 export const MAX_PASSES = 2;
@@ -196,33 +199,49 @@ const startSha = (c) => lotStartHead(wd(c), lotWork(histPlan(c), wd(c), c.lot.lo
  * pour que les paquets de workspace résolvent dans le worktree (`mirrorNodeModules`). Avec `orchestrate.testReplay`, un rouge nommé y est rejoué seul (L354) avant d'être retenu.
  * Null quand le worktree ne peut être monté : l'appelant garde alors les tests pour rouges.
  */
-async function baselineFailures(c, command) {
+async function baselineFailures(c, test) {
     const l = c.lot;
     const sha = startSha(c);
+    const command = gateLabel(test); // clé de cache ; pour des parties (L512) le libellé « dir : run ; … », stable d'une lecture à l'autre
     if (!sha)
         return null;
     if (l.baseline?.verified && l.baseline.sha === sha && l.baseline.command === command)
         return l.baseline.failures;
-    const dir = mkdtempSync(join(tmpdir(), 'cadence-baseline-'));
-    const links = [];
-    try {
-        git(l.repo, 'worktree', 'add', '--detach', '-f', dir, sha);
-        links.push(...linkIgnored(l.repo, dir));
-        // Le build d'abord, comme dans la porte (L333) : les tests lisent ce qu'il produit (`dist`), le départ sans lui rougirait tout. Un build rouge au départ
-        // ne dit rien des tests : pas de ligne de base, l'appelant garde les tests pour rouges.
-        if (c.config.build && (await sh(c, c.config.build, 30 * 60_000, {}, dir)).code !== 0)
-            return null;
-        const r = await sh(c, command, 30 * 60_000, {}, dir);
+    return atStartSha(c, sha, async (place) => {
+        const r = await runGate(place.run, test);
         // Ligne de base comprise (L354) : un rouge du sha de départ est rejoué seul dans le même worktree avant d'être retenu. Sous charge, un test
-        // qui passe seul au départ rougirait ici et excuserait une vraie régression du lot (« déjà rouge au départ »). Un échec sans nom reste tel quel.
+        // qui passe seul au départ rougirait ici et excuserait une vraie régression du lot (« déjà rouge au départ »). Un échec sans nom reste tel quel ; en parties (L512), partie par partie.
         const found = r.code === 0 ? [] : failedTests(r.output);
-        const named = c.config.testReplay && found.length && !hasUnnamedFailure(r.output) ? found : [];
-        const { red: failures, unstable } = named.length ? await replayAlone(c, c.config.testReplay, named, r.output, dir) : { red: found, unstable: [] };
+        const named = gateReplayable(test, c.config.testReplay) && found.length ? baselineCandidates(r) : [];
+        const { red: failures, unstable } = named.length ? await replayGate(place.run, c.config.testReplay, named, r) : { red: found, unstable: [] };
         if (unstable.length)
             c.wave.log(`${lotKey(l.project, l.lot)} · ligne de base ${sha.slice(0, 7)} : ${unstable.length} test(s) rouge(s) sous charge, vert(s) rejoué(s) seul(s), non retenu(s) comme déjà rouge(s) : ${unstable.join(' ; ')}`);
         l.baseline = { sha, command, failures, verified: true };
         save(c);
         return failures;
+    });
+}
+/** Parmi les tests rouges `names` du lot, ceux rouges SEULS aussi au sha de départ (L510) : la suite entière du départ a pu les voir verts (ordre, charge), ils n'en sont pas moins déjà rouges avant le lot. Vide sans `testReplay`, sans sha de départ, build du départ rouge ou worktree non monté. */
+async function redAtStart(c, names, ran) {
+    const sha = startSha(c);
+    return !sha || !gateReplayable(c.config.test, c.config.testReplay) || !names.length ? [] : (await atStartSha(c, sha, (place) => redAloneGate(place.run, c.config.testReplay, names, ran))) ?? [];
+}
+/** Joue `fn` dans un worktree jetable du sha de départ (ligne de base L213, rouges au départ L510), liens vers les dossiers ignorés posés puis retirés avec lui. Null si le worktree ne se monte pas, si le build du départ est rouge ou si `fn` lève. */
+async function atStartSha(c, sha, fn) {
+    const l = c.lot;
+    const dir = mkdtempSync(join(tmpdir(), 'cadence-baseline-'));
+    const links = [];
+    try {
+        git(l.repo, 'worktree', 'add', '--detach', '-f', dir, sha);
+        links.push(...linkIgnored(l.repo, dir));
+        // Sur l'hôte `gate.host` quand il y en a un (L403) ; le worktree local reste le lieu du rejeu si la connexion tombe.
+        return await withPlace({ config: c.config, repo: l.repo, sha, dir, needClean: false, label: `porte du lot ${l.lot}`, detail: `(ligne de base ${sha.slice(0, 7)})`, local: (cmd) => sh(c, cmd, 30 * 60_000, {}, dir), say: (line) => c.wave.log(`${lotKey(l.project, l.lot)} · ${line}`) }, async (place) => {
+            // Le build d'abord, comme dans la porte (L333) : les tests lisent ce qu'il produit (`dist`), le départ sans lui rougirait tout. Un build rouge au départ
+            // ne dit rien des tests : rien à rendre, l'appelant garde les tests pour rouges.
+            if (c.config.build && (await place.run(c.config.build)).code !== 0)
+                return null;
+            return fn(place);
+        });
     }
     catch {
         return null;
@@ -246,9 +265,10 @@ async function baselineFailures(c, command) {
     }
 }
 /** Des tests rouges comparés à la ligne de base (L213) : tous déjà rouges au départ, ou au moins un nouveau, ou rien de comparable. */
-async function againstBaseline(c, command, output) {
-    const now = failedTests(output);
-    if (!now.length || hasUnnamedFailure(output))
+async function againstBaseline(c, command, ran) {
+    const now = failedTests(ran.output);
+    // Un échec sans test nommé (en chaîne, ou dans une partie rouge, L512) : rien n'est comparable ni excusable, les tests restent rouges.
+    if (!now.length || gateUnnamed(ran))
         return { kind: 'unknown' };
     const base = await baselineFailures(c, command);
     if (!base?.length)
@@ -1065,7 +1085,7 @@ function checkTiers(c, kind, step, before) {
     const w = c.wave;
     const key = lotKey(l.project, l.lot);
     const wip = wipBranch(l.project, l.lot);
-    for (const [repo, b] of before) {
+    for (const [repo, b] of stillThird(before, w.store.lots(), key)) {
         const name = basename(repo);
         let a;
         try {
@@ -1829,7 +1849,7 @@ async function acceptProblems(c, fiche, json, headBefore) {
             l.warnings.push(NO_TEST_ACCEPT);
     }
     else {
-        const ordinary = await sh(c, c.config.test);
+        const ordinary = await runGate((cmd) => sh(c, cmd), c.config.test); // porte en parties (L512) : chaque partie dans son dossier, sortie fusionnée
         if (ordinary.code !== 0)
             out.push(`orchestrate.test échoue (code ${ordinary.code}) avec les tests rouges commités : les fichiers listés dans ${json} ne sont pas exclus de la config du lanceur (partagée avec la CI) tant que vert est false\n${tail(ordinary.output, 15)}`);
     }
@@ -1980,7 +2000,8 @@ async function acceptGreen(c) {
  */
 async function programChecks(c, red, runs) {
     try {
-        await runChecks(c, red, runs);
+        // Sur l'hôte `gate.host` (L403) quand il y en a un : le HEAD du worktree du lot, s'il est propre ; sinon, ou sans hôte, en local.
+        await withPlace({ config: c.config, repo: c.lot.repo, sha: tryGit(wd(c), ['rev-parse', 'HEAD']), dir: wd(c), needClean: true, label: `porte du lot ${c.lot.lot}`, local: (cmd) => sh(c, cmd), say: (line) => c.wave.log(`${lotKey(c.lot.project, c.lot.lot)} · ${line}`) }, (place) => runChecks(c, red, runs, place));
     }
     finally {
         // L395 : la porte se lit dans l'état du lot tant qu'une commande (ou le rejeu qui la suit) tourne, jamais après.
@@ -1988,19 +2009,19 @@ async function programChecks(c, red, runs) {
         save(c);
     }
 }
-async function runChecks(c, red, runs) {
+async function runChecks(c, red, runs, place) {
     const l = c.lot;
     for (const [label, command] of [['build', c.config.build], ['tests', c.config.test]]) {
         if (!command)
             continue;
         l.gate = { label, started: new Date().toISOString() };
         save(c);
-        const r = await sh(c, command);
-        const run = { label, command, code: r.code };
+        const r = await runGate(place.run, command); // porte en parties (L512) : toutes jouées, chacune dans son dossier ; le CheckRun porte le libellé « dir : run ; … »
+        const run = { label, command: gateLabel(command), code: r.code, ...place.stamp() };
         runs.push(run);
         if (r.code === 0)
             continue;
-        const vs = label === 'tests' ? await againstBaseline(c, command, r.output) : { kind: 'unknown' };
+        const vs = label === 'tests' ? await againstBaseline(c, command, r) : { kind: 'unknown' };
         const onlyExisting = (n) => {
             run.dejaRouges = n;
             const note = `${n} test(s) déjà rouge(s) au sha de départ ${(l.baseline?.sha ?? '').slice(0, 7)}, pas un défaut du lot : listés à part, la revue a lieu`;
@@ -2013,11 +2034,11 @@ async function runChecks(c, red, runs) {
         }
         // Un rouge absent de la ligne de base est rejoué SEUL avant d'être compté (L354) : sous charge, des tests qui passent seuls rougissent ensemble.
         // Sans `orchestrate.testReplay` rien n'est rejoué : le rouge est compté tel quel et rien n'est tenu pour instable (L354).
-        const replay = label === 'tests' ? c.config.testReplay : undefined;
-        const named = !replay ? [] : vs.kind === 'new' ? vs.nouveaux : !hasUnnamedFailure(r.output) ? failedTests(r.output) : [];
-        const { red: still, unstable } = named.length ? await replayAlone(c, replay, named, r.output) : { red: [], unstable: [] };
+        const named = label !== 'tests' || !gateReplayable(c.config.test, c.config.testReplay) ? [] : vs.kind === 'new' ? vs.nouveaux : redCandidates(r);
+        const { red: still, unstable, tight } = named.length ? await replayGate(place.run, c.config.testReplay, named, r) : { red: [], unstable: [], tight: [] };
         if (unstable.length) {
-            noteUnstable(c, unstable);
+            noteUnstable(c, unstable.filter((t) => !tight.some((k) => k.test === t)));
+            noteTight(c, tight);
             run.instables = unstable;
         }
         if (unstable.length && !still.length) {
@@ -2027,37 +2048,30 @@ async function runChecks(c, red, runs) {
                 run.code = 0;
             continue;
         }
+        // L510 : un rouge qui reste rouge seul dans le lot mais que la suite entière du départ avait vu vert (ordre, charge) peut être rouge seul au départ aussi : déjà rouge, ni correction ni escalade.
+        const atStart = still.length ? await redAtStart(c, still, r) : [];
+        if (atStart.length) {
+            const note = `${atStart.length} test(s) déjà rouge(s) au sha de départ ${startSha(c)?.slice(0, 7)} (rouge(s) seuls aussi, absent(s) de la ligne de base), pas un défaut du lot : ${atStart.join(' ; ')}`;
+            if (!l.warnings.includes(note))
+                l.warnings.push(note);
+            if (atStart.length === still.length) {
+                run.dejaRouges = atStart.length + (vs.kind === 'new' ? vs.existants : 0);
+                continue;
+            }
+        }
+        const fresh = still.filter((t) => !atStart.includes(t));
         const alone = unstable.length ? `\n(${unstable.length} test(s) rouge(s) sous charge, verts rejoués seuls : instables, à ne pas corriger)` : '';
         if (vs.kind === 'new') {
-            const left = vs.nouveaux.filter((t) => !unstable.includes(t));
-            red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) : ${left.length} test(s) rouge(s) qui ne l'étaient pas au sha de départ :\n${left.map((t) => `- ${t}`).join('\n')}${vs.existants ? `\n(${vs.existants} autre(s) test(s) déjà rouge(s) au sha de départ : à ne pas corriger)` : ''}${alone}` });
+            const left = vs.nouveaux.filter((t) => !unstable.includes(t) && !atStart.includes(t));
+            red.push({ source: 'tests', gravite: 'bloquant', texte: `${run.command} en échec (code ${r.code}) : ${left.length} test(s) rouge(s) qui ne l'étaient pas au sha de départ :\n${left.map((t) => `- ${t}`).join('\n')}${vs.existants ? `\n(${vs.existants} autre(s) test(s) déjà rouge(s) au sha de départ : à ne pas corriger)` : ''}${alone}` });
             return;
         }
         // Des instables sont écartés : la sortie de la suite entière les montre encore en FAIL, le constat ne nomme que ceux qui restent rouges.
-        const shown = unstable.length ? `${still.length} test(s) rouge(s) après rejeu seul :\n${still.map((t) => `- ${t}`).join('\n')}` : r.output.trim().split('\n').slice(-40).join('\n');
-        red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) :\n${shown}${alone}` });
+        const shown = unstable.length || atStart.length ? `${fresh.length} test(s) rouge(s) après rejeu seul :\n${fresh.map((t) => `- ${t}`).join('\n')}` : r.output.trim().split('\n').slice(-40).join('\n');
+        red.push({ source: 'tests', gravite: 'bloquant', texte: `${run.command} en échec (code ${r.code}) :\n${shown}${alone}` });
         return;
     }
 }
-/**
- * Rejoue SEULS (la commande `orchestrate.testReplay` où `{files}` devient les fichiers de ces tests, dans `cwd` : le worktree du lot, ou celui de la ligne de base) les tests rouges d'une suite entière (L354). Le 26-10, vitest à 31 workers par suite sur une machine à 4 sessions rougissait des tests
- * qui passaient seuls : quatre corrections vides (4 à 11 min chacune). Un test vert à un rejeu est `unstable` ; rouge aux rejeux, ou sans fichier désignable (rien à rejouer seul), il reste dans `red`. Le rejeu lui-même est `replayRed` (workers.ts), partagé avec `verify --gate` (L387).
- */
-function replayAlone(c, template, names, output, cwd = wd(c)) {
-    return replayRed((command) => sh(c, command, undefined, undefined, cwd), template, names, output);
-}
-/** Trace des tests instables sous charge (L354) : le lot (`instables`, journal et `cadence perf`), un avertissement du lot (tableau de fin de vague) et une ligne du journal de la vague. */
-function noteUnstable(c, tests) {
-    const l = c.lot;
-    const fresh = tests.filter((t) => !(l.instables ?? []).includes(t));
-    if (!fresh.length)
-        return;
-    l.instables = [...(l.instables ?? []), ...fresh];
-    const text = `${fresh.length} test(s) instable(s) sous charge (rouge(s) dans la suite, vert(s) rejoué(s) seul(s)), pas de passe de correction : ${fresh.join(' ; ')}`;
-    l.warnings.push(text);
-    c.wave.log(`${lotKey(l.project, l.lot)} · ${text}`);
-    save(c);
-}
 /**
  * Contrôles du sommet intégré (L328) : un rouge est relancé une fois avant de rendre le lot. Le 25-10, L326 a été rendu pour un rouge de charge (L325 tournait en même
  * temps) alors que le même sommet rejoué seul était vert. Rouge deux fois = rendu, avec le résultat de la seconde passe ; vert à la relance = une alerte sur le lot et une ligne du journal.
@@ -2269,7 +2283,7 @@ async function work(c, kind) {
     const gateGreen = runs.some((r) => r.label === 'tests' && r.code === 0);
     const baseOnly = declared.length > 0 && !!newFailures && !newFailures.length;
     if (deferred && red.length === 0 && gateGreen && baseOnly)
-        l.warnings.push(`tests annoncés rouges par la session, mais la porte du programme verte (${c.config.test}, code 0) et aucun nouvel échec déclaré (nouveauxEchecs vide) : les échecs sont ceux de la base qu'elle déclare (${declared.length}) ; pas de correction`);
+        l.warnings.push(`tests annoncés rouges par la session, mais la porte du programme verte (${gateLabel(c.config.test ?? '')}, code 0) et aucun nouvel échec déclaré (nouveauxEchecs vide) : les échecs sont ceux de la base qu'elle déclare (${declared.length}) ; pas de correction`);
     else if (deferred && red.length === 0 && !runs.some((r) => r.label === 'tests' && (r.dejaRouges || r.instables?.length)))
         red.push(claimed);
     if (red.length) {