@sylad/cadence 1.34.1 → 1.35.0

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';
@@ -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)
@@ -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) {

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/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';

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);
+}

package/dist/release.js

@@ -200,20 +200,22 @@ function whatsNewIssues(text, version) {
  * types que Claude Code génère dans plugins/cadence-hud et que seul un clone ne porte pas). `git clone` du dépôt courant ne prend que ce qui est commité,
  * `--no-hardlinks` pour ne rien partager avec lui ; le clone est retiré, vert ou rouge.
  */
-function cloneStep(scripts) {
+function cloneStep(scripts, untag) {
     const run = scripts.map((n) => (n === 'test' ? 'npm test' : `npm run ${n}`)).join(' && ');
-    return `d=$(mktemp -d) && git clone -q --no-hardlinks . "$d/c" && (cd "$d/c" && npm ci && ${run}); r=$?; rm -rf "$d"; test $r -eq 0    (la suite dans un git clone neuf, comme publish.yml ; rouge = pas de tag)`;
+    return `d=$(mktemp -d) && git clone -q --no-hardlinks . "$d/c" && (cd "$d/c" && npm ci && ${run}); r=$?; rm -rf "$d"; test $r -eq 0 || ${untag}    (la suite dans un git clone neuf, qui reçoit le tag provisoire, comme publish.yml ; rouge = tag retiré)`;
 }
 /** Les étapes que le lead joue, dans l'ordre : la commande n'en fait aucune. */
 function steps(p, files, branch) {
     const tag = `v${p.version}`;
+    // Rouge à la porte, au clone ou à l'éval : le tag provisoire est retiré, la release n'a pas eu lieu.
+    const untag = `{ git tag -d ${tag}; false; }`;
     const out = [
         `git add ${files.join(' ')} && git commit -m "release: ${p.version}"`,
-        'cadence verify --gate --sha HEAD    (la suite et le build rejoués sur le commit de version, où le CHANGELOG n\'a plus de [Unreleased] plein ; rouge = pas d\'éval ni de tag)',
-        ...(p.cloneScripts.length ? [cloneStep(p.cloneScripts)] : []),
-        ...(p.hasEvalScript ? ['npm run eval:plugin -- --trust-plugin    (facturé ; un cas sous le seuil arrête la release)'] : []),
-        `git tag ${tag}`,
-        `git push origin ${branch} ${tag}    (le tag lance le workflow de publication)`,
+        `git tag ${tag}    (tag local provisoire sur le commit de version : les tests qui lisent le dernier tag, comme test/changelog.test.ts, voient la version publiée ; retiré si une des trois étapes suivantes est rouge, jamais poussé avant)`,
+        `cadence verify --gate --sha HEAD || ${untag}    (la suite et le build rejoués sur le commit de version, où le CHANGELOG n'a plus de [Unreleased] plein ; rouge = tag retiré, pas d'éval)`,
+        ...(p.cloneScripts.length ? [cloneStep(p.cloneScripts, untag)] : []),
+        ...(p.hasEvalScript ? [`npm run eval:plugin -- --trust-plugin || ${untag}    (facturé ; un cas sous le seuil arrête la release et retire le tag ; si la lecture du rapport le juge faux, reposer le tag de l’étape 2 avant le push)`] : []),
+        `git push origin ${branch} ${tag}    (le tag provisoire devient le tag de la release ; il lance le workflow de publication)`,
         'gh run watch    (jusqu\'à la fin du run de publication)',
         ...(p.isPrivate || p.packageName === '' ? [] : [`npm view ${p.packageName} version    (doit répondre ${p.version})`]),
         ...(p.pluginName ? [