@sylad/cadence 1.33.0 → 1.35.0

package/dist/orchestrate/command.js

@@ -33,7 +33,7 @@ import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { groupLots, runPool } from './pool.js';
 import { repoBranch } from './integrate.js';
 import { baseBranchOf, keptLines, keptTrees, lotBranch, lotTreeDir, planFileSet, recoverTree, removeTree } from './worktree.js';
-import { schemaFor } from './schemas.js';
+import { agentOf, schemaFor } from './schemas.js';
 import { resolveLotRepos } from '../repos.js';
 import { excludeState, lotFinished, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
 import { linkNodeBin, nvmVersionsDir, resolveNode } from './node-env.js';
@@ -302,7 +302,7 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             refusals.push(`${key} : ${e.message}`);
             continue;
         }
-        if (info && olderThanEffort(info.version) && Object.values(env.config.effort).some((e) => e !== 'default')) {
+        if (info && olderThanEffort(info.version) && Object.entries(env.config.effort).some(([step, e]) => e !== 'default' && (step !== 'probe' || env.config.probe))) {
             refusals.push(`${key} : claude ${info.version} n'a pas --effort (2.1.284 requise) : mettre claude à jour, ou orchestrate.effort à « default » pour chaque passe`);
             continue;
         }
@@ -518,6 +518,7 @@ function dryRun(lots, io, deps, budget, id) {
             else
                 steps.unshift({ kind: 'precheck', model: env.config.precheckLocal ? 'local' : 'sonnet' });
         }
+        steps.push(...(env.config.probe ? [{ kind: 'probe', model: 'sonnet' }] : [])); // L497 : entre l'écriture et la revue
         const { light, full } = env.config.review;
         if (l.small)
             steps.push({ kind: l.visible ? 'review-small' : 'review', model: l.light ? light : full });
@@ -550,7 +551,7 @@ function dryRun(lots, io, deps, budget, id) {
         io.out(l.light ? '  revue conforme avec mineurs : pas de passe des mineurs, ils sont rendus en notes' : '  revue conforme avec mineurs : une passe de correction des mineurs (session neuve), puis une revue courte ; les mineurs refusés sont rendus en « choix »');
         const pwDir = join(resolve(RunStore.runsDir(io.cwd)), id, lotSlug(l.project, l.lot), 'playwright');
         // brief écrit par --dry-run = base d'une délégation à la main : aucun dossier de vague (il n'existe pas)
-        const vars = { chemin: l.repo, lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '' };
+        const vars = { chemin: l.repo, lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '', diff: 'git diff <sha de départ>..HEAD' };
         vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? env.loadPlan().lots().find((x) => x.id === lot.parent) : undefined));
         if (specStage)
             vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, back: !!l.specLot });
@@ -564,11 +565,10 @@ function dryRun(lots, io, deps, budget, id) {
         }
         for (const s of steps) {
             const file = join(tmp, `${lotSlug(l.project, l.lot)}--${s.kind}.md`);
-            const brief = renderBrief(briefName(l, s.kind), s.kind === 'fiche' || vars.fiche === undefined ? vars : { ...vars, fiche: '' }, deps.templatesDir); // la consigne de revue de fiche ne sert qu'au brief de la fiche : implement et review en sont la base d'une délégation à la main
-            writeFileSync(file, brief);
+            writeFileSync(file, renderBrief(briefName(l, s.kind), s.kind === 'fiche' || vars.fiche === undefined ? vars : { ...vars, fiche: '' }, deps.templatesDir)); // la consigne de revue de fiche ne sert qu'au brief de la fiche : implement et review en sont la base d'une délégation à la main
             const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen).playwright;
             const local = s.model === 'local';
-            const args = (local ? buildLocalArgs : buildArgs)({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model === 'local' ? 'sonnet' : s.model, local, effort: env.config.effort[s.kind === 'review-small' ? 'review' : s.kind], schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'spec' ? 'spec-writer' : s.kind === 'accept' ? 'acceptance-writer' : s.kind === 'ux' || s.kind === 'maquette' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && (s.kind === 'implement' || s.kind === 'spec') ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright, disablePlugins: enabledPlugins(settingsFiles(deps.claudeHome, l.repo)) }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
+            const args = (local ? buildLocalArgs : buildArgs)({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model === 'local' ? 'sonnet' : s.model, local, effort: env.config.effort[s.kind === 'review-small' ? 'review' : s.kind], schema: schemaFor(s.kind), agent: agentOf(s.kind), cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && (s.kind === 'implement' || s.kind === 'spec') ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright, disablePlugins: enabledPlugins(settingsFiles(deps.claudeHome, l.repo)) }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
             io.out(`  ${s.kind} : ${local ? 'claude-local' : 'claude'} ${args.join(' ')}`);
             io.out(`    brief : ${file}`);
             const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen));

package/dist/orchestrate/cycle.js

@@ -10,14 +10,19 @@ import { planLoader, readDocsConfig, readPlanConfig } from '../config.js';
 import { PLAN_ACTIONS, leadAnswerMessage, planCommitMessage } from '../plan-commit.js';
 import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
+import { citesPriorWork, precheckNothingToFind } from './precheck.js';
+import { PROBE_FAILED, PROBE_RESERVE, probeStep, probeVars, scheduleProbe } from './probe.js';
 import { changedFiles, dirtyPaths, gitCommonDir, isAncestor, readCommits, resolveCommit, restoreWorktree, tryGit } from '../git.js';
 import { blockingLots, gitCommitsIn } from './table.js';
 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';
@@ -25,7 +30,7 @@ import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, t
 import { cleanPlaywrightOutput, pushed, remoteAdvances, snapshot } from './guard.js';
 import { sumTokens } from './result.js';
 import { cutReport, EXTENSION_MS, MAX_EXTENSIONS, workTimeoutMs } from './timeouts.js';
-import { ACCEPT_SCHEMA, checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, WORK_SCHEMA } from './schemas.js';
+import { ACCEPT_SCHEMA, agentOf, checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, WORK_SCHEMA } from './schemas.js';
 import { acceptationFile, acceptCommands, isAcceptList, acceptText, checkAcceptation, findAcceptation, isAcceptationFile, lockViolations, lotStartHead, parseAcceptation, planAcceptRuns, redSha, resealedRouge, sealAcceptation, setVert } from './accept.js';
 import { lotIds, referenceIdsText } from '../ref/coverage.js';
 import { avalFicheText, ficheContracts, ficheRules, hasScreenPart } from './aval.js';
@@ -194,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;
@@ -244,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)
@@ -485,6 +507,8 @@ function avalOf(c, kind) {
     // la revue courte d'un petit lot visible est sa seule passe : elle porte aussi la conformité à la maquette
     return kind === 'review-small' && l.small && l.visible && screen ? `${text}\n${avalFicheText('ux', o)}` : text;
 }
+/** Les étapes dont le programme rejoue la porte après la session (L399) : elles reçoivent ses commandes exactes et la part de machine (L350). La sonde écrit des tests : sans la porte, elle joue le runner seul et commite un test que `tsc` ou la qualité mettent au rouge, d'où une passe de correction pour rien. */
+const writesCode = (kind) => kind === 'implement' || kind === 'fix' || kind === 'probe';
 /** Consigne de la part de machine de la session (L350) ; vide quand la vague n'en a pas calculé. */
 const workersText = (c) => (c.wave.testWorkers ? testWorkersText(c.wave.testWorkers) : '');
 function briefFor(c, kind, local = false) {
@@ -492,7 +516,7 @@ function briefFor(c, kind, local = false) {
     const l = c.lot;
     const lot = plan.lot(l.lot);
     const tmpDir = c.wave.store.tmpDir(l.project, l.lot);
-    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), workers: kind === 'implement' || kind === 'fix' ? workersText(c) : '', gate: kind === 'implement' || kind === 'fix' ? gateText(c.config) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
+    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), workers: writesCode(kind) ? workersText(c) : '', gate: writesCode(kind) ? gateText(c.config) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
         vars.news = newsText(l.lot, pwDir);
@@ -504,6 +528,8 @@ function briefFor(c, kind, local = false) {
     // la vérification des ids d'un document de référence sur l'écran fini : la passe ux, ou la revue courte d'un petit lot visible qui n'a que celle-là (comme la conformité, avalOf)
     if (kind === 'ux' || (kind === 'review-small' && l.small && l.visible))
         vars.ux = [vars.ux, referenceIdsText('ux', lotIds({ ...lot, goal: l.goal ?? lot.goal }))].filter(Boolean).join('\n');
+    if (kind === 'probe')
+        Object.assign(vars, probeVars(ficheOf(c), lotCommitLines(c), startSha(c), l.lot));
     if (kind === 'implement' || kind === 'fix')
         vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? plan.lots().find((x) => x.id === lot.parent) : undefined));
     if (kind === 'precheck' && local)
@@ -574,7 +600,7 @@ function briefFor(c, kind, local = false) {
     }
     const brief = renderBrief(briefName(l, kind, !!c.integration), vars, c.wave.templates);
     // Les dépôts tiers (L456) : la consigne s'ajoute à tout brief d'écriture, sans passer par un gabarit (un gabarit modifié change l'empreinte que d'autres tests gardent).
-    return kind === 'implement' || kind === 'fix' || kind === 'spec' || kind === 'accept' ? `${brief}\n${tiersText(l.project, l.lot)}\n` : brief;
+    return ['implement', 'fix', 'spec', 'accept', 'probe'].includes(kind) ? `${brief}\n${tiersText(l.project, l.lot)}\n` : brief;
 }
 /** Tokens comptés par les sessions d'un lot (un lot repris compte ses étapes d'avant). */
 export const lotSpent = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
@@ -625,8 +651,8 @@ export function budgetStep(l) {
     const step = named ?? l.next;
     return step && step !== 'integrate' && WRITE_STEPS.includes(step) ? step : null;
 }
-/** Le budget du lot paie-t-il la passe de correction et la revue courte qui la suit ? Sans budget de lot : toujours. La part de l'escalade (L349) n'est pas à dépenser, sauf pour décider l'escalade elle-même (`escalating`). */
-const fixAffordable = (l, escalating = false) => l.budget === undefined || lotSpent(l) + REVIEW_RESERVE < l.budget - (escalating ? 0 : heldForEscalation(l));
+/** Le budget du lot paie-t-il la passe de correction et la revue courte qui la suit ? Sans budget de lot : toujours. La part de l'escalade (L349) n'est pas à dépenser, sauf pour décider l'escalade elle-même (`escalating`). `extra` : le coût d'une étape de plus devant elles (la sonde, L497). */
+const fixAffordable = (l, escalating = false, extra = 0) => l.budget === undefined || lotSpent(l) + extra + REVIEW_RESERVE < l.budget - (escalating ? 0 : heldForEscalation(l));
 /** Cause d'une suspension demandée par `--stop-after-current` (L79). */
 export const STOP_REQUESTED = 'arrêt demandé (--stop-after-current)';
 /** Le lot a-t-il été écarté de la vague par `--drop` (L79) ? */
@@ -677,11 +703,11 @@ async function session(c, kind, local = false) {
     const halt = halted(w, l);
     if (halt)
         return suspend(c, halt);
-    const write = kind === 'implement' || kind === 'fix' || kind === 'spec' || kind === 'accept';
+    const write = kind === 'probe' || WRITE_STEPS.includes(kind); // la sonde écrit (ses tests) mais le budget ne la borne pas : il est vérifié avant de la décider
     // Le budget du lot borne l'écriture, jamais la revue (L145) : une revue est jouée dès que le code est à relire (sauf tests rouges après une écriture, cf. REVIEW_RESERVE), la passe fix réserve son coût.
-    if (write && (lotOver(l) || (kind === 'fix' && !fixAffordable(l))))
+    if (WRITE_STEPS.includes(kind) && (lotOver(l) || (kind === 'fix' && !fixAffordable(l))))
         return overBudget(c, kind === 'fix' && !lotOver(l));
-    const model = kind === 'spec' || kind === 'accept' || kind === 'fiche' ? 'sonnet' : write ? (kind === 'fix' && l.escalation?.stage === 'fix' ? l.escalation.model : l.model) : local ? 'local' : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
+    const model = ['spec', 'accept', 'fiche', 'probe'].includes(kind) ? 'sonnet' : write ? (kind === 'fix' && l.escalation?.stage === 'fix' ? l.escalation.model : l.model) : local ? 'local' : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
     const effort = c.config.effort[kind === 'review-small' ? 'review' : kind];
     const before = await snapshot(wd(c));
     const neighbours = l.repos ?? [];
@@ -691,7 +717,7 @@ async function session(c, kind, local = false) {
     const sessionId = randomUUID();
     const step = { n, kind, model, ...(effort !== 'default' ? { effort } : {}), status: 'running', sessionId, started: new Date().toISOString(), headBefore: before.head ?? undefined };
     l.steps.push(step);
-    const label = { implement: 'implementing', fix: 'fixing', review: 'reviewing', ux: 'reviewing', 'review-small': 'reviewing', precheck: 'implementing', spec: 'implementing', accept: 'implementing', maquette: 'reviewing', fiche: 'reviewing' };
+    const label = { implement: 'implementing', fix: 'fixing', review: 'reviewing', ux: 'reviewing', 'review-small': 'reviewing', precheck: 'implementing', spec: 'implementing', accept: 'implementing', maquette: 'reviewing', fiche: 'reviewing', probe: 'implementing' };
     transition(c, label[kind]);
     w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} (${model})`);
     let brief;
@@ -742,7 +768,7 @@ async function session(c, kind, local = false) {
         effort,
         local,
         schema: schemaFor(kind),
-        agent: kind === 'spec' ? 'spec-writer' : kind === 'accept' ? 'acceptance-writer' : kind === 'ux' || kind === 'maquette' ? 'ux-reviewer' : kind === 'precheck' ? 'precheck-reader' : kind === 'fix' && l.docsFix ? 'doc-keeper' : write ? undefined : 'code-reviewer',
+        agent: kind === 'fix' && l.docsFix ? 'doc-keeper' : agentOf(kind),
         cwd: wd(c),
         wave: w.id,
         lot: lotKey(l.project, l.lot),
@@ -882,6 +908,19 @@ async function session(c, kind, local = false) {
             return null;
         step.status = 'failed';
         step.cause = outcome.cause;
+        if (kind === 'probe') {
+            // R9 : une sonde en échec ou coupée ne rend pas le lot. Ce qu'elle a laissé non commité est remis (suivis restaurés, nouveaux fichiers retirés), un warning le nomme.
+            // Coupée entre `git add` et son commit, elle laisse aussi l'index : il est désindexé d'abord, `restoreWorktree` ne remet que l'arbre de travail (sinon « AD q.spec.ts » et le lot rendu pour arbre sale).
+            // Un fichier à la fois : un chemin inconnu de l'index (non indexé) fait refuser toute la commande, les autres resteraient indexés.
+            const left = dirtBetween(before, await snapshot(wd(c)));
+            if (left.length) {
+                for (const f of left)
+                    tryGit(wd(c), ['restore', '--staged', '--', f]);
+                restoreWorktree(wd(c), left);
+                l.warnings.push(`sonde de cas limites : fichiers non commités laissés par la session retirés (${left.join(', ')})`);
+            }
+            return PROBE_FAILED;
+        }
         if (write && outcome.cause === 'délai dépassé') {
             // L298 : le travail laissé par une étape d'écriture coupée au délai est signalé (commits, fichiers, tests), pas un « échec » sec ; L303 : dans les dépôts voisins aussi.
             const repos = [{ rel: '', path: wd(c), before }, ...neighbours.map((r, i) => ({ rel: r.rel, path: r.path, before: beforeOthers[i] }))];
@@ -1282,43 +1321,6 @@ function badReport(c, step, e) {
     step.cause = e.message;
     return stop(c, 'failed', `${step.kind} : ${e.message}`);
 }
-/**
- * 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.
- */
-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);
-        }),
-    };
-}
 /**
  * Le contrôle préalable ne vaut que pour un lot sans commit (avec des commits, l'implémentation reprend légitimement) dont le
  * titre ou le goal (clé `goal:` du plan, ou `goal` donné au lancement) cite un constat ou un autre lot (L288, L292) : sans cela
@@ -1335,44 +1337,7 @@ export function needsPrecheck(config, plan, repo, lot, repos = [], goal) {
     const text = [l.title, l.goal, goal].filter(Boolean).join('\n');
     return citesPriorWork(text, lot, plan.lots().map((x) => x.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;
-    }
-}
+export { precheckNothingToFind };
 /**
  * Contrôle préalable (L77) : une session de lecture seule cherche si le livrable du lot est déjà dans le dépôt (fait par un
  * autre lot). « oui » rend le lot sans ouvrir d'implémentation ; « partiel » joint le constat au brief de l'implémentation.
@@ -1884,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)}`);
     }
@@ -2035,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.
@@ -2043,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`;
@@ -2068,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) {
@@ -2082,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.
@@ -2144,6 +2103,8 @@ export function redExcerpt(k) {
     const more = named.length > EXCERPT_LINES ? [`… (+${named.length - EXCERPT_LINES})`] : [];
     return [head.replace(/\s*:$/, ''), ...shown, ...more].join(' ; ');
 }
+/** Violations du verrou des tests d'acceptation (L173) par les commits faits depuis `head` ; aucune sans HEAD de départ. */
+const sealedViolations = (c, head) => (head ? lockViolations(wd(c), c.config.spec.dir, head, { rouge: c.lot.accept?.rouge ? { [c.lot.accept.acceptation]: c.lot.accept.rouge } : {}, lot: c.lot.lot, lotBase: c.lot.steps.find((s) => s.headBefore)?.headBefore, lotStart: lotStartHead(wd(c), lotWork(histPlan(c), wd(c), c.lot.lot).map((k) => k.sha)), lotCommits: lotCommits(histPlan(c), wd(c), c.lot.lot).map((k) => k.sha) }) : []);
 /** Étape d'écriture (implémentation, correction) : contrôles, puis étape suivante décidée. */
 async function work(c, kind) {
     const l = c.lot;
@@ -2206,7 +2167,7 @@ async function work(c, kind) {
     save(c);
     // Verrou des tests d'acceptation (L173) : ceux de TOUS les lots du dépôt, pas seulement du lot courant ; une modification est une question au lead. Contrôlé à CHAQUE fin de session, une question comprise (L200) :
     // une session qui remplace un test scellé puis pose une question ne passe pas par la reprise du lead pour se faire adopter.
-    const locked = done.step.headBefore ? lockViolations(wd(c), c.config.spec.dir, done.step.headBefore, { rouge: l.accept?.rouge ? { [l.accept.acceptation]: l.accept.rouge } : {}, lot: l.lot, lotBase: l.steps.find((s) => s.headBefore)?.headBefore, lotStart: lotStartHead(wd(c), lotWork(histPlan(c), wd(c), l.lot).map((k) => k.sha)), lotCommits: lotCommits(histPlan(c), wd(c), l.lot).map((k) => k.sha) }) : [];
+    const locked = sealedViolations(c, done.step.headBefore);
     if (locked.length) {
         stop(c, 'handed-back', `verrou des tests d'acceptation : ${locked.join(' ; ')}`);
         return;
@@ -2322,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) {
@@ -2350,7 +2311,18 @@ async function work(c, kind) {
             }
         }
     }
-    // Bibliothécaire (L306) : docs.sync signale un document en retard sur les commits du lot → une passe doc-keeper avant la revue, une seule fois par lot, aux mêmes conditions de passe et de budget que la porte ci-dessus. Si elle ne touche pas le document, la revue part et porte l'écart (brief docs.sync, constat majeur).
+    // Sonde de cas limites (L497) : une fois par lot, après la porte « code sans test », avant le bibliothécaire et la revue.
+    if (scheduleProbe(c.config, l, { skip: minorsPass || !alreadyDone, late: l.pass >= MAX_PASSES - 1, pays: fixAffordable(l, false, PROBE_RESERVE), count: budgetCount(l) })) {
+        // Les contrôles de la porte restent au lot pendant la sonde : sans nouveau commit de sa part, la revue les reprend pour ce HEAD.
+        l.checks = runs.length ? { head: git(wd(c), 'rev-parse', 'HEAD'), tree: git(wd(c), 'rev-parse', 'HEAD^{tree}'), runs } : undefined;
+        return save(c);
+    }
+    await toReview(c, runs, minorsPass);
+}
+/** Fin d'une écriture dont les portes sont passées : le bibliothécaire (L306), puis la première revue. Aussi la suite d'une sonde (L497) qui n'a rien à corriger. */
+async function toReview(c, runs, minorsPass) {
+    const l = c.lot;
+    // Bibliothécaire (L306) : docs.sync signale un document en retard sur les commits du lot → une passe doc-keeper avant la revue, une seule fois par lot, aux mêmes conditions de passe et de budget que la porte « code sans test ». Si elle ne touche pas le document, la revue part et porte l'écart (brief docs.sync, constat majeur).
     if (!l.docsGate && !minorsPass) {
         const { gaps } = docGaps(c);
         if (gaps.length) {
@@ -2372,6 +2344,11 @@ async function work(c, kind) {
     l.next = firstReview(c);
     save(c);
 }
+/** Ce que la sonde (probe.ts) emprunte au cycle. */
+const probeIo = (c) => ({
+    lot: c.lot, config: c.config, cwd: wd(c), play: () => session(c, 'probe'), take: (step, rep) => takeReport(c, { step }, rep), sealed: (head) => sealedViolations(c, head), dirt: dirtAfter, gate: (red, runs) => programChecks(c, red, runs),
+    fix: (constats) => toFix(c, constats, 'sonde de cas limites'), review: (runs) => toReview(c, runs, false), handBack: (why) => void stop(c, 'handed-back', why), pays: () => fixAffordable(c.lot), head: () => git(wd(c), 'rev-parse', 'HEAD').trim(),
+});
 /** Mention « sans commit » du verdict quand la passe des mineurs n'a rien commité (l'UX finale conclut alors à la place de la passe). */
 const noCommitNote = (l) => (l.warnings.some((w) => w.startsWith('passe des mineurs sans commit')) ? ' sans commit' : '');
 /** Revue de code qui clôt le cycle : complète, ou courte une fois la passe des mineurs jouée. */
@@ -3104,6 +3081,8 @@ export async function runLot(c) {
                 await acceptStep(c);
             else if (kind === 'implement' || kind === 'fix')
                 await work(c, kind);
+            else if (kind === 'probe')
+                await probeStep(probeIo(c));
             else if (kind === 'integrate')
                 await integrateLot(c);
             else

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