@sylad/cadence 1.33.0 → 1.35.0

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/precheck.js

@@ -0,0 +1,79 @@
+// Les critères du contrôle préalable (L77, L288, L292, L322) : un lot qui cite un constat ou un autre lot, et un lot créé après le dernier commit de code, qui n'a rien à retrouver.
+import { relative } from 'node:path';
+import { isPlanOnly, lotWork } from '../audit.js';
+import { git } from './worktree.js';
+/**
+ * Mots du titre ou du goal qui disent que le lot reprend un constat : le livrable peut déjà exister. Mots entiers (« review » ne
+ * se lit pas dans `qa-reviewer` ni `review-small`), au pluriel ou accordés pour « constat ».
+ */
+const CITES_FINDING = /(?<![\w-])(?:constat\w*|revues?|reviews?|audits?)(?![\w-])/i;
+/**
+ * Le texte du lot (titre, goal, objectif donné) cite un constat, ou un autre lot dont le travail a pu être fait. Pour un lot
+ * `L<n>`, « L12 » compte dans le texte de `L30` (aussi dans « L12-L15 », « L12-bis », « L12.3 ») et non celui de `L12` ni d'un lot postérieur ; tout identifiant du plan qui n'est
+ * pas `L<n>` (`Q-CAN5`, `B28.1`, `Q4/qa-expectations`) compte cité en entier (`B28.1` n'est pas `B28.10`), pour un lot `L<n>`
+ * comme pour un autre ; un lot d'un autre projet (`cadence:L68`) compte toujours.
+ */
+export function citesPriorWork(text, lot, ids) {
+    if (CITES_FINDING.test(text))
+        return true;
+    const { ids: cited, foreign } = citedLots(text, lot, ids);
+    return foreign || cited.length > 0;
+}
+/**
+ * Les lots que le texte cite (même reconnaissance que `citesPriorWork`, L288/L292) : les identifiants du plan cités, et `foreign` quand il cite un lot d'un autre projet
+ * (`cadence:L68`, dont on ne lit pas les commits ici).
+ */
+function citedLots(text, lot, ids) {
+    const foreign = /(?<![\w-])[a-z][\w-]*:L\d+(?!\w)/i.test(text);
+    const own = /^L(\d+)$/.exec(lot);
+    const cited = (id) => new RegExp(`(?<![\\w.-])${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w-]|\\.\\w)`).test(text);
+    return {
+        foreign,
+        ids: ids.filter((id) => {
+            if (id === lot)
+                return false;
+            const n = /^L(\d+)$/.exec(id);
+            if (own && n)
+                return Number(n[1]) < Number(own[1]) && new RegExp(`(?<![\\w-])${id}(?!\\w)`).test(text);
+            return cited(id);
+        }),
+    };
+}
+/**
+ * Un lot créé après le dernier commit de code du dépôt n'a rien à retrouver (L322) : tout ce que le dépôt contient date d'avant le lot, donc aucun autre lot ne l'a livré.
+ * Rend la raison à écrire au journal, ou null quand le contrôle garde un sens. Le lot est daté par le commit qui a ajouté son id au plan, borné par sa clé `created` (une
+ * migration ou un déplacement du plan ne rajeunit pas un vieux lot) ; le dernier commit de code est le dernier qui ne touche pas que le plan (`isPlanOnly`). Prudent : lot
+ * qui travaille dans des dépôts voisins, id introuvable dans l'historique du plan, dépôt sans commit de code ou instants égaux → le contrôle reste.
+ * Le contrôle reste aussi quand le titre ou le goal (ou le goal donné au lancement) cite un lot qui a déjà ses propres commits, ou un lot d'un autre projet : une « suite de revue L<n> » écrite
+ * juste après le dernier correctif de L<n> liste des constats que les passes de correction de L<n> ont pu régler avant la création du lot (rejoué depuis le 24-10 : 5 lots sautés à tort,
+ * dont 2 avec un vrai « partiel »).
+ */
+export function precheckNothingToFind(plan, root, lot, repos = [], goal) {
+    if (repos.length)
+        return null;
+    try {
+        const rel = relative(root, plan.path);
+        const idLine = `^\\s*- id: ["']?${lot.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')}["']?\\s*$`;
+        // Pas de `--reverse` : avec `--follow`, git 2.43 ne rend rien sur un fichier renommé (`raf migrate`) ; le plus ancien est la dernière ligne.
+        const added = git(root, '-c', 'core.quotepath=off', 'log', '--follow', '--format=%ct', '-G', idLine, '--', rel).split('\n').filter(Boolean).pop();
+        if (!added)
+            return null;
+        const created = plan.lot(lot).created;
+        const endOfCreated = created ? Date.parse(`${created}T23:59:59`) / 1000 : Infinity;
+        const createdAt = Math.min(Number(added), Number.isNaN(endOfCreated) ? Infinity : endOfCreated);
+        const log = git(root, 'log', '--format=%H %ct').split('\n').filter(Boolean);
+        const code = log.map((x) => x.split(' ')).find(([sha]) => !isPlanOnly(sha, plan, root));
+        if (!code)
+            return null;
+        if (createdAt <= Number(code[1]))
+            return null;
+        const l = plan.lot(lot);
+        const { ids, foreign } = citedLots([l.title, l.goal, goal].filter(Boolean).join('\n'), lot, plan.lots().map((x) => x.id));
+        if (foreign || ids.some((id) => lotWork(plan, root, id).length > 0))
+            return null;
+        return `lot créé après le dernier commit de code du dépôt (${code[0].slice(0, 7)}) : rien à retrouver`;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/orchestrate/probe.js

@@ -0,0 +1,124 @@
+import { docSyncSet, filesOf } from '../docsync.js';
+import { readCommits } from '../git.js';
+import { checkShape, PROBE_SCHEMA } from './schemas.js';
+/** Rendu par la session de la sonde quand elle n'a rien donné (échec, coupure, délai) : la sonde ne bloque jamais le lot, un warning et la revue part. */
+export const PROBE_FAILED = Symbol('probe-failed');
+/**
+ * Coût réservé à la sonde en plus de la correction et de la revue qui la suit : une session Sonnet d'écriture. ESTIMATION, aucune mesure (la sonde n'a pas encore joué) :
+ * le p90 d'une passe fix Sonnet, 65 k tokens comptés (mesure du 2026-10-15, voir REVIEW_RESERVE). À remesurer sur les premières sondes (`cadence perf`, étape probe).
+ */
+export const PROBE_RESERVE = 65_000;
+/** Préfixe du texte d'un constat de la sonde : il distingue, dans le journal, la passe de correction qu'elle déclenche. */
+const PROBE_FINDING = 'sonde de cas limites : ';
+/**
+ * Décide la sonde d'un lot (R3, R6) : vrai quand elle est la prochaine étape. Décidée une seule fois par lot (`l.probe`), jouée ou écartée avec un warning qui dit pourquoi.
+ * Sans la clé `orchestrate.probe`, rien : ni champ ni warning.
+ */
+export function scheduleProbe(config, l, o) {
+    if (!config.probe || l.probe || o.skip)
+        return false;
+    l.probe = true;
+    if (!o.late && o.pays) {
+        l.next = 'probe';
+        return true;
+    }
+    l.warnings.push(`sonde de cas limites non jouée : ${l.pass} passe(s) de correction déjà faite(s) ou budget du lot (${o.count}) insuffisant`);
+    return false;
+}
+/** Les variables du brief de la sonde : la fiche du lot quand il en a une, ses commits, et la commande du diff (jamais le diff collé). */
+export function probeVars(fiche, commits, from, lot) {
+    return {
+        fiche: fiche ? `The lot has a spec sheet: \`${fiche}\`. Read it first: each of its rules (Rn) states a behaviour to attack, and its contracts give the exact errors the code must raise.` : '',
+        commits,
+        diff: from ? `git diff ${from}..HEAD` : `git log -p --reverse --grep=${lot}`,
+    };
+}
+const unplayed = (l, why) => l.warnings.push(`sonde de cas limites non jouée : ${why}`);
+/** Le rapport de la session, ou un warning « non jouée » quand il est illisible (la revue part quand même). */
+function readReport(l, report) {
+    try {
+        return checkShape(report, PROBE_SCHEMA);
+    }
+    catch (e) {
+        unplayed(l, e.message);
+        return undefined;
+    }
+}
+/** Les fichiers commités par la sonde qui ne sont pas des tests (R8) : un warning les nomme, rien n'est retiré. Sans `testGate.tests` déclaré, rien ne distingue un test d'un autre. */
+function warnOutsideTests(io, headBefore) {
+    const tests = io.config.testGate?.tests;
+    if (!tests)
+        return;
+    const isTest = docSyncSet(tests);
+    const outside = [...filesOf(io.cwd, readCommits(io.cwd, { range: headBefore ? `${headBefore}..HEAD` : undefined }))].filter((f) => !isTest(f)).sort();
+    if (outside.length)
+        io.lot.warnings.push(`sonde de cas limites : la session a modifié du code hors tests (${outside.join(', ')})`);
+}
+/** Les contrôles faits après une session qui a commité, avec ou sans rapport : verrou, dépôt propre (`dirt`), fichiers hors tests. Vrai quand le lot est rendu. */
+function handedBack(io, dirt, headBefore) {
+    const locked = io.sealed(headBefore);
+    const why = locked.length ? `verrou des tests d'acceptation : ${locked.join(' ; ')}` : dirt.length ? `dépôt sale après probe : ${dirt.join(', ')}` : '';
+    if (why)
+        io.handBack(why);
+    else
+        warnOutsideTests(io, headBefore);
+    return !!why;
+}
+/**
+ * Les constats de la sonde (R4, R5) : les rouges NOUVEAUX de la porte du programme (jamais un échec déjà rouge au départ), en gravité majeure, avec ce que la session annonce
+ * (« test — borne — attendu ») pour que la correction voie la borne. Sans `orchestrate.test`, les échecs annoncés tels quels, dits non vérifiés par le programme.
+ */
+function findings(l, red, claimed, gated) {
+    const said = claimed.length ? `\nLa sonde annonce : ${claimed.join(' ; ')}` : '';
+    const out = red.map((k) => ({ ...k, gravite: 'majeur', texte: `${PROBE_FINDING}${k.texte}${said}` }));
+    if (gated || !claimed.length)
+        return out;
+    l.warnings.push('sonde de cas limites : échecs annoncés par la session, non vérifié par le programme (orchestrate.test absent)');
+    return [...out, ...claimed.map((e) => ({ source: 'tests', gravite: 'majeur', texte: `${PROBE_FINDING}${e}` }))];
+}
+/**
+ * Joue la sonde (R3 à R9). Elle ne bloque jamais le lot : échec, coupure, délai ou rapport illisible sont un warning et la revue part. Seuls un quota (suspension : la reprise rejoue la sonde),
+ * un verrou d'acceptation violé ou un dépôt sale le rendent, comme après toute session d'écriture. Un test rouge nouveau repart en correction ; sinon le cycle reprend (bibliothécaire, revue).
+ */
+export async function probeStep(io) {
+    const l = io.lot;
+    const done = await io.play();
+    if (!done)
+        return;
+    const step = l.steps[l.steps.length - 1];
+    const rep = done === PROBE_FAILED ? cutSession(io, step) : readSession(io, done, step);
+    if (rep === 'rendu')
+        return;
+    // La porte du programme après la sonde comme après toute écriture, mais seulement si elle a commité : sans nouveau commit il n'y a rien de neuf à rejouer.
+    const red = [];
+    const runs = [];
+    const moved = !!step.headBefore && io.head() !== step.headBefore;
+    if (moved)
+        await io.gate(red, runs);
+    const found = moved ? findings(l, red, (rep?.echecs ?? []).map((e) => e.trim()).filter(Boolean), !!io.config.test) : [];
+    if (found.length) {
+        // Une correction que le budget ne paie plus n'est pas sautée : l'étape fix refuse et le lot revient au lead sans revue, tests rouges (L145, cycle.ts overBudget).
+        if (io.pays())
+            l.warnings.push(`${PROBE_FINDING}${found.length} constat(s), passe de correction avant la revue`);
+        step.constats = found.map((k) => k.texte);
+        io.fix(found);
+        return;
+    }
+    // Sans nouveau commit, les contrôles de la porte jouée après l'écriture valent toujours pour ce HEAD : la revue les garde (sinon elle relance la suite et le build).
+    await io.review(moved ? runs : [...(l.checks?.runs ?? [])]);
+}
+/** La session n'a rien donné (échec, coupure, délai) : un warning, pas de rapport. Ce qu'elle a commité avant d'être coupée passe les mêmes contrôles qu'après un rapport (commits au journal, verrou, fichiers hors tests) ; le dépôt a déjà été remis propre. */
+function cutSession(io, step) {
+    unplayed(io.lot, step.cause ?? 'échec');
+    if (!step.headBefore || io.head() === step.headBefore)
+        return undefined;
+    io.take(step, { questions: [] });
+    return handedBack(io, [], step.headBefore) ? 'rendu' : undefined;
+}
+/** Le rapport d'une session qui a répondu : questions notées, verrou et dépôt contrôlés. `'rendu'` quand le lot est rendu. */
+function readSession(io, done, step) {
+    const rep = readReport(io.lot, done.report);
+    for (const q of io.take(step, rep ?? { questions: [] }))
+        io.lot.warnings.push(`sonde de cas limites : question sans réponse (la sonde ne bloque pas le lot) : « ${q.trim()} »`);
+    return handedBack(io, io.dirt(done), step.headBefore) ? 'rendu' : rep;
+}

package/dist/orchestrate/schemas.js

@@ -53,8 +53,17 @@ export const PRECHECK_SCHEMA = {
     properties: { dejaPresent: { type: 'string', enum: ['oui', 'partiel', 'non'] }, preuves: strings, resume: str },
     required: ['dejaPresent', 'preuves', 'resume'],
 };
+/** Sortie de la sonde de cas limites (L497) : les tests commités, et `echecs` les tests qu'elle annonce rouges (« test — borne — attendu », un par entrée). */
+export const PROBE_SCHEMA = {
+    type: 'object',
+    properties: { commits: WORK_SCHEMA.properties.commits, echecs: strings, nonVerifie: strings, questions: strings, choix: strings, resume: str },
+    required: ['commits', 'echecs', 'nonVerifie', 'questions', 'resume'],
+};
 /** Une revue de maquette rend le même rapport qu'une revue d'ergonomie (REVIEW_SCHEMA). */
-export const schemaFor = (kind) => (kind === 'precheck' ? PRECHECK_SCHEMA : kind === 'spec' ? SPEC_SCHEMA : kind === 'accept' ? ACCEPT_SCHEMA : kind === 'implement' || kind === 'fix' ? WORK_SCHEMA : REVIEW_SCHEMA);
+export const schemaFor = (kind) => (kind === 'precheck' ? PRECHECK_SCHEMA : kind === 'spec' ? SPEC_SCHEMA : kind === 'accept' ? ACCEPT_SCHEMA : kind === 'probe' ? PROBE_SCHEMA : kind === 'implement' || kind === 'fix' ? WORK_SCHEMA : REVIEW_SCHEMA);
+/** L'agent du paquet de chaque étape qui en a un, ou `undefined` pour une écriture sans agent ; les revues et la fiche n'y sont pas : `code-reviewer`. */
+const STEP_AGENT = { implement: undefined, fix: undefined, probe: undefined, spec: 'spec-writer', accept: 'acceptance-writer', ux: 'ux-reviewer', maquette: 'ux-reviewer', precheck: 'precheck-reader' };
+export const agentOf = (kind) => (kind in STEP_AGENT ? STEP_AGENT[kind] : 'code-reviewer');
 /** Contrôle la forme d'une sortie structurée : un champ absent ou mal typé est une erreur nommée. */
 export function checkShape(value, schema) {
     if (!value || typeof value !== 'object' || Array.isArray(value))

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/perf.js

@@ -48,7 +48,7 @@ function planLot(plans, project, lot) {
     return lots.find((l) => l.id === lot) ?? (lot.includes('/') ? lots.find((l) => l.id === lot.slice(0, lot.indexOf('/'))) : undefined);
 }
 /** Rang d'affichage d'une sorte d'étape : l'ordre du cycle, les sortes inconnues après. */
-const KIND_ORDER = ['spec', 'maquette', 'fiche', 'precheck', 'implement', 'review', 'review-small', 'ux', 'fix', 'accept'];
+const KIND_ORDER = ['spec', 'maquette', 'fiche', 'precheck', 'implement', 'probe', 'review', 'review-small', 'ux', 'fix', 'accept'];
 const kindRank = (kind) => (KIND_ORDER.includes(kind) ? KIND_ORDER.indexOf(kind) : KIND_ORDER.length);
 /** Part de `counted` rangée en entrée quand une étape ne porte que ce compteur (journal ancien) : le reste est en sortie (R8 b). */
 const COUNTED_INPUT_SHARE = 0.9;

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 ? [