@sylad/cadence 1.34.1 → 1.36.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.34.1",
+      "version": "1.36.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.34.1",
+  "version": "1.36.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

@@ -49,7 +49,7 @@ Details: [docs/skills.md](docs/skills.md) and [docs/cadence-hud.md](docs/cadence
 
 - [docs/raf.md](docs/raf.md): the plan, its commands and its file.
 - [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/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,11 @@ 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'];
@@ -374,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)
@@ -383,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');

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/deliver-ci.js

@@ -0,0 +1,105 @@
+import { basename } from 'node:path';
+import { isPlanOnly } from './audit.js';
+import { isAncestor, readCommits } from './git.js';
+import { appendStep, lastDelivery } from './state.js';
+const POLL_CI = 15_000;
+const CI_APPEAR = 300_000;
+const CI_OK = new Set(['success', 'skipped', 'neutral']);
+/** « HH:MM:SS » UTC d'un instant en millisecondes : l'heure qui ouvre chaque ligne d'étape de la sortie. */
+const clockTime = (ms) => new Date(ms).toISOString().slice(11, 19);
+export const stamped = (deps, line) => `${clockTime(deps.now())} ${line}`;
+/**
+ * Livraison précédente quand la CI du sha n'a pas à être attendue : un seul fichier hors plan dans précédente..sha suffit à
+ * l'exiger. Null (CI attendue) sans plan, sans livraison précédente, si elle n'est pas un ancêtre du sha ou l'égale, si elle n'est pas un sha complet (ligne du journal écrite à la main), si la
+ * lecture échoue ou rend aucun commit : on ne saute la CI que sur une preuve (au moins un commit, tous plan seul).
+ */
+export function planOnlySince(ctx, sha) {
+    if (!ctx.plan)
+        return null;
+    const prev = lastDelivery(ctx.state);
+    if (!prev || !/^[0-9a-f]{40,64}$/.test(prev) || prev === sha || !isAncestor(ctx.root, prev, sha))
+        return null;
+    try {
+        const commits = readCommits(ctx.root, { range: `${prev}..${sha}` });
+        return commits.length > 0 && commits.every((c) => isPlanOnly(c.sha, ctx.plan, ctx.root)) ? prev : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Un tour de `gh run list` : message d'échec, null si tous les runs sont verts, undefined tant qu'il faut attendre. */
+function pollOnce(ctx, deps, sha, start, state) {
+    let runs = [];
+    let error = null;
+    try {
+        runs = deps.gh(sha);
+        state.failingSince = null;
+    }
+    catch (e) {
+        // Erreur passagère (réseau, quota d'API) : on réessaie ; persistante, on abandonne avec sa cause.
+        error = e.message;
+        state.failingSince ??= deps.now();
+    }
+    const elapsed = deps.now() - start;
+    if (error !== null) {
+        if (deps.now() - state.failingSince >= CI_APPEAR || elapsed >= ctx.config.ciTimeout * 1000)
+            return `gh run list en échec : ${error}`;
+        ctx.err(`  gh run list en échec, nouvel essai : ${error}`);
+        return undefined;
+    }
+    if (runs.length === 0) {
+        return elapsed >= CI_APPEAR ? `aucun run CI pour ce sha après ${CI_APPEAR / 60_000} min (le commit poussé est-il celui que la CI construit ?)` : undefined;
+    }
+    const pending = runs.filter((r) => r.status !== 'completed');
+    const summary = `${runs.length} run(s), ${runs.length - pending.length} terminé(s)`;
+    if (summary !== state.summary)
+        ctx.out(`  ${summary}`);
+    state.summary = summary;
+    if (pending.length > 0)
+        return undefined;
+    const bad = runs.filter((r) => !CI_OK.has(r.conclusion));
+    return bad.length ? `CI en échec : ${bad.map((r) => `${r.name} (${r.conclusion})`).join(', ')}` : null;
+}
+/** Message d'échec, ou null quand les runs GitHub du sha sont tous verts. */
+export async function pollGithubCi(ctx, deps, sha) {
+    const { ciTimeout } = ctx.config;
+    ctx.out(stamped(deps, `→ CI : attente des runs GitHub de ${sha.slice(0, 7)}`));
+    const start = deps.now();
+    const state = { summary: '', failingSince: null };
+    for (;;) {
+        const verdict = pollOnce(ctx, deps, sha, start, state);
+        if (verdict !== undefined)
+            return verdict;
+        if (deps.now() - start >= ciTimeout * 1000)
+            return `CI non terminée après ${ciTimeout} s`;
+        await deps.sleep(POLL_CI);
+    }
+}
+/**
+ * Journal des étapes (L516) : `step(etape, debut, ok)` ajoute une ligne à `deliveries-steps.log`. Une mesure, jamais bloquante :
+ * une écriture qui échoue est signalée une seule fois, la livraison continue. `lots` n'est lu qu'à la première écriture.
+ */
+export function stepJournal(ctx, deps, sha, lots) {
+    let known = null;
+    let warned = false;
+    return (etape, debut, ok) => {
+        try {
+            const fin = deps.now();
+            appendStep(ctx.state, {
+                lots: (known ??= lots()),
+                sha,
+                projet: ctx.plan?.project || basename(ctx.root),
+                etape,
+                debut: new Date(debut).toISOString(),
+                fin: new Date(fin).toISOString(),
+                duree_s: Math.round((fin - debut) / 1000),
+                resultat: ok ? 'ok' : 'echec',
+            });
+        }
+        catch (e) {
+            if (!warned)
+                ctx.err(`deliver : journal des étapes non écrit : ${e.message}`);
+            warned = true;
+        }
+    };
+}