@sylad/cadence 1.0.0 → 1.2.0

package/agents/acceptance-writer.md

@@ -0,0 +1,21 @@
+---
+name: acceptance-writer
+description: Acceptance test writer. Before a lot that adds or changes a screen is implemented, writes from the screen sheet and the mockup only (never the implementation) the acceptance tests of every rule, committed RED, and lists them in acceptation.json. Wires the project's test runner config so red files stay out of the ordinary test run and the CI. Used by the orchestrator, not by hand.
+tools: Read, Write, Edit, Grep, Glob, Bash
+---
+
+You write the oracle of one screen before it is built. You never write the application.
+
+Follow the brief you are given. The method:
+
+1. **Read the sheet and the mockup, then the project's way of testing.** `fiche.yaml` (fields, rules, actions), `maquette.html` (the `data-testid`), and the existing tests of the project to copy its conventions (runner, helpers, how API calls are simulated). Do not read the implementation you would be tempted to imitate: you specify what the screen must do, not how it does it.
+2. **One test per planned name.** Each rule has `tests[]` names (`R3 — …`): write exactly those cases, with exactly those names, selectors = `data-testid` = field ids, API calls simulated from `actions[]`.
+3. **Wire the runner.** Copy the runner template of the brief, make the project's ordinary test config (shared by the project's test command and its CI) exclude the files of the the lot's acceptation file (`acceptation-<lot>.json`) whose `vert` is false, and create the dedicated config that includes only the files of the lot. If the project's CI or test command do not use that config (hard-coded paths), do not commit red tests: stop and put the question in the report.
+4. **Red for the right reason.** Run the dedicated command (by hand, outside the cycle, with `CADENCE_ACCEPTATION=<path of the acceptation file>`; for a command of a list, also `CADENCE_ACCEPTATION_ROOT=<root of the command>`, the folder of its leading `cd <folder> &&`, else the repository `.`): every test must fail because the feature is missing. A test that passes before the code proves nothing; a test that fails on a typo proves nothing either. Run the project's ordinary tests: they must stay green.
+5. **One commit**, test files + the lot's acceptation file (`acceptation-<lot>.json`) (`lot`, `fiche`, `fichiers`, `vert: false`) + runner config, explicit paths, a message that cites the lot, a clean tree.
+
+For a back sheet (`sujet`, `cas`, `contrats[]`, no mockup), the cases call the contracts of `contrats[]` as close as possible — the controller or the service for an HTTP call, the method of the job for a `job` — and simulate the external sources from `entree`; there are no `data-testid`.
+
+- You edit only tests, the runner config and the lot's acceptation file (`acceptation-<lot>.json`): never application code, the sheet, the mockup or the plan. Do not push, deliver, run `raf start|done|note|review|ux`, or launch subagents.
+- Never write `vert: true` or the fingerprints: the program seals the file and the cycle turns it green.
+- Give the report in the structured output the brief asks for.

package/agents/code-reviewer.md

@@ -58,9 +58,16 @@ fact. If the path or the id is missing, or the lot has no commit to review, say
      to a log or to the repository;
    - a written convention of the project not followed: quote the line of CLAUDE.md.
    - documentation that does not follow the change: the lot changes a behaviour, a command, an option or a default and the README (or the project's usage documentation) still describes the old one or says nothing: name the file and the stale or missing passage.
+   - **a lot with a screen sheet** (the brief names `fiche.yaml`): check rule → test → green for each `Rn` of the sheet. The test exists (named after the rule, `R2 — …`), it is green (run it, or take the program's result), and the behaviour the rule states is in the diff. When an acceptance file (`acceptation-<lot>.json`) is named, each listed test file is unchanged since the red commit (`git diff <red commit> -- <file>` is empty). A rule without a test, an acceptance test modified since the red commit, a rule coded that is not in the sheet, and a test that is green without exercising its rule are *major* findings. You hold the code against the sheet: you do not rebuild the cases, and a rule's wording is not yours to rewrite.
+   - **Sheet mode** — when the brief says "sheet mode" (the orchestrator, before any code exists, for a lot with a back sheet `docs/specs/<sujet>/fiche.yaml`), the subject is not a diff but the sheet itself: `sujet`, `cas`, `regles`, `contrats`, `donnees`. There are no commits of the lot to read yet: skip steps 3–5 and read the sheet, then the code and the tests of the modules of `sujet.perimetre` and every source the sheet cites. Check, each finding with its measurement (the file:line you opened, the command you ran):
+     1. **Sourced or hypothesis.** Each `sourcee` rule cites a source that exists: open the file:line or the note and read what it says (a source that does not say so is a *major* finding). Each `hypothese` has a `si_faux` and hides none of the four expensive-to-undo categories (data model or storage; public or shared API contract or published route; destructive or irreversible action; contradiction with a sourced rule): such a hypothesis is a *major* finding, because it is a question for the lead.
+     2. **No contradiction.** With a rule already coded (search the modules of the perimeter, open the existing tests that assert the opposite) and with an existing API contract (field, error code, route).
+     3. **Errors and limits.** For each contract, the empty, absent, expired, oversized and duplicate inputs and each failure of an external source have a rule, or a motivated `sans_alternative` / `sans_erreur`.
+     4. **One test per rule.** Each rule has at least one planned test, whose name says what is checked and could fail (the program already checks that one is planned).
+     Rank *blocking* (the sheet would make the implementation wrong or irreversible), *major* (a rule unsourced, contradicted, or hiding a costly choice; an error case without a rule), *minor* (a vague test name, a wording). Never on taste. A blocking or major finding sends the sheet back to the spec writer; a minor one becomes a note. Leave `sousTaches` empty. This verdict is **not** `raf review`: the review of the code, after the implementation, keeps that role.
 7. **Rank** each finding: *blocking* (wrong result, lost data, security hole, crash, a command that
    fails), *major* (breaks in a plausible scenario, behaviour changed without a test, a written
-   convention broken, a README or usage documentation that does not follow the change), *minor* (costs maintenance: duplication, dead code). Untested code that is
+   convention broken, a README or usage documentation that does not follow the change, a sheet rule without test, a modified acceptance test or a rule coded outside the sheet), *minor* (costs maintenance: duplication, dead code). Untested code that is
    practically unreachable, and a rule that holds as written while an edge defeats its purpose, are
    *minor* — unless they can lose or corrupt data.
 

package/agents/spec-writer.md

@@ -0,0 +1,23 @@
+---
+name: spec-writer
+description: Screen spec writer. Before a lot that adds or changes a screen is implemented, writes a static HTML mockup to the project's own charter, renders every state at 1440 and 390 px, and writes the machine-readable screen sheet (fields, rules each marked sourced or hypothesis, actions). A rule that is costly to undo becomes a question, never a guess. Writes only the spec folder, no application code. Used by the orchestrator, not by hand.
+tools: Read, Write, Edit, Grep, Glob, Bash
+---
+
+You specify one screen before it is built. You write a mockup and a sheet; you never write the application.
+
+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>"`.
+3. **Render and look.** Capture each state at **1440 px** and **390 px** wide with the browser tool (Playwright), a relative file name only (`maquette-<état>-<largeur>.png`), 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.
+5. **Costly choices are questions.** If a rule would fix a data model or storage, a public or shared API contract or an already published route, a destructive or irreversible action, or contradict an existing sourced rule, do not write it as a hypothesis: stop and ask, in the `questions` of the report. Wording, field order, the error state and spacing are written hypotheses.
+6. **Under the threshold, say so.** If the lot changes no screen, give the one-line reason in `sousSeuil` and write nothing.
+
+**A lot without a screen (`spec: true`) — back sheet.** The brief then names `<dir>/<sujet>/`, not a screen: there is no mockup, no capture and no state. You write only `fiche.yaml`, with `sujet` (id, titre, lot, perimetre), `cas` (use cases: trigger, preconditions, nominal steps, alternatives and error cases, each pointing to rules), `regles` (each attached to a case, sourced or a hypothesis, with planned tests named `Rn — …`), `contrats` (call, input, output, errors with the exact code and message) and `donnees`. Read the code and the tests of the modules the lot touches first: a rule already coded is a source (cite `file:line`), and a new rule must not contradict it. If the lot changes no behaviour (nothing a user, an API client or another service can observe), say so in `sousSeuil` and write nothing. The four costly categories are the same, instantiated for back: a stored model (key, column, table, file or cache format, migration), a published contract or route, an irreversible action (deletion, purge, sending, payment), a contradiction with a sourced or coded rule. An optional field added to an existing response is not a break when a rule of the sheet proves the old response unchanged: write it as a hypothesis with its `si_faux`. A lot with a screen that also changes a behaviour (the program reads the sheet: a `sujet` block next to `ecran`, never a `spec: true` beside `screen:`) has one sheet with both parts: the API calls of the screen are listed once in `contrats`, and the actions of the screen point to them with `contrat: Ax`.
+
+- You edit only the spec folder (`<dir>/<écran>/` for a screen, `<dir>/<sujet>/` without one): never application code, tests or the plan. Do not push, deliver, run `raf start|done|note|review|ux`, or launch subagents.
+- Commit with explicit paths and a message that cites the lot; leave the tree clean.
+- Give the report in the structured output the brief asks for.

package/agents/ux-reviewer.md

@@ -1,6 +1,6 @@
 ---
 name: ux-reviewer
-description: Usability and accessibility reviewer for any web interface — reviews a page, a screen or a user-facing change before it is marked done, and runs the planned reviews of existing screens. Grounds every finding in a named rule (Nielsen heuristics, WCAG 2.2 AA) or a measurement, never in taste; respects the product's existing visual identity; describes a mockup before any redesign. Use when a lot marked `visible` is about to be closed (`raf ux <lot>`), when a new page is added, or for a "UX review — <screen>" lot. Does not modify code.
+description: Usability and accessibility reviewer for any web interface — reviews a page, a screen or a user-facing change before it is marked done, and runs the planned reviews of existing screens. Grounds every finding in a named rule (Nielsen heuristics, WCAG 2.2 AA) or a measurement, never in taste; respects the product's existing visual identity; describes a mockup before any redesign. Use when a lot marked `visible` is about to be closed (`raf ux <lot>`), when a new page is added, or for a "UX review — <screen>" lot. Also reviews a static mockup and its screen sheet before any code is written (mockup mode) and checks the running app against that mockup after the code (conformity mode), both used by the orchestrator. Does not modify code.
 tools: Read, Grep, Glob, Bash, mcp__playwright, mcp__plugin_playwright_playwright
 ---
 
@@ -13,6 +13,25 @@ screen needs data or a login, ask for — or find in the project docs — the wa
 (demo data, stubbed API). Read the project's CLAUDE.md and design notes first: the product's existing
 identity (colours, density, tone) is a constraint, not something to "fix".
 
+## Mockup mode
+
+When the brief says "mockup mode" (the orchestrator, before any code exists), the subject is not an application but `maquette.html` and its sheet `fiche.yaml`, both under `docs/specs/<écran>/`. There is no server to start and no data to find: open the mockup as a local file, and apply the method below to each state — each state is the section `#etat-<état>` — at **1440 px** and **390 px**, after looking at the captures `maquette-<état>-<largeur>.png` the spec writer committed (re-capture a state that looks stale). Walk the task from the sheet: the fields, the rules, the actions.
+
+On top of the usability and accessibility checks, check the **consistency mockup ↔ sheet**, state by state:
+
+- every field of `champs` is in the mockup and carries `data-testid="<id of the field>"`; no field in the mockup is missing from the sheet;
+- every rule message (`regles[].message`) is visible in the mockup, word for word, in the state its `etat` names, and in no other state by mistake;
+- every state of `etats` has its section `#etat-<état>`; the `masque` of an empty-state rule really hides the fields it names;
+- the units, formats and wording the sheet declares are those shown.
+
+Check the **sample data** too: recompute the weekday of every date shown (a command such as `date -d`), do not trust the one written. A wrong sample datum (weekday, date, figure that does not add up) is **minor**, never major: it changes no field, rule or state of the sheet, so it does not send the mockup back to the spec writer.
+
+A mismatch is a finding like any other (rule: the sheet is the reference of the later steps; a mockup that contradicts it misleads the acceptance tests). Rank blocking / major / minor as below: a blocking or major finding sends the mockup back to the spec writer, a minor one becomes a note of the lot. Leave the proposed sub-tasks empty — a mockup has no observable bug. This verdict is **not** `raf ux`: the conformity pass after the code keeps that role.
+
+## Conformity mode
+
+When the brief says "conformity" (the orchestrator, after the code, for a lot that has a screen sheet), the mockup `maquette.html` was already reviewed before any code: this is **not the full audit**. Compare the running app to the mockup and its captures `maquette-<état>-<largeur>.png`, state by state (the states of the sheet), at **1440 px** and **390 px**, and report the differences of rendering and ergonomics that the acceptance tests do not cover: layout, spacing and hierarchy that depart from the mockup, wording on screen, contrast, focus, target sizes, reflow. Each finding names the rule (Nielsen, WCAG 2.2 AA) or the measure and the mockup capture it differs from. Do not recheck the rules of the sheet (the tests cover them) and do not redo the audit of the whole screen. Rank blocking / major / minor as below; the verdict is the input of `raf ux`, which the lead decides on the captures, not you.
+
 ## Method
 
 1. **Look before judging.** Capture the screen with the browser tool available (Playwright or

package/bin/cadence.js

@@ -13,7 +13,7 @@ const io = {
 
 if (tool === 'raf') {
   process.exitCode = await run(args, io);
-} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead'].includes(tool)) {
+} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead', 'corrections', 'spec'].includes(tool)) {
   process.exitCode = await run([tool, ...args], io);
 } else if (tool === '--version' || tool === '-v') {
   const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
@@ -43,6 +43,16 @@ if (tool === 'raf') {
   cadence lead tour [dossier] [--idle 3] [--json]
                     le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier courant
                     s'il est lui-même un projet ; une première ligne « cadence.yaml · ✗ erreur » si priority: est illisible
+  cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--json]
+                    la mesure des passes de correction des vagues (dossier/.cadence/runs) : lots à ≥1 et ≥2 corrections,
+                    par projet, visibles ou non, passes par cause ; --classify les classe par Ollama (hors quota)
+  cadence spec check <fiche.yaml>
+                    les invariants d'une fiche d'écran, back ou mixte (étape spec ; gabarits templates/fiche.yaml, fiche-back.yaml) ; code 1 si un écart, 2 si illisible
+  cadence spec qa <fiche.yaml>
+                    la section de docs/qa/expectations.md dérivée de la fiche (shows, never, api), sur la sortie standard
+  cadence spec reseal <lot> <test> --reason "pourquoi"
+                    le chemin du lead quand un test d'acceptation scellé du lot en cours contredit la fiche : le test corrigé dans l'arbre,
+                    l'empreinte de ce seul test refaite, la raison dans acceptation.json et en note du lot ; hors vague orchestrée
   cadence skills install [--dir .claude] [--force]
                     installe les skills Claude Code session-start, session-close, deliver et l'agent ux-reviewer`);
   process.exitCode = !tool || ['help', '--help', '-h'].includes(tool) ? 0 : 2;

package/dist/audit.js

@@ -4,7 +4,8 @@ import { check } from './check.js';
 import { parse } from 'yaml';
 import { changedFiles, fileAt, readCommits } from './git.js';
 import { citedRefs, linkCommits, scopeOf } from './link.js';
-import { readDocsConfig, readNewsConfig } from './config.js';
+import { readDocsConfig, readNewsConfig, readOrchestrateConfig } from './config.js';
+import { ficheHypotheses } from './spec.js';
 import { docSyncGaps, filesOf, gapMessage } from './docsync.js';
 import { loadEntries, newsIssues, PUBLIC_TITLE_DEFAULT, publicTitleTooLong, reusedNewsTitle } from './news.js';
 import { isRecurring } from './recurring.js';
@@ -158,11 +159,22 @@ export function audit(plan, root, newsDir, today, opts = {}) {
         const m = l.public ? publicTitleTooLong(l.public, max) : reused ? publicTitleTooLong(reused, max) : null;
         return m ? [{ message: `${l.id} : ${reused && !l.public ? m.replace('titre public', 'titre public repris de la Nouveauté') : m}` }] : [];
     });
-    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, entries, newsDir), ...titles, ...gates, ...docSyncIssues(plan, root, all.byLot), ...(plan.hasPublicField ? missingPublicTitles(lots, entries) : []),
+    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, entries, newsDir, hypothesesOf(root, plan.configFile ?? join(root, 'cadence.yaml'))), ...titles, ...gates, ...docSyncIssues(plan, root, all.byLot), ...(plan.hasPublicField ? missingPublicTitles(lots, entries) : []),
         ...plan.ignore.invalid.map((src) => ({ message: `ignore : motif invalide « ${src} »` }))];
     // Un plan en lecture seule se corrige avec l'outil du projet : ne pas conseiller une commande raf qui refuserait.
     return plan.readonly ? issues.map((i) => ({ ...i, message: i.message.replace(/ — raf (start|public) .*$/, '') })) : issues;
 }
+/** Hypothèses des fiches, dans le dossier de `orchestrate.spec.dir` ; une configuration d'orchestrate illisible n'empêche pas le contrôle : dossier par défaut. */
+export function hypothesesOf(root, configFile) {
+    let dir = 'docs/specs';
+    try {
+        dir = readOrchestrateConfig(configFile).spec.dir;
+    }
+    catch {
+        // dossier par défaut
+    }
+    return ficheHypotheses(root, dir);
+}
 /**
  * Documentation en retard (L143, clé `docs.sync`) : un lot en cours — ou terminé à partir de `docs.since` — dont les commits de
  * travail touchent des chemins sans toucher le document que la règle désigne. Les commits de plan ne comptent pas.

package/dist/cli.js

@@ -1,9 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
-import { basename, dirname, join, relative, resolve } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { basename, dirname, join, posix, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
-import { readDocsConfig, readHookConfig, readNewsConfig, readPlanConfig, readSessionConfig } from './config.js';
+import { readDocsConfig, readHookConfig, readNewsConfig, readOrchestrateConfig, readPlanConfig, readSessionConfig } from './config.js';
 import { repoSections, repoShas, resolveLotRepos } from './repos.js';
-import { audit, exemptPlanOnly, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
+import { audit, exemptPlanOnly, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
 import { deliver, parseDeliverConfig, realDeps } from './deliver.js';
@@ -13,22 +14,27 @@ import { gitRoot, readCommits, matchesHead, resolveCommit, stage, stagedFiles, s
 import { installHook, pendingCommitMessage, REFUSED } from './hook.js';
 import { citedRefs, linkCommits } from './link.js';
 import { buildNews, loadEntries, newEntry, newsData, newsIssues, publicTitleTooLong, stampEntries } from './news.js';
-import { Plan, RafError, STATUSES } from './plan.js';
+import { Plan, RafError, SCREENS, STATUSES } from './plan.js';
 import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
-import { findProjects, leadTour, tourLine } from './lead.js';
+import { findProjects, leadTour, readLeadUx, tourLine } from './lead.js';
 import { liveLines, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
 import { cadenceHome, openLotsIn } from './orchestrate/registry.js';
+import { classifyAll, measure, ollamaClassifier, readCache, readRuns, renderReport, sampleKeys, serializeCache } from './corrections.js';
+import { findAcceptation, resealAcceptation } from './orchestrate/accept.js';
+import { checkFiche, deriveQa, readFiche, summary } from './spec.js';
 import { readHudContext } from './hud-context.js';
 import { sessionClose, sessionStart } from './session.js';
 import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
 const HELP = `raf — plan « reste à faire » versionné dans le dépôt, relié aux commits
 
   raf init [--project nom] [--prefix L] [--no-hook]
-  raf add "titre" [--estimate j] [--quickwin] [--visible] [--public "titre public"] [--every jours] [--after L2,L4] [--parent L3]
+  raf add "titre" [--estimate j] [--quickwin] [--visible [--screen page|component|journey]] [--spec] [--public "titre public"] [--every jours] [--after L2,L4] [--parent L3]
   raf public <id> "titre public" | --clear   titre du lot dans le langage du public (pages Nouveautés et Plan)
+  raf screen <id> page|component|journey|none   pose, remplace ou retire screen: d'un lot visible existant (l'étape spec d'orchestrate)
+  raf spec <id> on|off   pose ou retire spec: d'un lot existant (le lot change un comportement : étape spec back d'orchestrate)
   raf start <id>        raf done <id> [--force]        raf drop <id> [--reason texte]
   raf note <id> "texte"
   raf did <id> ["texte"]   un lot récurrent (--every) a été refait : le « dû depuis N j » repart de aujourd'hui
@@ -45,7 +51,8 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf gantt [-o docs/plan/gantt.html]
   raf hook install      (pre-commit et post-commit ; cadence.yaml hook.autostart: warn|refuse|start)
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom] [--continue [--until HH:MM] [--priority a,b]]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague]
-  cadence lead tour [dossier] [--idle 3] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier seul s'il est lui-même un projet (en cours, dérive, notes de clôture, prochain lot prêt, dépôt)
+  cadence lead tour [dossier] [--idle 3] [--depth n] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier seul s'il est lui-même un projet (en cours, dérive, notes de clôture, prochain lot prêt, dépôt)
+  cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--json]   mesure des passes de correction des journaux dossier/.cadence/runs : lots à ≥1 et ≥2 corrections, par projet, visibles ou non, passes par cause (classées par Ollama avec --classify, hors quota)
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
@@ -106,6 +113,8 @@ function dispatch(argv, io) {
             estimate: { type: 'string' },
             quickwin: { type: 'boolean' },
             visible: { type: 'boolean' },
+            screen: { type: 'string' },
+            spec: { type: 'boolean' },
             public: { type: 'string' },
             every: { type: 'string' },
             dir: { type: 'string' },
@@ -129,6 +138,11 @@ function dispatch(argv, io) {
             ignored: { type: 'boolean' },
             notes: { type: 'boolean' },
             json: { type: 'boolean' },
+            classify: { type: 'boolean' },
+            model: { type: 'string' },
+            cache: { type: 'string' },
+            sample: { type: 'string' },
+            until: { type: 'string' },
             help: { type: 'boolean', short: 'h' },
         },
     });
@@ -137,7 +151,7 @@ function dispatch(argv, io) {
         io.out(HELP);
         return 0;
     }
-    if (command !== 'session' && (values.all || values.depth !== undefined))
+    if (command !== 'session' && !(command === 'lead' && !values.all) && (values.all || values.depth !== undefined))
         throw new RafError(`${values.all ? '--all' : '--depth'} ne va qu'avec session start ou session close`);
     const today = io.env.RAF_TODAY ?? toDay(io.now());
     if (!isDay(today))
@@ -146,14 +160,17 @@ function dispatch(argv, io) {
     // Le tour parcourt les sous-dossiers (ou, sans sous-projet, prend le dossier lui-même s'il est un projet) : il ne lit pas le plan du dossier courant.
     if (command === 'lead') {
         if (rest[0] !== 'tour' || rest.length > 2)
-            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--json]');
+            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--depth n] [--json]');
         const idle = values.idle === undefined ? undefined : Number(values.idle);
         if (idle !== undefined && !(Number.isInteger(idle) && idle >= 0))
             throw new RafError(`--idle invalide : ${values.idle}`);
+        const depth = values.depth === undefined ? undefined : Number(values.depth);
+        if (depth !== undefined && !(Number.isInteger(depth) && depth >= 1))
+            throw new RafError(`--depth invalide : ${values.depth} (un entier ≥ 1)`);
         const parent = resolve(io.cwd, rest[1] ?? '.');
         if (!existsSync(parent))
             throw new RafError(`lead tour : dossier introuvable : ${parent}`);
-        const rows = leadTour(parent, today, idle);
+        const rows = leadTour(parent, today, idle, depth);
         if (values.json)
             io.out(JSON.stringify(rows, null, 2));
         else if (rows.length === 0)
@@ -165,9 +182,25 @@ function dispatch(argv, io) {
             const [slots] = liveLines();
             if (slots)
                 io.out(slots);
+            // le réglage lead.ux du cadence.yaml du dossier (L197) : le lead lit ici qui pose le verdict UX, au lieu d'ouvrir le fichier
+            try {
+                if (readLeadUx(parent) === 'lead')
+                    io.out('verdict UX : lead (le lead pose raf ux d\'après le rapport du ux-reviewer et les captures ; l\'humain n\'est consulté qu\'en cas de doute)');
+            }
+            catch (e) {
+                // un cadence.yaml illisible a déjà sa ligne d'erreur en tête de tour
+                if (/lead\.ux/.test(e.message))
+                    io.out(`cadence.yaml · ✗ erreur : ${e.message.replace(/^.*cadence\.yaml : /, '')}`);
+            }
         }
         return 0;
     }
+    if (command === 'corrections')
+        return corrections(rest, values, io);
+    // `spec` est aussi un verbe de raf (raf spec <lot> on|off, L186) : seuls check et qa vont à la fiche.
+    if (command === 'spec' && (rest[0] === 'check' || rest[0] === 'qa'))
+        return spec(rest, io);
+    const reseal = command === 'spec' && rest[0] === 'reseal';
     // --all balaie les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant.
     if (command === 'session' && (values.all || values.depth !== undefined))
         return sessionAll(rest, values, io);
@@ -211,6 +244,10 @@ function dispatch(argv, io) {
             const plan = loadPlan();
             let id;
             if (values.parent) {
+                if (values.screen !== undefined)
+                    throw new RafError('--screen se pose sur un lot, pas sur une sous-tâche');
+                if (values.spec)
+                    throw new RafError('--spec se pose sur un lot, pas sur une sous-tâche');
                 if (values.public !== undefined)
                     throw new RafError('--public se pose sur un lot, pas sur une sous-tâche');
                 if (values.every !== undefined)
@@ -227,7 +264,7 @@ function dispatch(argv, io) {
                     throw new RafError(`périodicité invalide : ${values.every} (un nombre entier de jours)`);
                 if (values.public !== undefined)
                     refuseLongTitle(values.public);
-                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, public: values.public, every, after });
+                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, screen: values.screen, spec: values.spec, public: values.public, every, after });
             }
             plan.save();
             io.out(id);
@@ -288,6 +325,30 @@ function dispatch(argv, io) {
             plan.save();
             return 0;
         }
+        case 'screen': {
+            need(2, 'screen <id> page|component|journey|none');
+            if (rest.length > 2)
+                throw new RafError('usage : raf screen <id> page|component|journey|none');
+            const plan = loadPlan();
+            if (rest[1] !== 'none' && !SCREENS.includes(rest[1]))
+                throw new RafError(`screen inconnu : ${rest[1]} (${SCREENS.join(', ')}, none)`);
+            plan.setScreen(rest[0], rest[1] === 'none' ? null : rest[1]);
+            plan.save();
+            return 0;
+        }
+        case 'spec': {
+            if (reseal)
+                return specReseal(rest.slice(1), values.reason, { root, loadPlan, configPath, today }, io);
+            if (rest.length !== 2 || (rest[1] !== 'on' && rest[1] !== 'off'))
+                throw new RafError('usage : raf spec <id> on|off (ou cadence spec check|qa <fiche.yaml>)');
+            const plan = loadPlan();
+            if (!plan.setSpec(rest[0], rest[1] === 'on')) {
+                io.out(`${rest[0]} a déjà screen: — l'écran implique la spec, rien à changer`);
+                return 0;
+            }
+            plan.save();
+            return 0;
+        }
         case 'ux':
         case 'review':
             return gate(command, rest, loadPlan, root, today, io);
@@ -321,6 +382,10 @@ function dispatch(argv, io) {
                 io.out(`after : ${lot.after.join(', ')}`);
             if (lot.public)
                 io.out(`public : ${lot.public}`);
+            if (lot.screen)
+                io.out(`screen : ${lot.screen}`);
+            if (lot.spec)
+                io.out('spec : true');
             if (notes.length) {
                 io.out('notes :');
                 // Les lignes suivantes d'une note multiligne s'alignent sous son texte, pas en colonne 0.
@@ -430,10 +495,8 @@ function dispatch(argv, io) {
         case 'deliver': {
             if (!gitRoot(io.cwd))
                 throw new RafError('deliver : à lancer dans un dépôt git');
-            const orchestrating = activeLock(join(sharedStateDir(root), REPO_LOCK));
-            // La vague tient le verrou jusqu'à la fin de ses lots ; ne refuse que si l'un d'eux travaille encore dans CE dépôt (état illisible : on refuse).
-            const stillOpen = orchestrating ? openLotsIn(cadenceHome(), orchestrating.pid, root) : null;
-            if (orchestrating && (stillOpen === null || stillOpen.length > 0))
+            const orchestrating = waveHolding(root);
+            if (orchestrating)
                 throw new RafError(`deliver : orchestration en cours (vague ${orchestrating.wave}, pid ${orchestrating.pid}) — livrer une fois les lots de ce dépôt finis (le verrou tombe dès que tous sont prêts ou rendus)`);
             if (!existsSync(configPath))
                 throw new RafError(`pas de configuration de livraison : ${configPath} (voir « cadence.yaml » dans le README)`);
@@ -479,7 +542,7 @@ function dispatch(argv, io) {
             return 0;
         }
         case 'news':
-            return news(rest, loadPlan(), newsDir, today, values, io, refuseLongTitle);
+            return news(rest, loadPlan(), newsDir, today, values, io, refuseLongTitle, () => hypothesesOf(root, configPath));
         default:
             throw new RafError(`commande inconnue : ${command} (raf --help)`);
     }
@@ -665,7 +728,7 @@ function postCommit(load, newsDir, root, today, io, mode) {
     }
     return 0;
 }
-function news([sub, ...args], plan, dir, today, values, io, refuseLongTitle) {
+function news([sub, ...args], plan, dir, today, values, io, refuseLongTitle, hypotheses) {
     const lots = plan.lots();
     switch (sub) {
         case 'new': {
@@ -694,7 +757,7 @@ function news([sub, ...args], plan, dir, today, values, io, refuseLongTitle) {
         case 'check':
         case 'build': {
             const entries = loadEntries(dir);
-            const issues = newsIssues(lots, entries, dir);
+            const issues = newsIssues(lots, entries, dir, sub === 'check' ? hypotheses() : undefined);
             for (const i of issues)
                 io.out(`✗ ${i.message}`);
             // Le build refuse seulement ce qu'il ne saurait pas publier : entrée illisible, capture absente.
@@ -736,6 +799,158 @@ function morningEffects(configPath, root) {
         return [`✗ ${e.message}`];
     }
 }
+/** La vague qui tient le verrou du dépôt tant qu'un de ses lots y travaille encore (état illisible : on la tient pour active) ; null si le dépôt est libre. Partagé par `deliver` et `spec reseal`. */
+function waveHolding(root) {
+    const orchestrating = activeLock(join(sharedStateDir(root), REPO_LOCK));
+    if (!orchestrating)
+        return null;
+    const stillOpen = openLotsIn(cadenceHome(), orchestrating.pid, root);
+    return stillOpen === null || stillOpen.length > 0 ? orchestrating : null;
+}
+/**
+ * `cadence spec reseal <lot> <test> --reason texte` (L200) : le chemin du lead quand un test d'acceptation scellé du lot EN COURS contredit la fiche.
+ * Le test est corrigé dans l'arbre de travail (fiche inchangée) ; la commande refait l'empreinte de ce seul test, journalise la raison dans
+ * acceptation.json, commite test + acceptation (le nouveau commit rouge), et note la raison au lot. Le verrou garde tout le reste.
+ */
+const git = (cwd, args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+function specReseal(args, reason, ctx, io) {
+    if (args.length !== 2 || !reason?.trim())
+        throw new RafError('usage : cadence spec reseal <lot> <test> --reason "pourquoi le test contredit la fiche"');
+    if (io.env.CADENCE_ORCHESTRATED)
+        throw new RafError(`spec reseal refusé pendant une vague orchestrée (${io.env.CADENCE_ORCHESTRATED}) : c'est le travail du lead, hors session`);
+    // Comme `deliver` : la vague tient le verrou du dépôt tant qu'un de ses lots y travaille (état illisible : on refuse) ; un commit du lead en pleine passe ferait signaler au lot suivant un écart qui n'est pas le sien.
+    const orchestrating = waveHolding(ctx.root);
+    if (orchestrating)
+        throw new RafError(`spec reseal : orchestration en cours (vague ${orchestrating.wave}, pid ${orchestrating.pid}) — rescellé une fois les lots de ce dépôt finis (le verrou tombe dès que tous sont prêts ou rendus)`);
+    const [lotId, test] = args;
+    const plan = ctx.loadPlan();
+    const lot = plan.lot(lotId);
+    if (lot.status !== 'doing')
+        throw new RafError(`${lotId} n'est pas en cours (${lot.status}) : le rescellé ne vaut que pour le lot en cours ; un lot livré évolue avec sa fiche (README, « Exception — a delivered lot »)`);
+    const repo = gitRoot(ctx.root) ?? ctx.root;
+    const dir = readOrchestrateConfig(ctx.configPath).spec.dir;
+    const json = findAcceptation(repo, dir, lotId);
+    if (!json)
+        throw new RafError(`${lotId} : aucune acceptation sous ${dir} (le lot n'a pas passé l'étape accept)`);
+    const before = { json: readFileSync(join(repo, json), 'utf8'), test: existsSync(join(repo, test)) ? readFileSync(join(repo, test), 'utf8') : '' };
+    let r;
+    try {
+        r = resealAcceptation(repo, json, test, reason, ctx.today);
+    }
+    catch (e) {
+        throw new RafError(e.message);
+    }
+    const norm = posix.normalize(test);
+    try {
+        git(repo, ['add', '--', json, norm]);
+        git(repo, ['commit', '-q', '-m', `test(${lotId}): acceptation rescellée, ${norm} : ${reason.trim()}`, '--', json, norm]);
+    }
+    catch (e) {
+        // Atomique : un commit refusé (hook pre-commit, ...) ne laisse ni empreinte refaite ni index à moitié prêt ; le test retrouve le texte du lead.
+        writeFileSync(join(repo, json), before.json);
+        writeFileSync(join(repo, norm), before.test);
+        try {
+            git(repo, ['reset', '-q', '--', json, norm]);
+        }
+        catch {
+            // rien d'indexé : rien à défaire
+        }
+        const out = e;
+        throw new RafError(`spec reseal : le commit du rescellé a échoué, ${json} et ${norm} sont revenus tels qu'avant la commande (rien n'est rescellé) — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
+    }
+    const sha = git(repo, ['rev-parse', '--short', 'HEAD']).trim();
+    // Un plan tenu par un autre outil ne se modifie pas d'ici : la raison est déjà dans acceptation.json et dans le commit, la note reste à la main du lead.
+    if (plan.readonly) {
+        io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha} ; raison dans ${json} et dans le commit — note à ajouter au lot avec l'outil du projet (plan en lecture seule)`);
+        return 0;
+    }
+    plan.note(lotId, `test d'acceptation rescellé (${norm}, fiche inchangée) : ${reason.trim()}`, ctx.today);
+    plan.save();
+    // La note du lot rejoint le dépôt dans la foulée (un dépôt sale arrêterait la vague suivante) ; un plan hors du dépôt ou non suivi reste à la main du lead.
+    const planRel = relative(repo, plan.path);
+    const tracked = !planRel.startsWith('..') && git(repo, ['ls-files', '--', planRel]).trim() !== '';
+    if (tracked) {
+        try {
+            git(repo, ['add', '--', planRel]);
+            git(repo, ['commit', '-q', '-m', `plan: ${lotId} test d'acceptation rescellé (${norm})`, '--', planRel]);
+        }
+        catch (e) {
+            // Le rescellé est fait (commit ${sha}) : on ne le défait pas, on dit où en est la note, au lieu d'une pile d'appels.
+            const out = e;
+            throw new RafError(`spec reseal : le rescellé a eu lieu (commit ${sha}) mais le commit de la note du lot a échoué — la note est écrite dans ${planRel}, à commiter à la main (un plan sale arrêterait la vague suivante) — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
+        }
+    }
+    io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha} ; raison dans ${json} et en note du lot${tracked ? '' : ' (plan à commiter)'}`);
+    return 0;
+}
+/** `cadence spec check|qa <fiche>` (L170) : code 0 valide, 1 écarts, 2 usage ou fichier illisible. `qa` imprime la section expectations.md de l'écran. */
+function spec(rest, io) {
+    const sub = rest[0];
+    if ((sub !== 'check' && sub !== 'qa') || rest.length !== 2)
+        throw new RafError('usage : cadence spec check|qa <fiche.yaml>');
+    const doc = readFiche(resolve(io.cwd, rest[1]));
+    const problems = checkFiche(doc);
+    if (sub === 'qa') {
+        // les écarts vont sur la sortie d'erreur : la sortie standard est la section, qu'on redirige vers le fichier
+        for (const m of problems)
+            io.err(`✗ ${m}`);
+        if (problems.length > 0)
+            return 1;
+        io.out(deriveQa(doc).trimEnd());
+        return 0;
+    }
+    for (const m of problems)
+        io.out(`✗ ${m}`);
+    if (problems.length > 0) {
+        io.out(`${problems.length} écart(s)`);
+        return 1;
+    }
+    io.out(summary(doc));
+    return 0;
+}
+/** `cadence corrections` (L165) : la mesure de référence des passes de correction d'une vague, lue dans <dossier>/.cadence/runs. */
+async function corrections(rest, values, io) {
+    if (rest.length > 1)
+        throw new RafError('usage : cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--json]');
+    const parent = resolve(io.cwd, rest[0] ?? '.');
+    const runsDir = join(parent, '.cadence', 'runs');
+    if (!existsSync(runsDir))
+        throw new RafError(`corrections : aucun journal de vague dans ${runsDir}`);
+    const sample = values.sample === undefined ? undefined : Number(values.sample);
+    if (sample !== undefined && !(Number.isInteger(sample) && sample > 0))
+        throw new RafError(`--sample invalide : ${values.sample}`);
+    if (values.until !== undefined && Number.isNaN(Date.parse(values.until)))
+        throw new RafError(`--until invalide : ${values.until} (une date ISO, ex. 2026-10-10T18:31Z)`);
+    const model = values.model ?? 'mistral-small3.2:24b';
+    const cacheFile = resolve(io.cwd, values.cache ?? join(parent, '.cadence', 'corrections.json'));
+    const data = readRuns(runsDir, values.until);
+    const cache = readCache(cacheFile);
+    if (values.classify) {
+        const classify = ollamaClassifier({ url: io.env.OLLAMA_HOST ?? 'http://localhost:11434', model });
+        await classifyAll(data.passes, cache, classify, model, (done, total) => {
+            if (done % 25 === 0 || done === total)
+                io.err(`classement : ${done}/${total}`);
+        }, { every: 10, save: () => writeFileSync(cacheFile, serializeCache(cache)) });
+        writeFileSync(cacheFile, serializeCache(cache));
+    }
+    if (sample !== undefined) {
+        const byKey = new Map(data.passes.map((p) => [p.key, p]));
+        // Une passe sans constat (tests rouges) n'a rien à relire : elle ne fait pas partie de l'échantillon.
+        for (const key of sampleKeys(data.passes.filter((p) => p.findings.length > 0).map((p) => p.key), sample)) {
+            const p = byKey.get(key);
+            io.out(`## ${key} (${p.project} ${p.lot}) · modèle : ${cache.get(key)?.cause ?? 'non classé'}${cache.get(key)?.manual ? ` · relu : ${cache.get(key).manual}` : ''}`);
+            for (const f of p.findings)
+                io.out(`- ${f}`);
+            for (const c of p.commits)
+                io.out(`  commit : ${c}`);
+            io.out('');
+        }
+        return 0;
+    }
+    const m = measure(data, cache);
+    io.out(values.json ? JSON.stringify(m, null, 2) : renderReport(m));
+    return 0;
+}
 /** `session start|close --all [--depth n]` : la commande jouée dans chaque projet sous le dossier courant, une section par projet. */
 async function sessionAll(rest, values, io) {
     const sub = rest[0];