@sylad/cadence 1.1.0 → 1.3.0

package/agents/code-reviewer.md

@@ -59,6 +59,12 @@ fact. If the path or the id is missing, or the lot has no commit to review, say
    - 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, 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

package/agents/spec-writer.md

@@ -16,6 +16,8 @@ Follow the brief you are given. The method:
 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.
 
-- You edit only the spec folder (`<dir>/<écran>/`): never application code, tests or the plan. Do not push, deliver, run `raf start|done|note|review|ux`, or launch subagents.
+**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/bin/cadence.js

@@ -40,6 +40,7 @@ if (tool === 'raf') {
                     une session claude neuve par étape (implémentation, revues, corrections) ; --status, --resume ;
                     --max-sessions : sessions simultanées, toutes vagues confondues (CADENCE_MAX_SESSIONS)
                     --continue [--until HH:MM] [--priority a,b] : tire seul les lots prêts du plan, jusqu'à une borne
+                    --waits [--since AAAA-MM-JJ] : l'attente de créneau de session par jour et par vague, lue dans les journaux
   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
@@ -47,9 +48,13 @@ if (tool === 'raf') {
                     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 (étape spec, gabarit templates/fiche.yaml) ; code 1 si un écart, 2 si illisible
+                    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" [--porteur <lot en cours>]
+                    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.
+                    Lot livré (vert: true), test instable au contrat inchangé : --porteur nomme le lot en cours qui porte la correction
   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/cli.js

@@ -1,7 +1,8 @@
 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, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
@@ -13,15 +14,16 @@ 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 { liveLines, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
+import { findProjects, leadTour, readLeadUx, tourLine } from './lead.js';
+import { configuredCap, 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, parseAcceptation, 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';
@@ -29,8 +31,10 @@ import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from './stat
 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 [--screen page|component|journey]] [--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 (seule la valeur page adopte 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
@@ -46,8 +50,8 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot (ou citant un id inconnu) sans réécrire l'historique ; raf check --ignored les liste
   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 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] ; --waits [--since AAAA-MM-JJ]
+  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 … »)
@@ -110,6 +114,7 @@ function dispatch(argv, io) {
             quickwin: { type: 'boolean' },
             visible: { type: 'boolean' },
             screen: { type: 'string' },
+            spec: { type: 'boolean' },
             public: { type: 'string' },
             every: { type: 'string' },
             dir: { type: 'string' },
@@ -118,6 +123,7 @@ function dispatch(argv, io) {
             parent: { type: 'string' },
             force: { type: 'boolean' },
             reason: { type: 'string' },
+            porteur: { type: 'string' },
             status: { type: 'string' },
             since: { type: 'string' },
             idle: { type: 'string' },
@@ -146,7 +152,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))
@@ -155,14 +161,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)
@@ -171,16 +180,28 @@ function dispatch(argv, io) {
             for (const r of rows)
                 io.out(tourLine(r));
             // les créneaux libres viennent du registre, le lead les lit au lieu de les calculer (L141)
-            const [slots] = liveLines();
+            const [slots] = liveLines(configuredCap(io.env));
             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);
-    if (command === 'spec')
+    // `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);
@@ -226,6 +247,8 @@ function dispatch(argv, io) {
             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)
@@ -242,7 +265,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, screen: values.screen, 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);
@@ -303,6 +326,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, values.porteur, { 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: page — 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);
@@ -338,6 +385,8 @@ function dispatch(argv, io) {
                 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.
@@ -447,10 +496,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)`);
@@ -753,6 +800,104 @@ 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, porteur, ctx, io) {
+    if (args.length !== 2 || !reason?.trim())
+        throw new RafError('usage : cadence spec reseal <lot> <test> --reason "pourquoi le test contredit la fiche" [--porteur <lot en cours>, pour un lot livré]');
+    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);
+    const repo = gitRoot(ctx.root) ?? ctx.root;
+    const dir = readOrchestrateConfig(ctx.configPath).spec.dir;
+    const json = findAcceptation(repo, dir, lotId);
+    // Un lot livré (acceptation verte) se rescelle pour un test instable dont le contrat ne change pas : le lot en cours qui porte la correction est nommé (--porteur) et cité dans le commit.
+    const livre = lot.status !== 'doing' && !!json && ((a) => typeof a !== 'string' && a.vert)(parseAcceptation(readFileSync(join(repo, json), 'utf8')));
+    if (lot.status !== 'doing' && !livre)
+        throw new RafError(`${lotId} n'est pas en cours (${lot.status}) : le rescellé vaut pour le lot en cours, ou pour un lot livré dont l'acceptation est verte (vert: true) avec --porteur <lot en cours>`);
+    if (porteur && lot.status === 'doing')
+        throw new RafError(`--porteur n'a de sens que pour un lot livré : ${lotId} est en cours, son rescellé est cité sous son propre id`);
+    if (livre && !porteur?.trim())
+        throw new RafError(`${lotId} est livré : --porteur <lot en cours> est obligatoire (le lot dont le commit porte la correction du test)`);
+    if (livre && porteur) {
+        if (porteur === lotId)
+            throw new RafError(`--porteur doit être un autre lot que ${lotId} (le lot livré est clos)`);
+        const carrier = plan.lot(porteur);
+        if (carrier.status !== 'doing')
+            throw new RafError(`--porteur ${porteur} n'est pas en cours (${carrier.status}) : le lot porteur est celui dont le commit porte la correction`);
+    }
+    const cite = livre ? porteur : 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, livre ? porteur : undefined);
+    }
+    catch (e) {
+        throw new RafError(e.message);
+    }
+    const norm = posix.normalize(test);
+    try {
+        git(repo, ['add', '--', json, norm]);
+        git(repo, ['commit', '-q', '-m', `test(${cite}): acceptation rescellée${livre ? ` du lot livré ${lotId}` : ''}, ${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 ${cite} avec l'outil du projet (plan en lecture seule)`);
+        return 0;
+    }
+    plan.note(cite, `test d'acceptation rescellé${livre ? ` (lot livré ${lotId}, ` : ' ('}${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: ${cite} 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 ${cite}${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];

package/dist/config.js

@@ -220,13 +220,13 @@ export function readSessionConfig(file) {
     return config;
 }
 const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
-export const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'accept', 'implement', 'fix', 'review', 'ux'];
+export const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'fix', 'review', 'ux'];
 const MODELS = ['haiku', 'sonnet', 'opus'];
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'ux', 'precheck', 'prodAccess', 'spec', 'review', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'fiche', 'ux', 'precheck', 'prodAccess', 'spec', 'review', '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, precheckLocal: false, prodAccess: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', 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, fiche: true, precheckLocal: false, prodAccess: 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 } };
     if (!existsSync(file))
         return config;
     let raw;
@@ -253,7 +253,14 @@ export function readOrchestrateConfig(file) {
     for (const k of Object.keys(o))
         if (!ORCH_KEYS.includes(k))
             throw bad(`${k} inconnu (attendu : ${ORCH_KEYS.join(', ')})`);
+    if (o.accept != null && Array.isArray(o.accept)) {
+        if (!o.accept.length || o.accept.some((x) => typeof x !== 'string' || !x.trim()))
+            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', 'build', 'accept']) {
+        if (k === 'accept' && Array.isArray(o.accept))
+            continue;
         if (o[k] == null)
             continue;
         if (typeof o[k] !== 'string' || !o[k].trim())
@@ -265,6 +272,11 @@ export function readOrchestrateConfig(file) {
             throw bad('maquette : true ou false attendu');
         config.maquette = o.maquette;
     }
+    if (o.fiche != null) {
+        if (typeof o.fiche !== 'boolean')
+            throw bad('fiche : true ou false attendu');
+        config.fiche = o.fiche;
+    }
     if (o.precheck != null) {
         if (typeof o.precheck !== 'boolean' && o.precheck !== 'local')
             throw bad('precheck : true, false ou local attendu');
@@ -318,7 +330,7 @@ export function readOrchestrateConfig(file) {
     }
     if (o.effort != null) {
         if (!isObject(o.effort))
-            throw bad('effort doit être un objet { precheck, spec, maquette, accept, implement, fix, review, ux }');
+            throw bad('effort doit être un objet { precheck, spec, maquette, fiche, accept, implement, 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.js

@@ -86,7 +86,7 @@ export function readRuns(runsDir, until) {
 const tally = () => ({ lots: 0, atLeast1: 0, atLeast2: 0, passes: 0 });
 const causes = () => ({ ...Object.fromEntries([...CAUSES, 'sans-constat', 'non-classe'].map((c) => [c, 0])) });
 export function measure(data, cache) {
-    const m = { total: tally(), byProject: {}, byVisibility: { visible: tally(), hidden: tally() }, byCause: causes(), byProjectCause: {}, agreement: { reviewed: 0, agree: 0 } };
+    const m = { total: tally(), byProject: {}, byVisibility: { visible: tally(), hidden: tally() }, byCause: causes(), byVisibilityCause: { visible: causes(), hidden: causes() }, byProjectCause: {}, agreement: { reviewed: 0, agree: 0 } };
     for (const l of data.lots) {
         const groups = [m.total, (m.byProject[l.project] ??= tally()), l.visible ? m.byVisibility.visible : m.byVisibility.hidden];
         for (const t of groups) {
@@ -102,6 +102,7 @@ export function measure(data, cache) {
         const c = cache.get(p.key);
         const cause = p.findings.length === 0 ? 'sans-constat' : c ? (c.manual ?? c.cause) : 'non-classe';
         m.byCause[cause]++;
+        (p.visible ? m.byVisibilityCause.visible : m.byVisibilityCause.hidden)[cause]++;
         (m.byProjectCause[p.project] ??= causes())[cause]++;
         if (c?.manual && cause !== 'sans-constat') {
             m.agreement.reviewed++;
@@ -208,6 +209,8 @@ export function serializeCache(cache) {
     return JSON.stringify(Object.fromEntries([...cache].sort(([a], [b]) => a.localeCompare(b))), null, 2) + '\n';
 }
 const pct = (a, b) => (b === 0 ? '—' : `${Math.round((100 * a) / b)} %`);
+/** Les causes qu'une meilleure spécification évite (critère de réussite de l'étape spec). */
+const SPEC_CAUSES = ['spec-floue', 'regle-inventee', 'test-manquant'];
 const row = (name, t) => `| ${name} | ${t.lots} | ${t.atLeast1} (${pct(t.atLeast1, t.lots)}) | ${t.atLeast2} (${pct(t.atLeast2, t.lots)}) | ${t.passes} |`;
 export function renderReport(m) {
     const all = [...CAUSES, 'sans-constat', 'non-classe'];
@@ -222,6 +225,12 @@ export function renderReport(m) {
         out.push(`| ${p} | ${used.map((c) => m.byProjectCause[p]?.[c] ?? 0).join(' | ')} | ${m.byProject[p].passes} |`);
     out.push('', '### Lots avec correction', '', '| Projet | Lots | ≥ 1 correction | ≥ 2 corrections | Passes |', '|---|---|---|---|---|', ...projects.map((p) => row(p, m.byProject[p])), row('**Total**', m.total), '');
     out.push('### Lots visibles et non visibles', '', '| Lots | Lots | ≥ 1 correction | ≥ 2 corrections | Passes |', '|---|---|---|---|---|', row('visibles', m.byVisibility.visible), row('non visibles', m.byVisibility.hidden), '');
+    out.push('### Par cause et par visibilité (passes)', '', `| Lots | Lots | Passes | ${used.map((c) => LABELS[c]).join(' | ')} | Spec floue, règle inventée ou test manquant |`, `|---|---|---|${used.map(() => '---').join('|')}|---|`);
+    for (const [name, t, byC] of [['visibles', m.byVisibility.visible, m.byVisibilityCause.visible], ['non visibles', m.byVisibility.hidden, m.byVisibilityCause.hidden]]) {
+        const spec = SPEC_CAUSES.reduce((n, c) => n + byC[c], 0);
+        out.push(`| ${name} | ${t.lots} | ${t.passes} | ${used.map((c) => byC[c]).join(' | ')} | ${spec} (${pct(spec, t.passes)}) |`);
+    }
+    out.push('');
     if (m.agreement.reviewed > 0)
         out.push(`Échantillon relu à la main : ${m.agreement.reviewed} passes, le modèle local est d'accord avec la relecture sur ${m.agreement.agree} (${pct(m.agreement.agree, m.agreement.reviewed)}) ; la cause relue prime dans les tableaux.`, '');
     return out.join('\n');

package/dist/lead.js

@@ -1,13 +1,58 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, join, relative, sep } from 'node:path';
 import { audit, nextUp, planCommits } from './audit.js';
 import { planLoader, readPlanConfig } from './config.js';
 import { diffDays } from './dates.js';
 import { gitRoot, repoStatus } from './git.js';
 import { linkCommits } from './link.js';
 import { lastActivity, lockStatus } from './session.js';
+import { parse } from 'yaml';
+import { RafError } from './plan.js';
 import { priorityRank, readPriority } from './orchestrate/continue.js';
 import { readNext, sharedStateDir, stateDir } from './state.js';
+/** Clé `lead.ux` du cadence.yaml du dossier parent (L197) : qui pose le verdict UX (`raf ux`) d'un lot visible. `human` (défaut) : l'humain ; `lead` : le lead, l'humain n'étant consulté qu'en cas de doute. */
+export function readLeadUx(parent) {
+    const file = join(parent, 'cadence.yaml');
+    if (!existsSync(file))
+        return 'human';
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const l = raw?.lead;
+    if (l == null)
+        return 'human';
+    const ux = l.ux;
+    if (typeof l !== 'object' || Array.isArray(l))
+        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+    if (ux == null)
+        return 'human';
+    if (ux !== 'lead' && ux !== 'human')
+        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+    return ux;
+}
+/** Clé `depth:` du cadence.yaml du dossier parent (L201, issue #8), à côté de `priority:` : combien de niveaux `lead tour` parcourt (1 : sous-dossiers directs, le défaut). */
+export function readDepth(parent) {
+    const file = join(parent, 'cadence.yaml');
+    if (!existsSync(file))
+        return 1;
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const d = raw?.depth;
+    if (d == null)
+        return 1;
+    if (typeof d !== 'number' || !Number.isInteger(d) || d < 1)
+        throw new RafError(`${file} : depth doit être un entier ≥ 1`);
+    return d;
+}
 export const NOTES_MAX = 120;
 export const TITLE_MAX = 60;
 /** Au-delà de ce nombre de jours sans activité, un lot en cours est dit silencieux. */
@@ -56,8 +101,8 @@ export function findProjects(parent, depth = 1) {
     return found.sort();
 }
 /** Les faits de `cadence session start` pour un projet, sous forme de données ; lecture seule. */
-export function tourRow(dir, today, idle = TOUR_IDLE) {
-    const row = empty(basename(dir));
+export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
+    const row = empty(name);
     try {
         const root = gitRoot(dir) ?? dir;
         const plan = planLoader(root)();
@@ -96,24 +141,32 @@ export function tourRow(dir, today, idle = TOUR_IDLE) {
 }
 /**
  * Les projets rangés par la clé `priority:` du cadence.yaml du dossier (L149) ; les autres après, par ordre alphabétique.
- * Une priorité illisible ou invalide ne vide pas le tableau : l'ordre alphabétique reste, et une première ligne `cadence.yaml` en erreur le dit.
+ * Une clé `depth:` invalide se signale de même. Une priorité illisible ou invalide ne vide pas le tableau : l'ordre alphabétique reste, et une première ligne `cadence.yaml` en erreur le dit.
  * Un dossier qui n'a aucun sous-projet mais est lui-même un projet donne la ligne de ce projet seul (la bande l'interroge depuis le dossier de la session).
  */
-export function leadTour(parent, today, idle = TOUR_IDLE) {
-    const dirs = findProjects(parent);
+export function leadTour(parent, today, idle = TOUR_IDLE, depth) {
+    const problems = [];
+    const attempt = (read, fallback) => {
+        try {
+            return read();
+        }
+        catch (e) {
+            const error = (e instanceof Error ? e.message : String(e)).split('\n')[0];
+            if (!problems.some((p) => p.error === error))
+                problems.push({ ...empty('cadence.yaml'), error }); // un yaml illisible l'est pour les deux clés : une seule ligne
+            return fallback;
+        }
+    };
+    // --depth l'emporte sur la clé `depth:` ; une clé invalide se signale et laisse un seul niveau
+    const levels = depth ?? attempt(() => readDepth(parent), 1);
+    const dirs = findProjects(parent, levels);
     if (dirs.length === 0 && isProject(parent))
-        return [tourRow(parent, today, idle)];
-    const rows = dirs.map((dir) => tourRow(dir, today, idle));
-    let priority = [];
-    let problem;
-    try {
-        priority = readPriority(parent);
-    }
-    catch (e) {
-        problem = { ...empty('cadence.yaml'), error: (e instanceof Error ? e.message : String(e)).split('\n')[0] };
-    }
-    const sorted = rows.map((r, i) => ({ r, i })).sort((a, b) => priorityRank(a.r.project, priority) - priorityRank(b.r.project, priority) || a.i - b.i).map((x) => x.r);
-    return problem ? [problem, ...sorted] : sorted;
+        return [...problems, tourRow(parent, today, idle)];
+    // un projet imbriqué est nommé par son chemin depuis le dossier : unique, et adressable par `orchestrate <projet>:<lot>` lancé d'ici ; la priorité et l'ordre alphabétique lisent le nom du dossier, comme orchestrate --continue
+    const rows = dirs.map((dir) => ({ dir, key: basename(dir), row: tourRow(dir, today, idle, relative(parent, dir).split(sep).join('/')) }));
+    const priority = attempt(() => readPriority(parent), []);
+    const sorted = rows.sort((a, b) => priorityRank(a.key, priority) - priorityRank(b.key, priority) || a.key.localeCompare(b.key) || a.row.project.localeCompare(b.row.project)).map((x) => x.row);
+    return [...problems, ...sorted];
 }
 const DRIFT_SHOWN = 2;
 /** Une ligne par projet : projet · en cours · dérive · notes · prochain lot prêt · dépôt. */