@sylad/cadence 1.34.1 → 1.36.0

package/dist/orchestrate/depot.js

@@ -0,0 +1,33 @@
+import { basename, join } from 'node:path';
+import { sharedStateDir } from '../state.js';
+import { addHint } from './ajout.js';
+import { canInstallPrePush, gitProcessRunning, indexLockRefusal, snapshot } from './guard.js';
+import { activeLock, REPO_LOCK } from './lock.js';
+/** Les fichiers suivis modifiés d'un dépôt. */
+export async function trackedDirty(repo) {
+    return (await snapshot(repo, { remote: false })).tracked.map((l) => l.slice(3));
+}
+/**
+ * Les refus propres à un dépôt avant qu'une vague y joue (arbre sale, `index.lock`, hook de push, orchestration en cours), les mêmes pour un lot lancé, repris ou ajouté.
+ * L421 : le dépôt que tient la vague qui reçoit l'ajout (`addTo`) est le sien : son arbre porte le travail de ses lots et son hook de push est le sien. `resume` : un dépôt tenu n'est pas refusé.
+ */
+export async function repoRefusals(repo, t, run, opts) {
+    const busy = activeLock(join(sharedStateDir(repo), REPO_LOCK));
+    const ours = !!opts.addTo && busy?.wave === opts.addTo.wave;
+    const name = basename(repo);
+    const out = [];
+    if (!ours) {
+        const dirty = await trackedDirty(repo);
+        if (dirty.length)
+            out.push(`${name} : arbre sale, ${dirty.length} fichier(s) suivi(s) modifié(s) : ${dirty.join(', ')}`);
+        const locked = indexLockRefusal(repo, run.io.now(), run.deps.gitRunning ?? gitProcessRunning);
+        if (locked)
+            out.push(`${name} : ${locked}`);
+        const hook = canInstallPrePush(repo);
+        if (hook)
+            out.push(`${name} : ${hook}`);
+    }
+    if (busy && !opts.resume && !ours)
+        out.push(`${name} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})${addHint(t, busy.wave, run.launch)}`);
+    return out;
+}

package/dist/orchestrate/gate-notes.js

@@ -0,0 +1,27 @@
+// Ce que la porte de tests dit d'un rouge qu'elle n'envoie pas en correction : instable sous charge (L354), délai trop juste (L510).
+import { lotKey } from './state.js';
+/** 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. */
+export 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}`);
+    c.wave.store.writeLot(l);
+}
+const seconds = (ms) => `${Math.round(ms / 100) / 10} s`.replace(/\.0 s$/, ' s');
+/** Trace des tests au « délai trop juste » (L510) : rouges dans la suite pour avoir expiré, verts seuls mais près de leur délai. Le lot (`delaisJustes`) et un avertissement qui nomme chaque test, sa durée seul et son délai ; jamais de passe de correction. */
+export function noteTight(c, tests) {
+    const l = c.lot;
+    const fresh = tests.filter((t) => !(l.delaisJustes ?? []).some((k) => k.test === t.test));
+    if (!fresh.length)
+        return;
+    l.delaisJustes = [...(l.delaisJustes ?? []), ...fresh];
+    const text = `délai trop juste, pas un bug (pas de passe de correction) : ${fresh.map((t) => `${t.test} (${seconds(t.ms)} seul pour ${seconds(t.limit)} de délai)`).join(' ; ')} — relever le délai du test`;
+    l.warnings.push(text);
+    c.wave.log(`${lotKey(l.project, l.lot)} · ${text}`);
+    c.wave.store.writeLot(l);
+}

package/dist/orchestrate/gate-parts.js

@@ -0,0 +1,135 @@
+// Porte de tests déclarée en parties (L512) : `orchestrate.test: [{ dir, run, replay? }]`. Le 31-10, la porte composée de warhammer (`backend && frontend`) refusait `testReplay`,
+// donc ni le rejeu seul (L354) ni le délai trop juste et le rouge au départ (L510) : quatre corrections et une escalade pour des faux rouges (L61). Décision de Sylvain du 01-11 :
+// cadence lance chaque partie séparément, dans son dossier, et attribue chaque rouge à la partie qui l'a imprimé ; une partie sans `replay` garde ses rouges comptés ; la forme chaîne reste telle quelle.
+// Ce module ne change que le lieu du lancement et l'attribution des noms : les règles de verdict (deux rejeux, fichier vu dans la sortie, délai trop juste) restent celles de workers.ts.
+import { isAbsolute, posix } from 'node:path';
+import { failedTests, hasUnnamedFailure } from './baseline.js';
+import { isComposedGate, redAlone, replayRed, shellArg } from './workers.js';
+export const isParts = (t) => Array.isArray(t);
+const PART_KEYS = ['dir', 'run', 'replay'];
+/** Le dossier d'une partie, normalisé (`./front/` → `front`) ; null s'il est vide, absolu ou contient « .. ». */
+function partDir(v) {
+    if (typeof v !== 'string' || !v.trim() || isAbsolute(v.trim()) || v.split(/[\\/]/).includes('..'))
+        return null;
+    const n = posix.normalize(v.trim().replaceAll('\\', '/')).replace(/\/+$/, '');
+    return n || null;
+}
+/** Lecture de `orchestrate.test` (contrat A1) : la chaîne telle quelle, ou la liste des parties validées ; `bad` fabrique l'erreur de cadence.yaml. */
+export function readGateTest(raw, bad) {
+    if (typeof raw === 'string') {
+        if (!raw.trim())
+            throw bad('test : commande non vide attendue');
+        return raw.trim();
+    }
+    if (!Array.isArray(raw))
+        throw bad('test : commande non vide attendue (chaîne ou liste de parties { dir, run, replay? })');
+    if (!raw.length)
+        throw bad('test : au moins une partie attendue (dir, run, replay facultatif)');
+    const seen = new Set();
+    return raw.map((item) => {
+        if (typeof item !== 'object' || item === null || Array.isArray(item))
+            throw bad('test : chaque partie doit être un objet { dir, run, replay? }');
+        const o = item;
+        for (const k of Object.keys(o))
+            if (!PART_KEYS.includes(k))
+                throw bad(`test : clé « ${k} » inconnue dans une partie (attendu : dir, run, replay)`);
+        const dir = partDir(o.dir);
+        if (dir === null || seen.has(dir))
+            throw bad(`test : dir invalide « ${typeof o.dir === 'string' ? o.dir : JSON.stringify(o.dir)} » (chemin relatif, sans « .. », unique)`);
+        seen.add(dir);
+        if (typeof o.run !== 'string' || !o.run.trim())
+            throw bad(`test : la commande run de la partie « ${dir} » ne peut pas être vide (chaîne non vide attendue)`);
+        const part = { dir, run: o.run.trim() };
+        if (o.replay != null) {
+            if (typeof o.replay !== 'string' || !o.replay.trim() || !o.replay.includes('{files}'))
+                throw bad(`test : le replay de la partie « ${dir} » doit être une commande non vide contenant {files} (remplacé par les fichiers des tests rouges)`);
+            part.replay = o.replay.trim();
+        }
+        return part;
+    });
+}
+/** `orchestrate.testReplay` face à `orchestrate.test` (L354, L512) : `{files}` exigé ; refusé avec une liste de parties (le rejeu se déclare par partie) et sur une porte composée en chaîne. */
+export function checkTestReplay(test, replay, bad) {
+    if (!replay)
+        return;
+    if (!replay.includes('{files}'))
+        throw bad('testReplay : la commande doit contenir {files} (remplacé par les fichiers des tests rouges)');
+    if (isParts(test))
+        throw bad('testReplay : refusé quand orchestrate.test est une liste de parties : déclarer replay dans chaque partie');
+    if (test && isComposedGate(test))
+        throw bad('testReplay : refusé quand orchestrate.test est une porte composée (&&, ||, sous-shell) : le rejeu seul ne vaut que pour un lanceur unique');
+}
+/** Le libellé d'une porte (R9 b) : la chaîne telle quelle ; les parties « dir : run » jointes par « ; ». Sert aux messages, aux briefs, au CheckRun et à la clé de cache de la ligne de base. */
+export const gateLabel = (t) => (isParts(t) ? t.map((p) => `${p.dir} : ${p.run}`).join(' ; ') : t);
+/** La porte a de quoi rejouer un rouge seul : `testReplay` pour une chaîne, au moins une partie avec `replay` pour une liste. */
+export const gateReplayable = (t, replay) => (isParts(t) ? t.some((p) => !!p.replay) : !!replay);
+/** La commande d'une partie jouée depuis la racine du lieu (worktree local ou de l'hôte) : un dossier introuvable fait sortir le shell en échec en le nommant (« can't cd to dir »), sans test nommé. */
+export const partCommand = (p, command = p.run) => `cd ${shellArg(p.dir)} && ${command}`;
+/** Joue la porte : la chaîne en un bloc ; les parties toutes, chacune dans son dossier (R8 : une partie rouge ne coupe pas les suivantes), code de la première non nulle, sorties fusionnées sous un en-tête « [dir] ». */
+export async function runGate(run, test) {
+    if (!isParts(test))
+        return run(test);
+    const parts = [];
+    for (const part of test) {
+        const r = await run(partCommand(part));
+        parts.push({ part, code: r.code, output: r.output });
+    }
+    return { code: parts.find((p) => p.code !== 0)?.code ?? 0, output: parts.map((p) => `[${p.part.dir}]\n${p.output}`).join('\n'), parts };
+}
+/**
+ * La porte a échoué pour autre chose qu'un test nommé : forme chaîne, `hasUnnamedFailure` (L354) ; parties, une partie rouge qui ne nomme aucun test (erreur de compilation, « can't cd to », lanceur
+ * planté) ou dont la sortie porte un échec sans nom (seuil de couverture, fichier qui ne se charge pas). Rien n'est alors rejoué ni excusé : la porte reste rouge, quoi que le rejeu des autres parties dise (revue du 01-11, bloquant : jamais de faux vert).
+ */
+export function gateUnnamed(ran) {
+    if (!ran.parts)
+        return hasUnnamedFailure(ran.output);
+    return ran.parts.some((p) => p.code !== 0 && (hasUnnamedFailure(p.output) || failedTests(p.output).length === 0));
+}
+/** Les rouges nommés de la porte du LOT, candidats au rejeu seul : vide dès que la porte a un échec sans test nommé (`gateUnnamed`), en chaîne comme en parties — rien n'excuse alors le lot. */
+export function redCandidates(ran) {
+    return gateUnnamed(ran) ? [] : failedTests(ran.output);
+}
+/**
+ * Les rouges nommés de la LIGNE DE BASE, candidats au rejeu seul : là, rejouer retire des excuses (un rouge de charge du départ ne doit pas excuser une vraie régression du lot), donc chaque partie est jugée pour elle-même :
+ * une partie rouge sans test nommé au départ ne retient que ses propres rouges (aucun), les noms des autres parties sont rejoués par leur partie (`perPart`). Forme chaîne : comme avant (tout ou rien).
+ */
+export function baselineCandidates(ran) {
+    return ran.parts ? failedTests(ran.output) : redCandidates(ran);
+}
+/** Par partie rouge, les noms de `names` qu'elle a imprimés et le verdict de `judge` sur eux seuls ; null (rien de prouvable) pour une partie sans `replay` ou à échec sans nom. */
+async function perPart(parts, names, judge) {
+    const out = [];
+    for (const p of parts) {
+        if (p.code === 0)
+            continue;
+        const printed = new Set(failedTests(p.output));
+        const own = names.filter((n) => printed.has(n));
+        if (own.length)
+            out.push({ own, v: p.part.replay && !hasUnnamedFailure(p.output) ? await judge(p, own) : null });
+    }
+    return out;
+}
+/** Un nom est excusé seulement si CHAQUE partie qui l'a imprimé rouge l'excuse (règle du lead du 01-11 : jamais de faux vert) ; un nom qu'aucune partie rouge n'a imprimé ne l'est pas. */
+const everyPart = (judged, names, ok) => [...new Set(names)].filter((n) => {
+    const mine = judged.filter((j) => j.own.includes(n));
+    return mine.length > 0 && mine.every((j) => j.v !== null && ok(j.v, n));
+});
+/**
+ * Rejeu seul des rouges `names` (L354, L510) : forme chaîne, `replayRed` tel quel ; parties, chaque partie rouge rejoue dans son dossier, par son `replay`, les seuls noms qu'elle a imprimés (R4),
+ * et un nom imprimé par plusieurs parties n'est instable que si toutes le voient vert (R5) ; le délai trop juste d'un instable est celui lu dans l'une d'elles.
+ */
+export async function replayGate(run, replay, names, ran) {
+    if (!ran.parts)
+        return replayRed(run, replay, names, ran.output);
+    const judged = await perPart(ran.parts, names, (p, own) => replayRed((c) => run(partCommand(p.part, c)), p.part.replay, own, p.output));
+    const unstable = everyPart(judged, names, (v, n) => v.unstable.includes(n));
+    const tight = unstable.flatMap((n) => judged.map((j) => j.v?.tight.find((k) => k.test === n)).filter((k) => !!k).slice(0, 1));
+    return { red: [...new Set(names)].filter((n) => !unstable.includes(n)), unstable, tight };
+}
+/** Rouges seuls au sha de départ (L510, R6) : forme chaîne, `redAlone` tel quel ; parties, un nom n'est « déjà rouge » que si chaque partie qui l'a imprimé rouge dans le lot le nomme encore en échec à ses rejeux au départ. */
+export async function redAloneGate(run, replay, names, ran) {
+    if (!ran.parts)
+        return redAlone(run, replay, names, ran.output);
+    const judged = await perPart(ran.parts, names, (p, own) => redAlone((c) => run(partCommand(p.part, c)), p.part.replay, own, p.output));
+    return everyPart(judged, names, (v, n) => v.includes(n));
+}

package/dist/orchestrate/gate-place.js

@@ -0,0 +1,66 @@
+// Où une commande de la porte d'un lot tourne (L403) : sur l'hôte `orchestrate.gate.host` quand il répond et que l'hôte verrait ce qui est testé, sinon en local.
+// Les décisions de verdict (rouge, ligne de base, rejeu seul) restent celles du cycle : ce module ne change que le lieu et ne rend jamais un 255 comme un résultat.
+import { GATE_TIMEOUT_MS, isSha, openRemoteGate } from '../remote-gate.js';
+import { configuredCap } from './command.js';
+import { testWorkersFrom } from './workers.js';
+import { trackedDirty, untrackedFiles } from './worktree.js';
+const localPlace = (local) => ({ run: local, stamp: () => ({}), close: () => { } });
+/**
+ * Ouvre le lieu de la porte. Sans `gate.host`, ou quand l'hôte ne peut pas porter la porte (arbre non validé R7, hôte injoignable, push ou cache impossible R4/R5), la porte est locale et la ligne dit pourquoi.
+ * Sur l'hôte, un code 255 de ssh (connexion perdue) n'est jamais un résultat : la commande est rejouée en local, la ligne le dit, et le lieu reste local pour les commandes suivantes (R6).
+ */
+async function openPlace(o) {
+    const host = o.config.gate?.host;
+    // Aucune commande de porte déclarée : rien à jouer, ni sonde ni worktree sur l'hôte.
+    if (!host || !o.sha || !(o.config.build || o.config.test))
+        return localPlace(o.local);
+    if (o.needClean) {
+        const dirty = [...trackedDirty(o.dir), ...untrackedFiles(o.dir)];
+        if (dirty.length) {
+            o.say(`${o.label} : worktree non validé, jouée en local (l'hôte ne verrait pas les modifications)`);
+            return localPlace(o.local);
+        }
+    }
+    if (!isSha(o.sha)) {
+        o.say(`${o.label} : sha invalide pour la porte déportée (hexadécimal attendu), jouée en local`);
+        return localPlace(o.local);
+    }
+    const env = o.env ?? process.env;
+    const opened = await openRemoteGate({ host, install: o.config.gate?.install, repo: o.repo, sha: o.sha, depsFrom: o.repo, worktreeDeps: o.config.worktreeDeps, env, timeoutMs: GATE_TIMEOUT_MS, workers: (cores) => testWorkersFrom(env, cores, configuredCap(env)) });
+    if (!opened.ok) {
+        o.say(opened.stage === 'host' ? `${o.label} : porte déportée indisponible sur ${host} (${opened.cause}) — jouée en local` : `${o.label} : cache de dépendances impossible sur ${host} (${opened.cause}) — jouée en local`);
+        return localPlace(o.local);
+    }
+    const gate = opened.gate;
+    let lost = false;
+    const where = `hôte ${host}, sha ${o.sha.slice(0, 7)}, ${gate.cache}`;
+    o.say(`${o.label} : porte jouée sur l'hôte ${host} (sha ${o.sha.slice(0, 7)}, ${gate.cache})`);
+    return {
+        run: async (command) => {
+            if (lost)
+                return o.local(command);
+            const r = await gate.run(command, GATE_TIMEOUT_MS);
+            if (!r.lost)
+                return r;
+            lost = true;
+            o.say(`${o.label} : connexion perdue avec ${host} pendant la porte — rejouée en local${o.detail ? ` ${o.detail}` : ''}`);
+            return o.local(command);
+        },
+        stamp: () => ({ lieu: lost ? `local (connexion perdue avec ${host})` : where }),
+        close: () => {
+            const orphan = gate.close();
+            if (orphan)
+                o.say(`${o.label} : nettoyage de l'hôte ${host} en échec (${orphan}) — le worktree orphelin y sera retiré au prochain appel`);
+        },
+    };
+}
+/** Joue `fn` dans le lieu de la porte et retire le worktree de l'hôte quoi qu'il arrive (R10). */
+export async function withPlace(o, fn) {
+    const place = await openPlace(o);
+    try {
+        return await fn(place);
+    }
+    finally {
+        place.close();
+    }
+}

package/dist/orchestrate/lot-budget.js

@@ -0,0 +1,50 @@
+import { ESCALATION_RESERVE } from './cycle.js';
+/**
+ * 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);
+};

package/dist/orchestrate/pool.js

@@ -93,7 +93,7 @@ export async function runPool(ctxs, slots = SLOTS, known = [], onSettled = () =>
     };
     for (;;) {
         admitted.length = 0;
-        for (const c of answers?.take(canRun) ?? []) {
+        for (const c of (await answers?.take(canRun)) ?? []) {
             live.add(c);
             pending.push([c]);
         }

package/dist/orchestrate/retrait.js

@@ -0,0 +1,37 @@
+import { existsSync } from 'node:fs';
+import { basename, resolve } from 'node:path';
+import { gitRoot } from '../git.js';
+import { keptTrees, removeTree } from './worktree.js';
+/**
+ * `--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.
+ */
+export 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;
+}

package/dist/orchestrate/snapshot.js

@@ -130,6 +130,19 @@ export function waveReadsAnswerQueue(waveDir) {
         return false;
     }
 }
+/**
+ * La vague lit-elle la file d'ajouts `adds.log` (L421, `--add`) ? Une vague lancée avant L421 ne la lirait jamais : le lot y dormirait. Sans instantané : on suppose que oui.
+ */
+export function waveReadsAdds(waveDir) {
+    if (!snapshotExists(waveDir))
+        return true;
+    try {
+        return readFileSync(join(toolDirOf(waveDir), 'dist', 'orchestrate', 'state.js'), 'utf8').includes('adds.log');
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * L'instantané de la vague connaît-il `--budget projet:lot=+N` (L223) ? Un instantané plus ancien relit l'argument avec son `parseBudget` et le refuse
  * comme budget invalide. Sans instantané : rien à relire, on suppose que oui.

package/dist/orchestrate/state.js

@@ -9,7 +9,7 @@ import { pidAlive } from '../state.js';
 export const LOCAL_PRECHECK_UNREADABLE = 'contrôle préalable : rapport du modèle local illisible';
 export const PRECHECK_UNREADABLE = 'contrôle préalable illisible, implémentation lancée';
 export function newLot(o) {
-    return { ...o, status: 'queued', pass: 0, next: null, steps: [], constats: [], verdict: null, uxVerdict: null, questions: [], choix: [], answers: [], proposals: [], warnings: [], instables: undefined, outcome: null };
+    return { ...o, status: 'queued', pass: 0, next: null, steps: [], constats: [], verdict: null, uxVerdict: null, questions: [], choix: [], answers: [], proposals: [], warnings: [], instables: undefined, delaisJustes: undefined, outcome: null };
 }
 /** Un lot fini ne travaille plus dans son dépôt : prêt, rendu ou échoué. */
 export const lotFinished = (l) => l.status === 'ready' || l.status === 'handed-back' || l.status === 'failed';
@@ -168,11 +168,11 @@ export class RunStore {
         writeFileSync(f, kept.map((l) => `${l}\n`).join(''));
     }
     /**
-     * File des réponses du lead à une vague vivante (L407) : `answers.log`, en ajout seul, une ligne JSON par réponse déposée (`{id, lot, text}`) ou par réponse prise (`{taken: id}`).
-     * La vague la relit entre deux étapes ; une réponse prise ou écartée n'y figure plus. Une ligne illisible est ignorée. Pas de `.json` : `lots()` le prendrait pour un lot.
+     * Lit une file en ajout seul de la vague (`answers.log`, `adds.log`) : une ligne JSON par demande (`{id, …}`) ou par demande prise (`{taken: id}`) ; une demande prise n'y figure plus.
+     * Une ligne vide ou illisible est ignorée, et `parse` écarte une ligne dont la forme n'est pas celle de la file. Pas de `.json` : `lots()` le prendrait pour un lot.
      */
-    answerQueue() {
-        const f = join(this.dir, 'answers.log');
+    queue(file, parse) {
+        const f = join(this.dir, file);
         if (!existsSync(f))
             return [];
         const entries = [];
@@ -182,8 +182,11 @@ export class RunStore {
                 const o = JSON.parse(line);
                 if (typeof o.taken === 'number')
                     taken.add(o.taken);
-                else if (typeof o.id === 'number' && typeof o.lot === 'string' && typeof o.text === 'string')
-                    entries.push({ id: o.id, lot: o.lot, text: o.text });
+                else if (typeof o.id === 'number') {
+                    const rest = parse(o);
+                    if (rest)
+                        entries.push({ id: o.id, ...rest });
+                }
             }
             catch {
                 // ligne vide ou illisible : ignorée
@@ -191,11 +194,22 @@ export class RunStore {
         }
         return entries.filter((e) => !taken.has(e.id));
     }
+    /** Numéro suivant d'une file : un de plus que le plus grand déjà écrit. */
+    nextId(file) {
+        const f = join(this.dir, file);
+        const last = existsSync(f) ? [...readFileSync(f, 'utf8').matchAll(/^\{"id":(\d+),/gm)].map((m) => Number(m[1])) : [];
+        return Math.max(0, ...last) + 1;
+    }
+    /**
+     * File des réponses du lead à une vague vivante (L407) : `answers.log`, une ligne JSON par réponse déposée (`{id, lot, text}`).
+     * La vague la relit entre deux étapes.
+     */
+    answerQueue() {
+        return this.queue('answers.log', (o) => (typeof o.lot === 'string' && typeof o.text === 'string' ? { lot: o.lot, text: o.text } : null));
+    }
     /** Dépose une réponse dans la file ; rend son numéro. */
     requestAnswer(lot, text) {
-        const f = join(this.dir, 'answers.log');
-        const last = existsSync(f) ? [...readFileSync(f, 'utf8').matchAll(/^\{"id":(\d+),/gm)].map((m) => Number(m[1])) : [];
-        const id = Math.max(0, ...last) + 1;
+        const id = this.nextId('answers.log');
         appendFileSync(join(this.dir, 'answers.log'), `${JSON.stringify({ id, lot, text })}\n`);
         return id;
     }
@@ -203,6 +217,30 @@ export class RunStore {
     markAnswerTaken(id) {
         appendFileSync(join(this.dir, 'answers.log'), `${JSON.stringify({ taken: id })}\n`);
     }
+    /**
+     * File des lots à ajouter à une vague vivante (L421, `--add`) : `adds.log`, une ligne JSON par demande (`{id, lot, project?, model?}`), le projet étant écrit comme le lead l'a donné
+     * (nom de dossier depuis le dossier de lancement). La vague la relit entre deux étapes, comme celle des réponses.
+     */
+    addQueue() {
+        return this.queue('adds.log', (o) => (typeof o.lot === 'string' ? { lot: o.lot, ...(typeof o.project === 'string' ? { project: o.project } : {}), ...(typeof o.model === 'string' ? { model: o.model } : {}) } : null));
+    }
+    /** Dépose un lot à ajouter ; rend son numéro. */
+    requestAdd(t) {
+        const id = this.nextId('adds.log');
+        this.appendAddLine({ id, lot: t.lot, ...(t.project ? { project: t.project } : {}), ...(t.model ? { model: t.model } : {}) });
+        return id;
+    }
+    /** La demande `id` est prise (lot ajouté ou écarté) : elle ne sera plus relue. */
+    markAddTaken(id) {
+        this.appendAddLine({ taken: id });
+    }
+    /** Ajoute une ligne à `adds.log`, après un saut de ligne si une écriture interrompue a laissé la dernière sans le sien (sinon les deux lignes se collent et sont perdues). */
+    appendAddLine(o) {
+        const f = join(this.dir, 'adds.log');
+        const before = existsSync(f) ? readFileSync(f, 'utf8') : '';
+        const cut = before !== '' && !before.endsWith('\n');
+        appendFileSync(f, `${cut ? '\n' : ''}${JSON.stringify(o)}\n`);
+    }
     journal(line) {
         appendFileSync(join(this.dir, 'journal.log'), `${new Date().toISOString()} ${line}\n`);
     }

package/dist/orchestrate/tiers.js

@@ -1,6 +1,7 @@
 import { lstatSync, readdirSync, realpathSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { git, gitFailure, tryGit } from './worktree.js';
+import { lotKey, lotRepoPaths } from './state.js';
 /** Voie prévue pour un travail qui doit toucher un dépôt tiers (L456) : une branche à part, jamais la branche principale. */
 export const wipBranch = (project, lot) => `wip/${project}-${lot}`;
 const real = (p) => {
@@ -119,3 +120,11 @@ export function tierMoved(repo, before, after, lots) {
     }
     return null;
 }
+/**
+ * Les dépôts tiers de la session qui le sont encore à sa fin (L421) : un lot ajouté (`--add`) pendant la session a pu prendre l'un d'eux, dont la branche principale bouge alors
+ * légitimement, comme celle des autres lots de la vague (R14).
+ */
+export function stillThird(before, wave, mine) {
+    const ofOthers = new Set(wave.filter((x) => lotKey(x.project, x.lot) !== mine).flatMap(lotRepoPaths));
+    return [...before].filter(([repo]) => !ofOthers.has(repo));
+}

package/dist/orchestrate/workers.js

@@ -1,5 +1,5 @@
 // Part de la machine de chaque session (L350) : le 26-10, 32 cœurs et 4 sessions, vitest à 31 workers par suite, et des tests qui passaient seuls rougissaient ensemble.
-import { jestTestFiles, stripAnsi } from './baseline.js';
+import { failedTests, jestTestFiles, stripAnsi, testDurationMs, timeoutLimits } from './baseline.js';
 /** Variable posée dans l'environnement des sessions et de la porte : le nombre de workers que leurs lanceurs de tests ont le droit d'ouvrir. */
 export const TEST_WORKERS_ENV = 'CADENCE_TEST_WORKERS';
 /** Cœurs ÷ plafond de sessions, arrondi vers le bas, jamais moins de 1 (cœurs inconnus ou plafond absurde compris). */
@@ -73,15 +73,35 @@ export function replayRanFile(output, file) {
 const NO_TEST_RAN = /^\W*(?:no test files? found, exiting with code|no tests? found, exiting with code|no tests ran in)\b/im;
 /** Rejeux d'un test rouge de la porte, seul (L354) : rouge aux deux, il est compté. */
 const REPLAYS = 2;
+/**
+ * Parmi `names`, les tests rouges SEULS (L510) : `run` rejoue la commande `template` avec leurs fichiers, au plus `REPLAYS` fois ; un test reste s'il est nommé en échec par chaque rejeu, qui sort en échec. C'est une preuve positive : un rejeu qui échoue pour une autre raison
+ * (build cassé, fichier introuvable) ne nomme pas le test et ne l'excuse pas. Un test sans fichier désignable n'est pas rejoué, donc n'est jamais retenu. Sert à savoir si un rouge du lot était déjà rouge au sha de départ.
+ */
+export async function redAlone(run, template, names, output) {
+    const jest = jestTestFiles(output);
+    const fileOf = (n) => replayFile(n) ?? jest.get(n) ?? null;
+    let still = [...new Set(names)].filter((n) => fileOf(n));
+    for (let i = 0; i < REPLAYS && still.length; i++) {
+        const files = [...new Set(still.map((n) => fileOf(n)))];
+        const r = await run(template.replaceAll('{files}', () => files.map(shellArg).join(' ')));
+        const failing = r.code === 0 ? new Set() : new Set(failedTests(r.output));
+        still = still.filter((n) => failing.has(n));
+    }
+    return still;
+}
+/** Un test vert seul mais à au moins cette part de son délai est un « délai trop juste » (L510) : 25 s pour 30 s le 31-10 (warhammer L61). */
+const TIGHT_RATIO = 0.8;
 /**
  * Rejoue SEULS les tests `names` rouges dans `output` (L354, L387) : `run` exécute la commande `template` où `{files}` devient les fichiers de ces tests, dans le dossier de l'appelant (worktree du lot, de la ligne de base ou de `verify --gate`).
- * Un test vert à un rejeu est `unstable` ; rouge aux `REPLAYS` rejeux, ou sans fichier désignable (rien à rejouer seul), il reste dans `red`.
+ * Un test vert à un rejeu est `unstable` (et `tight` quand sa durée seul est près de son délai, L510) ; rouge aux `REPLAYS` rejeux, ou sans fichier désignable (rien à rejouer seul), il reste dans `red`.
  */
 export async function replayRed(run, template, names, output) {
     const jest = jestTestFiles(output);
     const fileOf = (n) => replayFile(n) ?? jest.get(n) ?? null;
-    let red = names;
+    let red = [...new Set(names)];
     const unstable = [];
+    const tight = [];
+    const limits = timeoutLimits(output);
     for (let i = 0; i < REPLAYS; i++) {
         const replayable = red.filter((n) => fileOf(n));
         const files = [...new Set(replayable.map((n) => fileOf(n)))];
@@ -92,7 +112,14 @@ export async function replayRed(run, template, names, output) {
         const ran = r.code === 0 && !NO_TEST_RAN.test(r.output);
         const passed = ran ? replayable.filter((n) => replayRanFile(r.output, fileOf(n))) : [];
         unstable.push(...passed);
+        // L510 : vert seul mais expiré dans la suite, et la durée du rejeu est près du délai : le test est trop juste, pas bugué. Sans délai lu dans la suite ou sans durée lisible au rejeu, rien n'est dit.
+        for (const n of passed) {
+            const limit = limits.get(n);
+            const ms = limit ? testDurationMs(r.output, n, fileOf(n)) : null;
+            if (limit && ms !== null && ms >= TIGHT_RATIO * limit)
+                tight.push({ test: n, ms, limit });
+        }
         red = red.filter((n) => !passed.includes(n));
     }
-    return { red, unstable };
+    return { red, unstable, tight };
 }

package/dist/plan-commit.js

@@ -21,6 +21,8 @@ export const PLAN_ACTIONS = {
     /** `raf archive` (L396) : le nombre de lots déplacés dans l'archive. */
     archived: (n) => `${n} lot(s) archivé(s)`,
     reviewRecorded: 'revue de code enregistrée',
+    /** `raf ux <lot>` ne commite pas : l'action de la commande de commit qu'il propose (L509). */
+    uxRecorded: 'verdict UX enregistré',
     reviewNoted: 'revue de code notée',
     /** `cadence deliver` pendant une vague (L388) : le lot de l'article ouvert, ou ses titres ajoutés en note. */
     articleOpened: 'article à rafraîchir ouvert',
@@ -51,12 +53,12 @@ export function planCommitProblem(template) {
 }
 /**
  * Le message d'un commit de plan : le gabarit du projet (`plan.commit`), à défaut celui d'avant L343.
- * Hors vague, un groupe entre parenthèses qui porte `{vague}` disparaît avec elle, au lieu de laisser « (orchestrate ) ».
+ * Hors vague, un groupe entre parenthèses ou crochets qui porte `{vague}` disparaît avec elle, au lieu de laisser « (orchestrate ) » ou « [] ».
  */
 export function planCommitMessage(template, v) {
     let t = template ?? (v.wave === undefined ? PLAN_COMMIT_PLAIN : PLAN_COMMIT_WAVE);
     if (v.wave === undefined)
-        t = t.replace(/\s*\([^()]*\{vague\}[^()]*\)/g, '').replaceAll('{vague}', '');
+        t = t.replace(/\s*(?:\([^()]*\{vague\}[^()]*\)|\[[^\[\]]*\{vague\}[^\[\]]*\])/g, '').replaceAll('{vague}', '');
     return t.replaceAll('{lot}', () => v.lot).replaceAll('{vague}', () => v.wave ?? '').replaceAll('{action}', () => v.action);
 }
 /** Le hook commit-msg que git lancerait dans `root` (core.hooksPath compris, husky aussi) ; null s'il n'y en a pas d'exécutable. */

package/dist/plan-uncommitted.js

@@ -0,0 +1,26 @@
+import { relative } from 'node:path';
+import { dirtyPaths, gitRoot } from './git.js';
+import { PLAN_ACTIONS, planCommitMessage } from './plan-commit.js';
+/**
+ * `raf done`, `raf ux <lot>` et `raf review <lot>` (L509) écrivent le plan et ne le commitent jamais (voulu : raf n'a pas de réglage qui commite, docs/raf.md) : la commande de commit du plan et des fichiers
+ * que `plan.onWrite` produit, au gabarit `plan.commit` du projet (L371). Null hors d'un dépôt git ou quand rien n'est à commiter.
+ */
+function uncommittedPlanCommand(plan, root, lot, template, action = PLAN_ACTIONS.done) {
+    const repo = gitRoot(root);
+    if (!repo)
+        return null;
+    // Seuls les chemins que git voit modifiés : `git add` d'un chemin absent ou ignoré est fatal.
+    const paths = dirtyPaths(repo, [relative(repo, plan.path), ...plan.files, ...plan.produced, ...plan.archiveFiles().map((f) => relative(repo, f))]);
+    if (paths.length === 0)
+        return null;
+    const quote = (t) => (/^[\w./-]+$/.test(t) ? t : `'${t.replaceAll("'", "'\\''")}'`);
+    const message = planCommitMessage(template, { lot, action });
+    const list = paths.map(quote).join(' ');
+    return `plan non commité : raf ne commite jamais (voulu, ce n'est pas un réglage), à commiter :\n  git add -- ${list} && git commit -m ${quote(message)} -- ${list}`;
+}
+/** Dit sur `out` la commande de commit du plan, quand il y a quelque chose à commiter (rien sinon). */
+export function printUncommittedPlan(out, ...args) {
+    const command = uncommittedPlanCommand(...args);
+    if (command)
+        out(command);
+}