@sylad/cadence 1.33.0 → 1.35.0

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "cadence",
       "description": "Session start and close rituals driven by a versioned plan (raf), and deliveries proven by their effect. Needs the cadence CLI (npm i -g @sylad/cadence).",
-      "version": "1.33.0",
+      "version": "1.35.0",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "description": "A repo-native working method: session start and close rituals driven by a versioned plan (raf), deliveries proven by their effect, and three reviewer agents (UX, code, QA).",
-  "version": "1.33.0",
+  "version": "1.35.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/NOTICE

@@ -0,0 +1,28 @@
+cadence — third-party attribution
+
+The "Delivery grid" section of agents/ux-reviewer.md lists AI-tic rules that are
+reworded (not copied) from the rules of the work `detect.mjs`. Its parts ported
+from Impeccable are under the Apache License, Version 2.0 (Apache-2.0,
+https://www.apache.org/licenses/LICENSE-2.0); its own rules are under MIT.
+
+Work:        scripts/detect.mjs (static detection of AI-generated interface tics)
+Repository:  https://github.com/ryanthedev/design-for-ai
+Commit read: 37d7ae63d1afa45eb57ec90bc246cef6dd60c033 (shallow clone, read only, 2026-11-01)
+Licence:     per rule. The header of scripts/detect.mjs limits Apache-2.0 to the
+             parts ported from Impeccable (https://github.com/pbakaus/impeccable,
+             Copyright Impeccable contributors, Apache-2.0) with modifications:
+             nested-cards, gradient-text, dark-glow, overused-font and
+             marketing-buzzword. It names purple-triplet and
+             unmodified-shadcn-tokens as new rules of design-for-ai, under MIT
+             (.claude-plugin/plugin.json declares "license": "MIT"; the
+             repository carries no LICENSE file).
+Original authors: the design-for-ai authors (ryanthedev); Impeccable contributors
+             for the ported parts.
+
+Of the 16 rules of detect.mjs, seven are kept and reworded (nested-cards,
+gradient-text, purple-triplet, unmodified-shadcn-tokens, dark-glow,
+overused-font, marketing-buzzword) and nine are not. The rules of the agent are
+written in our own words with their own thresholds and charter exceptions; the
+script is neither bundled nor run, and no text of the original is copied.
+
+The package itself stays under the MIT licence (see LICENSE).

package/README.md

@@ -48,8 +48,8 @@ Details: [docs/skills.md](docs/skills.md) and [docs/cadence-hud.md](docs/cadence
 ## Where to read more
 
 - [docs/raf.md](docs/raf.md): the plan, its commands and its file.
-- [docs/orchestrate.md](docs/orchestrate.md): waves of sessions and their budgets, and which repositories a session may commit in.
-- [docs/deliver.md](docs/deliver.md): wait for the CI, deploy, verify the effect.
+- [docs/orchestrate.md](docs/orchestrate.md): waves, budgets, and [the edge-case probe](docs/orchestrate.md#the-edge-case-probe-orchestrateprobe-l497).
+- [docs/deliver.md](docs/deliver.md): wait for the CI, deploy, verify the effect; [docs/remote-gate.md](docs/remote-gate.md): the gate on another machine.
 - [docs/spec.md](docs/spec.md): screen and back-end sheets.
 - [docs/ref.md](docs/ref.md): reference documents (specs, norms, mock-ups) and the coverage of their elements by the lots.
 - [docs/lead.md](docs/lead.md): the lead workflow, and the `livreur` agent that delivers a ready lot for it.

package/agents/qa-reviewer.md

@@ -40,8 +40,9 @@ missing, or the URL does not answer, say so and stop.
    *suspect* at most. Return a DRAFT expectations file as text, for the human to correct: you do not
    write it into the repository. Say plainly that without expectations an empty state cannot be told
    from a normal one.
-4. **Open each page in a real browser** (Playwright, or the browser tool available), at **1440 px**
-   and **390 px** wide. Walk within the bounded pass below. Let it settle: after `load`, wait a fixed few seconds, scroll through the
+4. **Open each page in a real browser** (your own Playwright context, see below), at **1440 px**
+   and **390 px** wide.
+   The browser is yours alone: open your own browser context, never the browser or the tabs another session already holds (a Playwright server shared with another agent, a tab left open by a previous pass). Launch a persistent context with `launchPersistentContext` from a Node script that you write outside the repository and run with Bash, in a `userDataDir` reserved for this agent, under `$HOME/.cache/cadence-qa/` (outside the repository), named after the app (host and port of the base URL, every character that is not a letter, a digit or a dash replaced by a dash, so `localhost:4200` gives `localhost-4200`), kept between passes on that app; launch it first, and do not test for a lock file before (two passes would both see none): only when the launch fails because that directory is open in another browser, use a directory suffixed with your process id instead (a suffixed profile is single-use: delete it at the end of the pass); a `SingletonLock` left by a browser that closed abruptly is a link `host-pid` whose pid is no longer running: remove that link and keep the named profile, so two QA passes running together, on two apps or on the same one, never share a profile. The `browser_*` tools of the Playwright MCP server take no `userDataDir` and use the one browser of the session that started you, which other agents use too: do not use them. The script loads `playwright` from a package already on the machine — the repository does not depend on it and the temporary directory has no `node_modules`, so a bare `require('playwright')` fails there: resolve it with `createRequire` (or `require` on an absolute path) from, in this order, the directory `CADENCE_PLAYWRIGHT` names when that variable is set, the app repository's own `node_modules/playwright` when the app depends on it, the package of the Playwright MCP server the wave started (`ps -eo args` shows `<dir>/node_modules/.bin/playwright-mcp`: load `<dir>/node_modules/playwright`), else the newest `~/.npm/_npx/*/node_modules/playwright`. Launch Playwright's bundled Chromium first; when the launch fails because its executable is missing (`Executable doesn't exist`), relaunch with `channel: 'chrome'`, the installed Chrome the MCP server itself runs. Never install anything (`npm i`, `npx playwright install`, `npx -y`): it needs the network, and a version pulled that way may not find its browser. When no candidate loads and launches, the pass does not take place: say so under « Not verified » as a missing browser tool and stop — the `browser_*` tools are not a fallback. At the end, close your own context and nothing else: you neither read nor close a tab you did not open, nor the browser of another session. Walk within the bounded pass below. Let it settle: after `load`, wait a fixed few seconds, scroll through the
    page (lazy images), wait again — never for network idle, which streams and polling never reach.
    Then measure:
    - read the page as text first: its rendered text and structure (`innerText`, or the
@@ -49,7 +50,7 @@ missing, or the URL does not answer, say so and stop.
      you listened to. Compare that text with the expectations, and take a capture only for a gap —
      a `shows:` line unmet, a `never:` text found, a failed call — as evidence of that gap: a page
      that matches its expectations gets none;
-   - browser state, once before the first page, in a profile already used (a persistent context, not a fresh one — a `userDataDir` reserved for QA and kept between passes, never the user's own browser profile): compare the bundle the page loaded (its script URL) with the one `index.html` references, re-read without cache — a returning visitor still holds the old one, so a difference is stated in the report — then clear the cache and measure;
+   - browser state, once before the first page, in a profile already used (a persistent context, not a fresh one — the `userDataDir` of your own browser context, see above, never the user's own browser profile): compare the bundle the page loaded (its script URL) with the one `index.html` references, re-read without cache — a returning visitor still holds the old one, so a difference is stated in the report — then clear the cache and measure;
    - the expected content is present and non-empty — name the selector or the text found and its
      count (`.player-card` ×14), not "the list looks fine";
    - no `never:` text on screen, and no other error or missing-data message;
@@ -166,7 +167,7 @@ A short report:
   returned". It is the last line of the report.
 
 Give screenshots and snapshots the absolute path of the capture directory your brief names when it names one (a wave's Playwright server resolves a bare name against the repository, not its output directory); with no such directory in the brief, a path under `.playwright-mcp/` (e.g. `.playwright-mcp/page-home.png`: the Playwright MCP resolves a bare file name against the repository, where it would land at the root and dirty the working tree) and no other path inside the repository (list them in the report if git does not ignore that folder). Other temporary files go in a temporary directory outside the repository, or in the one
-the caller names; remove them, or list their paths in the report — except the QA browser profile, which is kept for the next pass. The working tree is left as you
+the caller names; remove them, or list their paths in the report — except the QA browser profile named after the app, which is kept for the next pass (a profile suffixed with a process id is removed). The working tree is left as you
 found it.
 
 ## Short reply

package/agents/spec-writer.md

@@ -11,6 +11,8 @@ Follow the brief you are given. The method:
 1. **Read the charter first.** The project's CLAUDE.md, its CSS and variables, the neighbouring components and pages, `docs/qa/expectations.md`, the routes and API contracts already present. The mockup must look like the product: reuse what exists, invent nothing when an equivalent exists.
 2. **List the states before drawing**: empty, loading, error, and loaded when there is data. Each is an addressable section `#etat-<état>` of one static `maquette.html` (HTML + CSS, no business JavaScript). Each field of the sheet carries `data-testid="<field id>"`.
    **Write the texts before drawing and render them in the mockup**, with the structure the reviewer will check: an error message says what, why, how to fix; an empty or loading state says what it is, why it is empty, how to start; an action label is a verb that names the result, never “OK” or “Validate” alone; the confirmation of a destructive action names the object and the consequence and its buttons are named by the action; one word per notion, in the sheet and in the mockup. Draw one primary element per state, one visible label per field, and take every colour, size and spacing from the product’s CSS variables (a product with no CSS variables has none to take: follow its existing values). A word or a message already in the product is kept as it is (reuse what exists).
+   **Colours you add: semantic tokens, `on-*`, contrast.** Start from the charter's colour tokens and their text tokens (CSS variables). For every colour the screen adds, name a semantic token named by its role (`primary`, `success`, `warning`, `danger`, `surface`…) and its text token `on-<role>`; a colour added without its `on-*` token is a defect of the spec. The values come from a ramp drawn from the charter's brand colour (same hue, stepped lightness): the agent imports no external palette. A role already covered by a token of the charter keeps that token: reuse what exists, create no duplicate token, and only measure the existing pair. Write the measure in `contraste.md`, in the spec folder, committed with the sheet: `contraste.md` has two lists: the tokens created, and the existing pairs measured (an existing token appears only in the second), with one line per token / on-token pair: both values, the computed ratio (WCAG 2.2, relative luminance) and `ok` or `non`. Every pair is at least 4.5:1 (a pair at 4.49:1 is `non`, a pair at 4.5:1 is `ok`); fix a pair that falls short: change the step of the ramp, never the text size. A product with no CSS variable and no brand colour gets a mockup that follows its existing values: invent no ramp, measure the existing values in `contraste.md`, and write the absence of a coloured charter in the sheet. On a product that has a charter, never propose, draw or blame a generic style from a catalogue; with no charter, follow the existing values and say so, and choose no style.
+
 3. **Render and look.** Capture each state at **1440 px** and **390 px** wide with the browser tool (Playwright), named `maquette-<état>-<largeur>.png`, with the absolute capture-directory path your brief gives in front of the name (a bare name lands in the repository), and look at every capture before keeping it: a mockup you did not look at is not checked. Copy the kept captures into the spec folder.
    Before keeping a state, check its sample data: compute the weekday of every date shown (`date -d`), never write it from memory.
 4. **Write the sheet** in the format of the template of the brief, and run `cadence spec check` on it until it passes. Every rule is `sourcee` (say where it comes from) or `hypothese` (say what would change if it were wrong, in `si_faux`). Never dress a guess as a source.

package/agents/ux-reviewer.md

@@ -116,3 +116,31 @@ session and a call by hand without it have none.
 - If you cannot write the file, say so on the first line of the reply and give the whole report in the reply, as if
   the brief had no report file: a verdict whose evidence nobody can read is lost.
 - With no `Report file:` line in the brief, give the complete report in your reply.
+
+## Delivery grid
+
+This section applies in every case, with or without a `Report file:` line, to the UX step of a visible lot and to the review of an existing screen. It does not apply in mockup mode or conformity mode, whose captures stay at 1440 px and 390 px. With a `Report file:` line, each point is a line of the checklist of the report file, ticked or not, with the measure or the capture that supports it; the short reply does not repeat the list. Without a `Report file:` line (the orchestrated `ux` step), the structured report has no checklist and its schema is unchanged: a point that could not be checked goes in `nonVerifie` (`grille : focus visible non vérifié`), and the `verdict` line ends with the tally of the grid and the tics line, e.g. `… — grille 5/5 — tics d’IA : 0 constat`, so the lead knows the grid was passed. In both cases a point that fails is a finding on the blocking / major / minor scale of the Method section, no severity of its own (a focus that is not visible is ranked like any other accessibility gap).
+
+Points, at widths **375, 768, 1024 and 1440 px**:
+
+- visible focus on every interactive element;
+- `prefers-reduced-motion` respected by animations and transitions;
+- `cursor: pointer` on what is clickable;
+- no emoji used as an icon;
+- no horizontal scroll at any of the four widths.
+
+A width that cannot be rendered goes in `nonVerifie`, not ticked.
+
+**AI tics.** This is a static check: apply these rules while reading the diff of the lot, one by one; never run `detect.mjs` and use no tool beyond those above. They are reworded from the rules of `detect.mjs`, a static detector of 16 rules (Apache-2.0 for the parts it ports from Impeccable, MIT for its own rules purple-triplet and unmodified-shadcn-tokens; work, commit, licence and author in the NOTICE file of the package): seven of the 16 are kept, the nine others are not (see below). Each tic found is a numbered finding T1, T2… with its file, line, named rule and severity. A tic with no effect on the task or on legibility is minor and stays a note of the lot; a tic that harms legibility or slows the user follows the existing scale (major, or blocking if a task or accessibility fails), no severity of its own. A tic that is a choice of the product's charter is not a finding: the charter wins over the rules. The checklist (or, without a report file, the end of the `verdict` line) carries `tics d’IA : 0 constat` when none is found, and `tics d’IA : non applicable` when the lot has no front file.
+
+- `tic-nested-cards`: a card (border or shadow, rounded or filled) inside another card, which flattens the hierarchy (Gestalt: one grouping level per idea);
+- `tic-gradient-text`: text filled with a gradient (`background-clip: text`); measure the contrast (WCAG 1.4.3) at the lightest point of the gradient;
+- `tic-purple-triplet`: the accent values `#6366F1`, `#8B5CF6` or `#A855F7` (or Tailwind `indigo`, `violet`, `purple` at 500) used as the accent of a product whose charter does not list them; flag only when it is not the charter's choice;
+- `tic-unmodified-shadcn-tokens`: `--radius: 0.5rem` or `0.625rem` together with at least two of the stock shadcn colour values (e.g. `222.2 84% 4.9%`, `210 40% 96.1%`), i.e. the library defaults never replaced by the charter's tokens; flag only when the charter defines its own tokens and they are absent;
+- `tic-dark-glow`: on a dark page, a coloured `box-shadow` (channels more than 30 apart) with a blur above 4 px; check the contrast of the text it lies behind;
+- `tic-overused-font`: Inter, Roboto, Open Sans, Lato, Montserrat, Arial, Helvetica, Fraunces, Geist, Mona Sans, Plus Jakarta Sans, Space Grotesk, Recoleta or Instrument Sans/Serif as the primary face; flag only when it is not the charter's choice (a charter that uses Inter makes Inter correct);
+- `tic-marketing-buzzword`: stock marketing phrases in interface text ("streamline your", "seamless experience", "best-in-class", "cutting-edge", "unleash the power"…), against the Nielsen heuristic « match between the system and the real world »; the voice of the charter wins.
+
+Not kept from the 16 rules of `detect.mjs`, nine: `icon-tile-stack`, `hero-eyebrow-chip`, `repeated-section-kickers`, `uniform-low-opacity-shadow` (taste of composition, no named rule or measure behind them); `monotonous-spacing` (a single spacing scale is what a token system asks for, so the rule contradicts a charter); `em-dash-overuse`, `numbered-section-markers`, `aphoristic-cadence`, `theater-slop-phrase` (detectors of prose style, not of usability, and written for English marketing pages). The former rules `tic-violet-gradient`, `tic-side-border`, `tic-blur-panel`, `tic-glow-shadow` and `tic-bounce-easing`, which `detect.mjs` does not carry, were removed.
+
+On a product that has a charter, never propose, draw or blame a generic style from a catalogue; with no charter, follow the existing values and say so, and choose no style.

package/dist/cli.js

@@ -12,6 +12,7 @@ import { defaultTarget, effectLines, realCheckDeps, verifyCommand } from './veri
 import { verifyGate } from './verify-gate.js';
 import { ganttData, renderGantt } from './gantt.js';
 import { PLAN_ACTIONS, planCommitMessage } from './plan-commit.js';
+import { printUncommittedPlan } from './plan-uncommitted.js';
 import { dirtyPaths, gitRoot, isTracked, readCommits, matchesHead, resolveCommit, stage, stagedFiles, syncIndexWithHead } from './git.js';
 import { installHook, pendingCommitMessage, REFUSED } from './hook.js';
 import { gateRefusal, pushRefusal, UNGATED_ENV } from './push-guard.js';
@@ -31,6 +32,7 @@ import { INTEGRATION_LOCK } from './orchestrate/integrate.js';
 import { mainTreeWorkers } from './orchestrate/main-tree.js';
 import { cadenceHome, liveWaves, openLotsIn, openWavesIn, waveLotsIn } from './orchestrate/registry.js';
 import { blockingLots, LABEL, resumeCommand } from './orchestrate/table.js';
+import { renderTestsSansCode, testsSansCode } from './corrections-sans-code.js';
 import { bugCodeOf, bugCodePasses, classifyAll, classifySous, measure, ollamaClassifier, ollamaSousClassifier, readCache, readJournals, readRuns, readSousCache, renderReport, sampleKeys, serializeCache, serializeSousCache } from './corrections.js';
 import { computePerf, perfHeader, perfWindows, readPlans, readProjectDeliveries, readProjectFailedEntries, renderPerf } from './perf.js';
 import { findAcceptation, parseAcceptation, redAcceptations, resealAcceptation, resealForGreen, runAcceptation, setVert } from './orchestrate/accept.js';
@@ -478,9 +480,7 @@ function dispatch(argv, io) {
                 if (lot.visible && !loadEntries(newsDir).some((e) => e.lots.includes(lot.id))) {
                     io.out(`${lot.id} est visible : écrire l'entrée : cadence news new ${lot.id}`);
                 }
-                const uncommitted = uncommittedPlanCommand(plan, root, lot.id, planConfig?.commit);
-                if (uncommitted)
-                    io.out(uncommitted);
+                printUncommittedPlan(io.out, plan, root, lot.id, planConfig?.commit);
             }
             return 0;
         }
@@ -508,9 +508,7 @@ function dispatch(argv, io) {
             else if (!dry) {
                 if (plan.republishes)
                     io.err('raf: plan.onWrite republie le fichier du plan sans les lots archivés : le générateur de la copie publiée doit aussi lire .cadence/archive/*.yaml (clé `lots`), sinon l\'historique livré disparaît de la feuille de route publique');
-                const uncommitted = uncommittedPlanCommand(plan, root, moved[0].lot.id, planConfig?.commit, PLAN_ACTIONS.archived(moved.length));
-                if (uncommitted)
-                    io.out(uncommitted);
+                printUncommittedPlan(io.out, plan, root, moved[0].lot.id, planConfig?.commit, PLAN_ACTIONS.archived(moved.length));
             }
             return 0;
         }
@@ -617,7 +615,7 @@ function dispatch(argv, io) {
         }
         case 'ux':
         case 'review':
-            return gate(command, rest, loadPlan, root, today, io, !!values.verbose);
+            return gate(command, rest, loadPlan, root, today, io, { verbose: !!values.verbose, commit: planConfig?.commit });
         case 'commits': {
             need(1, 'commits <lot>');
             const plan = loadPlan();
@@ -867,11 +865,11 @@ function dispatch(argv, io) {
     }
 }
 const GATES = {
-    ux: { on: 'revue UX obligatoire pour les lots visibles', already: 'revue UX déjà active' },
-    review: { on: 'revue de code obligatoire pour les lots à commits', already: 'revue de code déjà active' },
+    ux: { on: 'revue UX obligatoire pour les lots visibles', already: 'revue UX déjà active', action: PLAN_ACTIONS.uxRecorded },
+    review: { on: 'revue de code obligatoire pour les lots à commits', already: 'revue de code déjà active', action: PLAN_ACTIONS.reviewRecorded },
 };
 /** « raf ux … » et « raf review … » ont la même forme : activer la porte, ou noter le verdict d'un lot. */
-function gate(kind, rest, loadPlan, root, today, io, verbose) {
+function gate(kind, rest, loadPlan, root, today, io, opts) {
     if (rest.length < 1)
         throw new RafError(`usage : raf ${kind} enable | ${kind} <lot> "verdict"`);
     const plan = loadPlan();
@@ -896,7 +894,9 @@ function gate(kind, rest, loadPlan, root, today, io, verbose) {
         plan.recordReview(rest[0], verdict, today, plan.readonly ? null : (lotWork(plan, root, rest[0])[0]?.sha ?? null), neighbours?.repos.length ? repoShas(plan, neighbours.repos, rest[0]) : undefined);
     }
     plan.save();
-    touchedLot(plan, rest[0], verbose, io);
+    touchedLot(plan, rest[0], opts.verbose, io);
+    // Comme `raf done` (L371) : le plan et la copie publiée que `plan.onWrite` vient de régénérer partent dans le même commit (L509).
+    printUncommittedPlan(io.out, plan, root, rest[0], opts.commit, GATES[kind].action);
     return 0;
 }
 /** Un titre de lot n'est jamais rendu en entier par défaut (L453) : ~300 caractères répétés à chaque commande, chaque commit de plan. */
@@ -915,23 +915,6 @@ function knownLot(plan, id, subtask) {
         throw new RafError(id.includes('/') ? `${subtask} : ${id}` : `lot inconnu : ${id}`);
     return lot;
 }
-/**
- * `raf done` écrit le plan et ne le commite 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}`;
-}
 function describe(l, commits) {
     const bits = [`${l.estimate} j`];
     if (commits)
@@ -1624,7 +1607,8 @@ async function corrections(rest, values, io) {
     }
     const m = measure(data, cache);
     const bugCode = bugCodeOf(bugCodePasses(data.passes, cache), sousCache);
-    io.out(values.json ? JSON.stringify(bugCode ? { ...m, bugCode } : m, null, 2) : renderReport(m, bugCode));
+    const sansCode = testsSansCode(data.passes);
+    io.out(values.json ? JSON.stringify({ ...m, testsSansCode: sansCode, ...(bugCode ? { bugCode } : {}) }, null, 2) : [renderReport(m, bugCode), ...renderTestsSansCode(sansCode)].join('\n'));
     return 0;
 }
 /**

package/dist/config.js

@@ -2,10 +2,12 @@ import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
 import { parse } from 'yaml';
 import { isDay } from './dates.js';
+import { readGate } from './gate-config.js';
 import { DEFAULT_TEST_PATTERNS } from './testgate.js';
 import { gitRoot } from './git.js';
 import { planCommitProblem } from './plan-commit.js';
-import { isComposedGate } from './orchestrate/workers.js';
+import { checkTestReplay, readGateTest } from './orchestrate/gate-parts.js';
+import { booleanKey } from './yaml-keys.js';
 import { FIELDS, Plan, RafError, STATUSES } from './plan.js';
 const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit'];
 const ON_WRITE_KEYS = ['command', 'files'];
@@ -311,7 +313,7 @@ export function readSessionConfig(file) {
     return config;
 }
 const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
-const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'fix', 'review', 'ux'];
+const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'probe', 'fix', 'review', 'ux'];
 /** Clé `verify:` de cadence.yaml. Absente : `{}`. */
 export function readVerifyConfig(file) {
     if (!existsSync(file))
@@ -338,10 +340,10 @@ export function readVerifyConfig(file) {
     return { inPlace: v.inPlace };
 }
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeDeps', 'gate', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'continue', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeDeps', 'gate', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'probe', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'continue', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
-    const config = { precheck: true, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, worktrees: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
+    const config = { precheck: true, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, worktrees: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', probe: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
     if (!existsSync(file))
         return config;
     let raw;
@@ -373,7 +375,9 @@ export function readOrchestrateConfig(file) {
             throw bad('accept : commande non vide attendue (chaîne ou liste de commandes non vides)');
         config.accept = o.accept.map((x) => x.trim());
     }
-    for (const k of ['start', 'verdict', 'test', 'testReplay', 'build', 'accept']) {
+    if (o.test != null)
+        config.test = readGateTest(o.test, bad);
+    for (const k of ['start', 'verdict', 'testReplay', 'build', 'accept']) {
         if (k === 'accept' && Array.isArray(o.accept))
             continue;
         if (o[k] == null)
@@ -382,31 +386,15 @@ export function readOrchestrateConfig(file) {
             throw bad(`${k} : commande non vide attendue`);
         config[k] = o[k].trim();
     }
-    if (config.testReplay && !config.testReplay.includes('{files}'))
-        throw bad('testReplay : la commande doit contenir {files} (remplacé par les fichiers des tests rouges)');
-    if (config.testReplay && config.test && isComposedGate(config.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');
+    checkTestReplay(config.test, config.testReplay, bad);
     if (o.worktreeDeps != null) {
         const deps = o.worktreeDeps;
         if (!Array.isArray(deps) || !deps.length || deps.some((x) => typeof x !== 'string' || !x.trim() || isAbsolute(x) || x.split(/[\\/]/).includes('..')))
             throw bad('worktreeDeps : liste de chemins relatifs au dépôt, sans « .. » (node_modules, .venv…)');
         config.worktreeDeps = deps.map((x) => x.trim().replace(/\/$/, ''));
     }
-    if (o.gate != null) {
-        if (!isObject(o.gate))
-            throw bad('gate : objet attendu (gate: { readsPlan: true })');
-        for (const k of Object.keys(o.gate))
-            if (k !== 'readsPlan')
-                throw bad(`gate.${k} inconnu (attendu : readsPlan)`);
-        const r = o.gate.readsPlan;
-        const msg = 'gate.readsPlan : true, false ou liste de chemins de tests relatifs au dépôt, sans « .. »';
-        if (r === true)
-            config.gate = { readsPlan: true };
-        else if (Array.isArray(r) && r.length && r.every((x) => typeof x === 'string' && x.trim() && !isAbsolute(x) && !x.split(/[\\/]/).includes('..')))
-            config.gate = { readsPlan: r.map((x) => x.trim()) };
-        else if (r !== false)
-            throw bad(msg);
-    }
+    if (o.gate != null)
+        config.gate = readGate(o.gate, bad);
     if (o.maquette != null) {
         if (typeof o.maquette !== 'boolean')
             throw bad('maquette : true ou false attendu');
@@ -417,11 +405,9 @@ export function readOrchestrateConfig(file) {
             throw bad('maquetteReviews : entier supérieur ou égal à 1 attendu');
         config.maquetteReviews = o.maquetteReviews;
     }
-    if (o.fiche != null) {
-        if (typeof o.fiche !== 'boolean')
-            throw bad('fiche : true ou false attendu');
-        config.fiche = o.fiche;
-    }
+    for (const k of ['fiche', 'probe'])
+        if (o[k] != null)
+            config[k] = booleanKey(o[k], bad(`${k} : true ou false attendu`));
     if (o.precheck != null) {
         if (typeof o.precheck !== 'boolean' && o.precheck !== 'local')
             throw bad('precheck : true, false ou local attendu');
@@ -534,7 +520,7 @@ export function readOrchestrateConfig(file) {
     }
     if (o.effort != null) {
         if (!isObject(o.effort))
-            throw bad('effort doit être un objet { precheck, spec, maquette, fiche, accept, implement, fix, review, ux }');
+            throw bad('effort doit être un objet { precheck, spec, maquette, fiche, accept, implement, probe, fix, review, ux }');
         for (const [k, v] of Object.entries(o.effort)) {
             if (!EFFORT_STEPS.includes(k))
                 throw bad(`effort.${k} inconnu (attendu : ${EFFORT_STEPS.join(', ')})`);

package/dist/corrections-sans-code.js

@@ -0,0 +1,12 @@
+// Les passes lancées sur des tests rouges et terminées sans changement de code (L510) : la part des corrections que la porte a demandées pour rien.
+export function testsSansCode(passes) {
+    const onTests = passes.filter((p) => p.findings.length === 0);
+    return { passes: onTests.length, sansCode: onTests.filter((p) => p.commits.length === 0).length };
+}
+const plural = (n, one, many) => `${n} ${n < 2 ? one : many}`;
+/** La ligne du rapport lisible, vide sans passe de ce genre. À part de `renderReport` : le relevé de référence du 10-10 reproduit ce rapport mot pour mot. */
+export function renderTestsSansCode(t) {
+    if (t.passes === 0)
+        return [];
+    return [`${plural(t.passes, 'passe lancée', 'passes lancées')} sur des tests, ${plural(t.sansCode, 'terminée', 'terminées')} sans changement de code (${Math.round((100 * t.sansCode) / t.passes)} %, passes sans commit).`, ''];
+}

package/dist/corrections.js

@@ -99,11 +99,10 @@ export function readJournals(runsDir, until, since) {
             const name = basename(file, '.json');
             const fixSteps = steps.filter((s) => s.kind === 'fix' && done(s));
             const passes = fixSteps.map((fix) => {
-                const review = [...steps].reverse().find((s) => s.n < fix.n && isReview(s.kind) && s.report);
-                // Une passe fix entre la revue et celle-ci a déjà traité ces constats : cette passe-ci (tests rouges) n'en a pas.
-                const handled = review ? fixSteps.some((f) => f.n > review.n && f.n < fix.n) : false;
-                const findings = review?.report && !handled ? findingsOf(readJson(join(waveDir, name, review.report))) : [];
-                return { key: `${wave}/${name}/${fix.n}`, project: rec.project, lot: rec.lot, visible: !!rec.visible, findings, commits: fix.commits ?? [], ...(fix.ended ? { fixEnded: fix.ended } : {}), ...(findings.length > 0 && review ? { reviewKind: review.kind } : {}) };
+                const review = [...steps].reverse().find((s) => s.n < fix.n && ((isReview(s.kind) && s.report) || (s.kind === 'probe' && Array.isArray(s.constats) && s.constats.length > 0)));
+                // La revue (ou la sonde, L497, qui porte ses constats dans son étape) qui précède. Une passe fix entre elle et celle-ci a déjà traité ces constats : cette passe-ci (tests rouges) n'en a pas.
+                const findings = !review || fixSteps.some((f) => f.n > review.n && f.n < fix.n) ? [] : review.kind === 'probe' ? review.constats.filter((t) => typeof t === 'string') : review.report ? findingsOf(readJson(join(waveDir, name, review.report))) : [];
+                return { key: `${wave}/${name}/${fix.n}`, project: rec.project, lot: rec.lot, visible: !!rec.visible, findings, commits: fix.commits ?? [], ...(fix.ended ? { fixEnded: fix.ended } : {}), ...(findings.length > 0 && review && review.kind !== 'probe' ? { reviewKind: review.kind } : {}) };
             });
             const precheck = precheckVerdictOf(rec, steps);
             const esc = rec.escalation;

package/dist/deliver.js

@@ -557,8 +557,8 @@ function deliveredLots(ctx, ids, prev, sha) {
 }
 /**
  * Livraison verte (L144) : les lots livrés dont le titre est public changent ce que les articles externes racontent, on ouvre
- * donc le lot qui les rafraîchit. Hors vague le plan est écrit mais pas commité ; pendant une vague (L388) il est commité avec les fichiers que produit `plan.onWrite`, avec
- * le gabarit `plan.commit`, pour ne pas laisser le plan modifié dans l'arbre où une session de la vague travaille — sauf si le plan ou ces fichiers l'étaient
+ * donc le lot qui les rafraîchit. Le plan est commité (L388 pendant une vague, L420 aussi hors vague : le livreur lancé à la main le laissait modifié) avec les fichiers que produit `plan.onWrite`, avec
+ * le gabarit `plan.commit` (sans la vague hors vague), pour ne pas laisser le plan modifié dans l'arbre — sauf si le plan ou ces fichiers l'étaient
  * déjà avant l'écriture (le lead y a des modifications que ce commit emporterait). Une erreur ici ne défait pas une livraison déjà faite.
  */
 function refreshArticles(ctx, ids, sha) {
@@ -586,10 +586,10 @@ function refreshArticles(ctx, ids, sha) {
             plan.save();
         const touched = [...r.opened, ...r.noted];
         let state = 'plan modifié, à commiter';
-        if (touched.length && ctx.duringWave && wasDirty) {
+        if (touched.length && wasDirty) {
             state = 'plan déjà modifié avant la livraison, non commité : à commiter avec vos modifications';
         }
-        else if (touched.length && ctx.duringWave) {
+        else if (touched.length) {
             const message = planCommitMessage(ctx.planCommit, { lot: touched.join(', '), action: r.opened.length ? PLAN_ACTIONS.articleOpened : PLAN_ACTIONS.articleNoted, wave: ctx.waveId });
             try {
                 state = `plan commité ${commitPaths(ctx.root, [planFile, ...dirtyPaths(ctx.root, plan.produced)], message)}`;

package/dist/gate-config.js

@@ -0,0 +1,47 @@
+import { isAbsolute } from 'node:path';
+/** Un chemin de test relatif au dépôt, sans « .. » (`gate.readsPlan`). */
+const relativeTest = (x) => typeof x === 'string' && !!x.trim() && !isAbsolute(x) && !x.split(/[\\/]/).includes('..');
+/** `gate.readsPlan` : true, une liste de chemins de tests, false ou absent (rien d'actif). */
+function readsPlanOf(r, bad, others) {
+    if (r === true)
+        return true;
+    if (Array.isArray(r) && r.length && r.every(relativeTest))
+        return r.map((x) => x.trim());
+    // Sans `host` ni `install`, `gate: {}` ne déclare rien : refusé comme avant.
+    if (r === false || (r == null && others))
+        return undefined;
+    throw bad('gate.readsPlan : true, false ou liste de chemins de tests relatifs au dépôt, sans « .. »');
+}
+/** `gate.host` : une destination ssh, sans espace ; une qui commencerait par « - » serait lue par ssh comme une option (-oProxyCommand=…). */
+function hostOf(v, bad) {
+    const h = typeof v === 'string' ? v.trim() : '';
+    if (!h || /\s/.test(h) || h.startsWith('-'))
+        throw bad('gate.host : destination ssh attendue (une chaîne sans espace, ne commençant pas par « - »)');
+    return h;
+}
+/** `gate.install` : une commande non vide. */
+function installOf(v, bad) {
+    if (typeof v !== 'string' || !v.trim())
+        throw bad('gate.install : commande non vide attendue');
+    return v.trim();
+}
+/**
+ * Clé `orchestrate.gate` de cadence.yaml : `readsPlan` (L450), `host` et `install` (L403). Rend undefined quand elle ne déclare rien d'actif (`readsPlan: false` seul) ;
+ * `host` ou `install` seuls posent la clé sans `readsPlan` : déclarer l'hôte ne vaut pas déclarer que des tests lisent le plan (R11).
+ * `bad` fabrique l'erreur de config préfixée (`cadence.yaml : orchestrate.<what>`).
+ */
+export function readGate(raw, bad) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        throw bad('gate : objet attendu (gate: { readsPlan: true })');
+    const o = raw;
+    for (const k of Object.keys(o))
+        if (!['readsPlan', 'host', 'install'].includes(k))
+            throw bad(`gate.${k} inconnu (attendu : readsPlan, host, install)`);
+    const readsPlan = readsPlanOf(o.readsPlan, bad, o.host != null || o.install != null);
+    const gate = {
+        ...(readsPlan ? { readsPlan } : {}),
+        ...(o.host != null ? { host: hostOf(o.host, bad) } : {}),
+        ...(o.install != null ? { install: installOf(o.install, bad) } : {}),
+    };
+    return Object.keys(gate).length ? gate : undefined;
+}

package/dist/orchestrate/accept.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, posix } from 'node:path';
 import { parse } from 'yaml';
 import { citedRefs } from '../link.js';
+import { isParts } from './gate-parts.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function git(repo, ...args) {
     return execFileSync('git', args, { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 });
@@ -461,6 +462,8 @@ export function planAcceptRuns(commands, fichiers, single = false) {
     return { runs: all.filter((r) => fichiers.some((f) => underRoot(f, r.root))), orphans: fichiers.filter((f) => !all.some((r) => underRoot(f, r.root))) };
 }
 /** Consigne propre à l'étape accept dans le brief : fiche, maquette, commande dédiée, gabarit du lanceur, et les écarts de la passe précédente. */
+/** La commande ordinaire du projet dans le prompt de la session accept : une chaîne telle quelle, une porte en parties (L512) partie par partie avec son dossier. */
+const ordinaryText = (t) => (!t ? '' : isParts(t) ? ` The project's ordinary test commands, one per folder, are ${t.map((p) => `\`${p.run}\` (in \`${p.dir}/\`)`).join(', ')}: they must stay green with your red tests committed.` : ` The project's ordinary test command is \`${t}\`: it must stay green with your red tests committed.`);
 export function acceptText(o) {
     const commands = acceptCommands(o.command);
     const screen = o.screen !== false;
@@ -469,8 +472,8 @@ export function acceptText(o) {
             ? `Sheet: \`${o.fiche}\` (cases, rules, contracts, data). You get nothing else about the behaviour: the implementation does not exist yet.`
             : `Sheet: \`${o.fiche}\` (rules, fields, actions). Mockup: \`${o.maquette}\` (every field carries \`data-testid="<field id>"\`). You get nothing else about the screen: the implementation does not exist yet.${o.back ? ' The sheet also has a back part (`cas`, `contrats`, `donnees`): write the cases of its rules too, calling the contracts of `contrats[]` as close as possible and simulating the external sources from `entree`.' : ''}`,
         isAcceptList(o.command)
-            ? `The project declares several dedicated commands (\`orchestrate.accept\`, one per test runner), each of which runs ONLY the acceptance tests of this lot that sit under its root (the folder of its leading \`cd <folder> &&\`, else the repository): ${commands.map((x) => `\`${x}\` (root \`${acceptRoot(x) || '.'}\`)`).join(', ')}. Each is run from the repository root and gets \`CADENCE_ACCEPTATION\` (the absolute path of the lot's \`acceptation.json\`, also substituted for \`{acceptation}\`) and \`CADENCE_ACCEPTATION_ROOT\` (its root); it takes only the files listed under its root, a command with no listed file under its root is not run, and a listed file under no root is refused. Put each test file where its runner looks, and list every file in \`fichiers\`.${o.test ? ` The project's ordinary test command is \`${o.test}\`: it must stay green with your red tests committed.` : ''}`
-            : `The project declares the dedicated command that runs ONLY the acceptance tests of this lot (\`orchestrate.accept\`): \`${commands[0]}\` (from the repository root; the program sets \`CADENCE_ACCEPTATION\` to the absolute path of the lot's \`acceptation.json\`, and replaces \`{acceptation}\` with it).${o.test ? ` The project's ordinary test command is \`${o.test}\`: it must stay green with your red tests committed.` : ''}`,
+            ? `The project declares several dedicated commands (\`orchestrate.accept\`, one per test runner), each of which runs ONLY the acceptance tests of this lot that sit under its root (the folder of its leading \`cd <folder> &&\`, else the repository): ${commands.map((x) => `\`${x}\` (root \`${acceptRoot(x) || '.'}\`)`).join(', ')}. Each is run from the repository root and gets \`CADENCE_ACCEPTATION\` (the absolute path of the lot's \`acceptation.json\`, also substituted for \`{acceptation}\`) and \`CADENCE_ACCEPTATION_ROOT\` (its root); it takes only the files listed under its root, a command with no listed file under its root is not run, and a listed file under no root is refused. Put each test file where its runner looks, and list every file in \`fichiers\`.${ordinaryText(o.test)}`
+            : `The project declares the dedicated command that runs ONLY the acceptance tests of this lot (\`orchestrate.accept\`): \`${commands[0]}\` (from the repository root; the program sets \`CADENCE_ACCEPTATION\` to the absolute path of the lot's \`acceptation.json\`, and replaces \`{acceptation}\` with it).${ordinaryText(o.test)}`,
         `If \`${o.acceptation}\` already exists with \`vert: true\` and \`empreintes\`, the lot's oracle is green and sealed: never rewrite it, nor its tests, \`resceaux\` or \`empreintes\`, and never set \`vert\` (a corrected test is resealed by the lead, \`cadence spec reseal\`). Write nothing, commit nothing, and hand the lot back with that finding in \`questions\`. A \`vert: true\` file WITHOUT \`empreintes\` (or whose \`empreintes\` lack one of the listed test files) was never sealed by the program (only the cycle sets \`vert\`, after the seal): it proves nothing, so write the oracle as described below, with \`vert: false\`.`,
         `Write \`${o.acceptation}\` (one file per lot, next to the sheet: another lot on the same ${screen ? 'screen' : 'subject'} has its own, which you never touch, nor its tests — give your test files names of your own): \`{ "lot": "<lot>", "fiche": "${o.fiche}", "fichiers": ["<test file>", …], "vert": false }\` (paths relative to the repository). If the tests need a build or a browser (Playwright, Chromium, \`dist\`), add \`"e2e": true\` to it: those files then stay out of the ordinary runner and the unit CI even once green (they would turn it red without \`dist\` or Chromium) and belong to the project's e2e suite, run after the build (\`acceptationE2e()\` of the runner template lists them). The ordinary test config of the project (shared with its CI) must exclude those files while \`vert\` is false; the dedicated config includes only them. Both read the file with this runner template (copy it into the project, e.g. \`tests/acceptation-runner.mjs\`):`,
     ];

package/dist/orchestrate/baseline.js

@@ -61,6 +61,63 @@ export function unloadedSuites(output) {
     }
     return [...found].sort();
 }
+/** Le délai d'un test expiré : vitest « Test timed out in 30000ms », jest « Exceeded timeout of 5000 ms for a test ». */
+const SUMMARY = /^\s*(?:Test Files?|Tests?)\s+\d/;
+const TIMEOUT = /(?:timed out in|Exceeded timeout of)\s+(\d+)\s*ms/i;
+/**
+ * Le délai (ms) de chaque test qui a expiré dans la sortie d'un lanceur (L510) : le message d'expiration est lu sous le dernier test nommé rouge qui le précède, avec le nom que donne `failedTests`.
+ * Un message sans test nommé avant lui ne désigne rien et n'est pas retenu.
+ */
+export function timeoutLimits(output) {
+    const limits = new Map();
+    let current = null;
+    for (const raw of stripAnsi(output).split('\n')) {
+        if (FILE_LOAD_FAIL.test(raw))
+            continue;
+        current = namedFailure(raw, current);
+        const t = TIMEOUT.exec(raw);
+        if (t && current)
+            limits.set(current, Number(t[1]));
+    }
+    return limits;
+}
+/** Le test rouge qu'une ligne nomme, null quand elle ouvre un résumé de fin ou un nom vide, `current` quand elle n'en nomme aucun. */
+function namedFailure(raw, current) {
+    if (SUMMARY.test(raw))
+        return null;
+    for (const re of MARKERS) {
+        const m = re.exec(raw);
+        if (!m)
+            continue;
+        const name = clean(m[1]);
+        return name && !/^(?:Test Files?|Tests?)\b/.test(name) ? name : null;
+    }
+    return current;
+}
+/**
+ * La durée (ms) que la sortie d'un rejeu donne au test `name` du fichier `file` : la ligne du test (son dernier segment « suite > test » ou « Suite › test ») qui finit par une durée, sinon la ligne ✓ du fichier (« ✓ a.test.ts (3 tests) 24s »,
+ * une borne haute pour le test). Null quand aucune durée ne se lit.
+ */
+export function testDurationMs(output, name, file) {
+    const leaf = name.split(/ > | › /).pop().trim();
+    const lines = stripAnsi(output).split('\n');
+    const byTest = leaf ? lines.find((l) => lineDurationMs(l) !== null && endsWithName(l, leaf)) : undefined;
+    if (byTest)
+        return lineDurationMs(byTest);
+    const byFile = lines.find((l) => /^\s*[✓√]/.test(l) && l.includes(file) && lineDurationMs(l) !== null);
+    return byFile ? lineDurationMs(byFile) : null;
+}
+const DURATION_END = /\s*\(?(\d+(?:\.\d+)?)\s*(ms|s)\)?\s*$/;
+/** La durée (ms) qui finit une ligne de lanceur, null sans durée. */
+function lineDurationMs(l) {
+    const m = DURATION_END.exec(l);
+    return m ? Math.round(Number(m[1]) * (m[2] === 's' ? 1000 : 1)) : null;
+}
+/** La ligne finit par `leaf` (puis sa durée), au début d'un mot : un nom qui n'est que le sous-texte d'un voisin (« plan » / « plan-data ») ne la désigne pas. */
+function endsWithName(l, leaf) {
+    const bare = l.replace(DURATION_END, '').trimEnd();
+    return bare.endsWith(leaf) && (bare.length === leaf.length || /[\s>›]/.test(bare[bare.length - leaf.length - 1]));
+}
 /** Sortie sans les séquences de couleur du lanceur. */
 export const stripAnsi = (s) => s.replace(ANSI, '');
 /**

package/dist/orchestrate/briefs.js

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+import { isParts } from './gate-parts.js';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { RafError } from '../plan.js';
@@ -90,6 +91,7 @@ const FILES = {
     accept: 'accept.md',
     maquette: 'maquette.md',
     implement: 'implement.md',
+    probe: 'probe.md',
     fix: 'fix.md',
     'fix-minors': 'fix-minors.md',
     'fix-docs': 'fix-docs.md',
@@ -132,7 +134,9 @@ export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
  * alors que la porte joue `npx tsc --noEmit` (test et scripts compris) : L330, L353. Vide sans commande déclarée.
  */
 export function gateText(gate) {
-    const lines = [gate.test ? `- tests: \`${gate.test}\`` : '', gate.build ? `- build: \`${gate.build}\`` : ''].filter(Boolean);
+    // Porte en parties (L512) : une ligne par partie, avec son dossier, jamais la liste sérialisée.
+    const tests = !gate.test ? [] : isParts(gate.test) ? gate.test.map((p) => `- tests (run in \`${p.dir}/\`): \`${p.run}\``) : [`- tests: \`${gate.test}\``];
+    const lines = [...tests, gate.build ? `- build: \`${gate.build}\`` : ''].filter(Boolean);
     if (!lines.length)
         return '';
     return `The program's gate, played after every writing session, is exactly:\n${lines.join('\n')}\nRun these commands as written before reporting, not a narrower one (\`npm run build\` or \`npm test\` may cover less than the gate). A red there sends the lot back to a correction pass even when your own run was green.`;