@sylad/cadence 1.40.0 → 1.41.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.40.0",
+      "version": "1.41.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.40.0",
+  "version": "1.41.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/agents/spec-writer.md

@@ -14,6 +14,7 @@ Follow the brief you are given. The method:
    **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.
+   **Light mockup** (the brief says so: a visible lot that is not a whole page): cover only the states the lot touches, and before drawing the target capture the CURRENT screen of each of those states at both widths, named `actuel-<état>-<largeur>.png`, in the same folder. If the current screen cannot be captured (the application does not start, the page is protected), say so under `nonVerifie` and base the mockup on the code: never invent a capture.
    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.

package/agents/ux-reviewer.md

@@ -24,6 +24,8 @@ On top of the usability and accessibility checks, check the **consistency mockup
 - 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.
 
+Light mockup (the brief says so): the sheet and the mockup cover only the states the lot touches. Sweep those states only, and compare the target of each one to the capture of the current screen `actuel-<état>-<largeur>.png` in the same folder (a free file the program does not check; when it is missing the spec writer said why under `nonVerifie`, judge the target against the code and the neighbouring pages). A defect of the screen that the lot does not touch is not a finding of this review.
+
 **Criteria added in mockup mode** — in this mode only (conformity mode and the review of an existing screen keep their text). Each one carries its named rule or the value to count; the checks of the method below (contrast, targets, keyboard, focus, alternatives, colour, reflow, data display) are already written there and are not repeated here.
 
 **Family: visual hierarchy**

package/dist/cli.js

@@ -2,9 +2,13 @@ import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from
 import { execFileSync } from 'node:child_process';
 import { basename, dirname, join, posix, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
+import { refuseRedAcceptation } from './raf-close-checks.js';
+import { statusCommand } from './raf-status.js';
 import { defaultPlan, PLAN_DEFAULT, PLAN_LEGACY, readDocsConfig, readHookConfig, readNewsConfig, readOrchestrateConfig, readPerfConfig, readPlanConfig, readSessionConfig, readVerifyConfig } from './config.js';
 import { repoSections, repoShas, resolveLotRepos } from './repos.js';
-import { audit, exemptPlanOnly, gateProgress, gateText, gateWaiting, hypothesesOf, isNonConformingVerdict, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork, workByLot } from './audit.js';
+import { lotJson, lotLines } from './lot-lines.js';
+import { parseSet } from './plan-extras.js';
+import { audit, exemptPlanOnly, gateWaiting, hypothesesOf, isNonConformingVerdict, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork, workByLot } from './audit.js';
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
 import { deliver, parseDeliverConfig, realDeps, shellQuote } from './deliver.js';
@@ -34,7 +38,7 @@ 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, modeSpecGreen, setVert } from './orchestrate/accept.js';
+import { findAcceptation, parseAcceptation, resealAcceptation, resealForGreen, runAcceptation, modeSpecGreen, setVert } from './orchestrate/accept.js';
 import { refCommand } from './ref/command.js';
 import { coverageCommand } from './ref/coverage.js';
 import { release } from './release.js';
@@ -47,7 +51,7 @@ 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]] [--spec] [--local] [--public "titre public"] [--every jours] [--after L2,L4] [--uses banc,passerelle] [--parent L3]
+  raf add "titre" [--estimate j] [--quickwin] [--visible [--screen page|component|journey]] [--spec] [--local] [--public "titre public"] [--every jours] [--after L2,L4] [--uses banc,passerelle] [--set champ=valeur]… [--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 visible <id> on|off   pose ou retire visible: d'un lot existant (changement visible : entrée Nouveautés et étape UX d'orchestrate) ; off est refusé tant que le lot a un screen:
@@ -56,6 +60,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf uses <lot> [<ressource>…]   remplace les ressources partagées du lot (uses:, déclarées par resources: dans le cadence.yaml du dossier parent ; raf check refuse un nom non déclaré) ; sans nom, retire la clé
   cadence local start <lot> [--ttl minutes] | local done <lot> | local abort <lot>   tâche locale du lead (lot posé par raf add --local) : start verrouille le dépôt comme une vague (aucune vague n'y démarre, --add y est refusé) et passe le lot à doing, refusé si une orchestration ou un autre lot du dépôt est en cours ; le verrou est déclaré (60 min par défaut), tenu sans processus jusqu'à done ou abort, signalé en ⚠ par lead tour et orchestrate --status au-delà du délai ; done joue la porte du projet UNE fois, libère le dépôt si elle est verte (la capture, la revue du diff, cadence deliver et raf done restent au lead) et le garde verrouillé sinon ; abort libère sans porte
   raf start <id>        raf done <id> [--force]        raf drop <id> [--reason texte]
+  raf status [<id> <état> ["message"] | <id> --back ["message"]]   états détaillés du projet (cadence.yaml : plan.states) : pose l'état d'un lot sous la garde de plan.transitions et note le message ; --back sort de l'état bloqué vers l'état d'avant ; sans argument, liste les états. start / done / drop / todo posent eux-mêmes l'état de leur statut
   raf todo <id> [--reason texte]   remet en attente un lot démarré sans commit de travail (doing → todo, started retiré, note datée) ; refusé s'il a des commits ; rouvre un lot done ou dropped (→ todo, finished retiré, note « rouvert ») — la seule façon de rouvrir, archivé compris (il revient dans le fichier du plan)
   raf note <id> "texte"
   --verbose             avec done, ux, review, note, move ou public : imprime la ligne « id  état  titre entier » du lot touché ; avec hook post-commit : le titre entier (sinon 60 caractères au plus)
@@ -68,7 +73,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf show <id> [--notes]   le lot : statut, dates, after, titre public, visible et verdict ux (lot visible), notes datées, commits comptés ; --notes : les notes seules
   raf commits <id>      les commits du lot que compte la porte de revue de code, du plus ancien au plus récent
   raf now               ce qui est en cours, la suite, les derniers terminés
-  raf list [--status todo|doing|done|dropped]
+  raf list [--status todo|doing|done|dropped] [--json]   les lots, une ligne chacun ; --json : un tableau JSON des lots (clés du fichier du plan, champs d'extension sous extras)
   raf check [--since date] [--idle 7]   (défaut : date « since » du plan) code 1 s'il y a des écarts
   raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot, citant un id inconnu ou des lots sans y travailler, sans réécrire l'historique ; raf check --ignored les liste
   raf docs-ok <lot> --reason texte   acquitte l'écart docs.sync d'un lot (documentation en retard) avec la raison pour laquelle la documentation reste telle quelle (plan en lecture seule : .cadence/docs-ok.yaml, le plan n'est pas touché) ; lu par raf check et par orchestrate, qui ne rend jamais prêt un lot avec un écart ouvert
@@ -93,7 +98,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   cadence ref eval <attendu.json | dossier> <lecture.json | dossier> [--json]   note une lecture contre l'inventaire attendu (vérité connue) : rappel et précision par type, faux lu (éléments sûrs et faux), pièges trouvés, tokens par page (usage.tokens de la lecture) ; lecture d'un autre document refusée (code 2) ; sur dossiers, un cas par sous-dossier (attendu.json / lecture.json)
   cadence ref corpus <dossier> [--sans-rendu]   écrit le corpus synthétique à vérité connue (7 pièges : texte ambigu levé par une figure, figure qui contredit, table en image, gabarit BUFR, contrôle translucide, page Proposal, scan bruité) : par cas document.html et attendu.json, puis document.pdf et page-<n>.png (1700×2200) rendus par Playwright (CADENCE_PLAYWRIGHT = dossier du paquet) ; dossier existant ou Playwright introuvable : code 2
   cadence release patch|minor|major [--dry-run]   prépare le commit de version (package.json, package-lock.json, plugin.json, marketplace.json, CHANGELOG.md) sans commiter ni publier ; imprime les étapes du lead et vérifie docs/whats-new.md : refus sur un arbre sale, un [Unreleased] vide ou une version déjà taguée
-  cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
+  cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert (et, au sha de la dernière livraison rouge, l’inscrit au journal des livraisons), 1 effet rouge, 2 rien à vérifier
   cadence verify --gate --sha rév [--project dossier]   porte du projet (orchestrate.build puis orchestrate.test) : reprend le verdict enregistré par la vague quand son sha est le même et son arbre identique, sans rien rejouer (la sortie dit « verdict repris de la porte de la vague ») ; sinon la rejoue (« verdict rejoué : raison ») au sha dans l'arbre principal s'il est propre au sha, sinon dans un worktree jetable aux dépendances copiées (orchestrate.worktreeDeps), puis le retire : 0 vert, 1 rouge avec les tests en échec, 2 rien à rejouer ; le verdict (0 ou 1) est noté par sha et le hook pre-push refuse un push dont le sha n'a pas de verdict vert (CADENCE_PUSH_UNGATED=1 passe outre)
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
@@ -183,8 +188,10 @@ function dispatch(argv, io) {
             title: { type: 'string' },
             after: { type: 'string' },
             uses: { type: 'string' },
+            set: { type: 'string', multiple: true },
             parent: { type: 'string' },
             force: { type: 'boolean' },
+            back: { type: 'boolean' },
             reason: { type: 'string' },
             porteur: { type: 'string' },
             status: { type: 'string' },
@@ -406,6 +413,8 @@ function dispatch(argv, io) {
                 }
                 if (values.uses !== undefined)
                     throw new RafError(`uses se pose sur un lot, pas sur une sous-tâche : ${values.parent}`);
+                if (values.set !== undefined)
+                    throw new RafError(`--set se pose sur un lot, pas sur une sous-tâche : ${values.parent}`);
                 id = plan.addTask(values.parent, rest.join(' '));
             }
             else {
@@ -421,7 +430,7 @@ function dispatch(argv, io) {
                 const uses = values.uses?.split(',').map((n) => n.trim()).filter(Boolean);
                 if (uses?.length === 0)
                     throw new RafError(invalidResource(''));
-                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, screen: values.screen, spec: values.spec, local: values.local, public: values.public, every, after, uses });
+                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, screen: values.screen, spec: values.spec, local: values.local, public: values.public, every, after, uses, extras: parseSet(values.set) });
             }
             plan.save();
             io.out(id);
@@ -444,24 +453,8 @@ function dispatch(argv, io) {
                     refuseLongTitle(pub, lot?.public ? '' : ' — titre de la Nouveauté reprise par le site : corriger l\'entrée ou poser raf public');
             }
             // Le plan ne lit pas git : lui dire combien de commits du lot sa revue ne couvre pas quand elle est exigée.
-            // Un lot clos avec une acceptation à vert: false bloque les vagues suivantes du dépôt (verrou des tests d'acceptation, L366).
-            if (status === 'done' && !rest[0].includes('/')) {
-                const repo = gitRoot(root) ?? root;
-                let dir = null;
-                try {
-                    dir = readOrchestrateConfig(configPath).spec.dir;
-                }
-                catch {
-                    // un cadence.yaml illisible ne doit pas empêcher de clore un lot : `cadence check` en parle
-                }
-                const red = dir === null ? undefined : redAcceptations(repo, dir).find((a) => a.lot === rest[0]);
-                if (red) {
-                    const text = `${rest[0]} : ${red.path} est à vert: false — clos ainsi, le lot bloquerait les vagues suivantes du dépôt (verrou des tests d'acceptation) ; cadence spec green ${rest[0]} lance la commande d'acceptation et pose vert: true`;
-                    if (!values.force)
-                        throw new RafError(`${text} (--force pour passer outre)`);
-                    io.err(`avertissement : ${text}`);
-                }
-            }
+            if (status === 'done' && !rest[0].includes('/'))
+                refuseRedAcceptation(root, configPath, rest[0], !!values.force, io.err);
             const unreviewed = status === 'done' && plan.reviewSince && !plan.readonly && !values.force ? unreviewedWork(plan, root, rest[0]) : 0;
             const verdict = status === 'done' && !rest[0].includes('/') ? plan.lots().find((l) => l.id === rest[0])?.review?.verdict : undefined;
             const nonConforming = verdict !== undefined && isNonConformingVerdict(verdict);
@@ -512,6 +505,8 @@ function dispatch(argv, io) {
             }
             return 0;
         }
+        case 'status':
+            return statusCommand(loadPlan(), rest, { back: !!values.back, today, out: io.out, commits: (p, id) => lotWork(p, root, id).length });
         case 'todo': {
             need(1, 'todo <id> [--reason texte]');
             const plan = loadPlan();
@@ -638,32 +633,8 @@ function dispatch(argv, io) {
                     io.out(n);
                 return 0;
             }
-            io.out(`${lot.id}  ${lot.status}  ${lot.title}`);
-            if (lot.goal)
-                io.out(`goal : ${lot.goal}`);
-            const dates = [['créé', lot.created], ['démarré', lot.started], [lot.status === 'dropped' ? 'abandonné' : 'terminé', lot.finished]].filter(([, d]) => d);
-            if (dates.length)
-                io.out(dates.map(([k, d]) => `${k} : ${d}`).join('  '));
-            if (lot.after.length)
-                io.out(`after : ${lot.after.join(', ')}`);
-            if (lot.public)
-                io.out(`public : ${lot.public}`);
-            // L439 : le livreur lit ici si le lot est visible et s'il porte un verdict UX ; deux lignes stables, absentes d'un lot non visible.
-            if (lot.visible)
-                io.out('visible : oui');
-            if (lot.screen)
-                io.out(`screen : ${lot.screen}`);
-            if (lot.visible)
-                io.out(lot.ux ? `ux : ${lot.ux.verdict}` : 'ux : absent');
-            if (lot.spec)
-                io.out('spec : true');
-            if (lot.uses)
-                io.out(`uses : ${lot.uses.join(', ')}`);
-            if (lot.docsOk)
-                io.out(`docs-ok : ${lot.docsOk.date} — ${lot.docsOk.reason}`);
-            const gate = gateProgress(plan.lots(), lot);
-            if (lot.gate && gate)
-                io.out(lot.gate.invalid ? `gate : ${gateText(gate)}` : `gate : ${gate.n} lots ${gate.label} faits`);
+            for (const line of lotLines(plan, lot))
+                io.out(line);
             if (notes.length) {
                 io.out('notes :');
                 // Les lignes suivantes d'une note multiligne s'alignent sous son texte, pas en colonne 0.
@@ -682,9 +653,12 @@ function dispatch(argv, io) {
             const plan = loadPlan();
             if (values.status && !STATUSES.includes(values.status))
                 throw new RafError(`statut inconnu : ${values.status}`);
-            for (const l of plan.lots().filter((l) => !values.status || l.status === values.status)) {
-                io.out(`${l.id.padEnd(6)} ${l.status.padEnd(8)} ${l.quickwin ? '⚡ ' : ''}${l.title}`);
-            }
+            const shown = plan.lots().filter((l) => !values.status || l.status === values.status);
+            if (values.json)
+                io.out(JSON.stringify(shown.map(lotJson), null, 2));
+            else
+                for (const l of shown)
+                    io.out(`${l.id.padEnd(6)} ${l.status.padEnd(8)} ${l.quickwin ? '⚡ ' : ''}${l.title}`);
             return 0;
         }
         case 'now':
@@ -816,12 +790,8 @@ function dispatch(argv, io) {
             if (!existsSync(configPath))
                 throw new RafError(`pas de configuration de livraison : ${configPath} (voir « cadence.yaml » dans docs/deliver.md du paquet @sylad/cadence)`);
             const config = parseDeliverConfig(readFileSync(configPath, 'utf8'), configPath);
-            const plan = existsSync(planPath) ? loadPlan() : null;
-            const articles = readDocsConfig(configPath).articles;
-            // Sans public: d'un lot visible, le site reprend le titre de sa Nouveauté la plus récente.
-            const publicTitle = (lot) => lot.public ?? (lot.visible ? loadEntries(newsDir).find((e) => e.lots.includes(lot.id))?.title : undefined);
-            const ctx = { root, state: sharedStateDir(root), plan, config, today, dryRun: !!values['dry-run'], sha: values.sha, duringWave: !!orchestrating, waveId: orchestrating?.wave, planCommit: readPlanConfig(configPath, root)?.commit, args: rest, articles, publicTitle, out: io.out, err: io.err };
-            return deliver(ctx, realDeps(root));
+            const effects = deliveredEffects({ root, configPath, planPath, loadPlan, newsDir, today, waveId: orchestrating?.wave, io });
+            return deliver({ ...effects, state: sharedStateDir(root), config, dryRun: !!values['dry-run'], sha: values.sha, duringWave: !!orchestrating, args: rest }, realDeps(root));
         }
         case 'verify': {
             if (values.gate)
@@ -837,7 +807,12 @@ function dispatch(argv, io) {
             const target = values.sha ? { sha: resolveCommit(root, values.sha) ?? '', note: null } : defaultTarget(root, config);
             if (values.sha && !target.sha)
                 throw new RafError(`--sha ${values.sha} : commit introuvable`);
-            return verifyCommand({ config, sha: target.sha, note: target.note, retry, out: io.out }, realCheckDeps(root));
+            // Une ligne verte écrite par verify (L435) est une livraison : mêmes effets que deliver (lots annoncés, article à rafraîchir, L144).
+            // verify lit le verrou sans refuser : une tâche locale du lead (L519) n'empêche pas de rejouer les vérifications, et n'est pas une vague à citer.
+            const holding = waveHolding(root);
+            const waveId = holding && !localLotOf(holding.wave) ? holding.wave : undefined;
+            const effects = () => deliveredEffects({ root, configPath, planPath, loadPlan, newsDir, today, waveId, io });
+            return verifyCommand({ config, sha: target.sha, note: target.note, retry, out: io.out, journal: { dir: sharedStateDir(root), day: today, effects } }, realCheckDeps(root));
         }
         case 'skills': {
             if (rest[0] !== 'install')
@@ -870,6 +845,16 @@ const GATES = {
     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 },
 };
+/**
+ * Ce qu'une livraison verte annonce et ouvre (lots livrés, article à rafraîchir, L144) : pour `cadence deliver` et pour la ligne verte
+ * que `cadence verify` inscrit (L435). Sans `public:`, un lot visible tire son titre de sa Nouveauté la plus récente.
+ */
+function deliveredEffects(p) {
+    const { root, configPath, newsDir, io } = p;
+    const publicTitle = (lot) => lot.public ?? (lot.visible ? loadEntries(newsDir).find((e) => e.lots.includes(lot.id))?.title : undefined);
+    const plan = existsSync(p.planPath) ? p.loadPlan() : null;
+    return { root, plan, today: p.today, articles: readDocsConfig(configPath).articles, publicTitle, planCommit: readPlanConfig(configPath, root)?.commit, waveId: p.waveId, out: io.out, err: io.err };
+}
 /** « 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, opts) {
     if (rest.length < 1)

package/dist/config.js

@@ -4,16 +4,16 @@ import { parse } from 'yaml';
 import { isDay } from './dates.js';
 import { readGate } from './gate-config.js';
 import { DEFAULT_TEST_PATTERNS } from './testgate.js';
+import { readExtras } from './plan-extras.js';
 import { gitRoot } from './git.js';
 import { planCommitProblem } from './plan-commit.js';
+import { parseStates } from './plan-states.js';
 import { checkTestReplay, readGateTest } from './orchestrate/gate-parts.js';
-import { booleanKey } from './yaml-keys.js';
+import { booleanKey, isObject, list } from './yaml-keys.js';
 import { FIELDS, Plan, RafError, STATUSES } from './plan.js';
-const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit'];
+const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit', 'states', 'transitions', 'doneState', 'blockedState', 'extras'];
 const ON_WRITE_KEYS = ['command', 'files'];
 const FORMAT_KEYS = ['lots', 'fields', 'statuses', 'estimates'];
-const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-const list = (v) => (v == null ? [] : Array.isArray(v) ? v.map(String) : [String(v)]);
 /** Chemin réel (liens symboliques résolus) du plus proche ancêtre existant, le reste rattaché tel quel. */
 function realish(p) {
     try {
@@ -112,6 +112,7 @@ export function readPlanConfig(file, root) {
         settings.onWrite = readOnWrite(p.onWrite, root ?? dirname(resolve(file)), bad);
     if (FORMAT_KEYS.some((k) => p[k] != null))
         settings.format = parseFormat(p, bad);
+    Object.assign(settings, parseStates(p, bad, settings.format !== undefined), readExtras(p.extras, !!settings.format, bad));
     if (p.path != null && String(p.path).trim() === '')
         throw bad('path est vide');
     if (p.add != null && (typeof p.add !== 'string' || !p.add.includes('{title}')))
@@ -191,12 +192,11 @@ export function readNewsConfig(file) {
     for (const k of Object.keys(n))
         if (k !== 'publicTitleMax')
             throw new RafError(`${file} : news.${k} inconnu (attendu : publicTitleMax)`);
-    const max = n.publicTitleMax;
-    if (max == null)
+    if (n.publicTitleMax == null)
         return {};
-    if (typeof max !== 'number' || !Number.isInteger(max) || max < 1)
+    if (typeof n.publicTitleMax !== 'number' || !Number.isInteger(n.publicTitleMax) || n.publicTitleMax < 1)
         throw new RafError(`${file} : news.publicTitleMax : nombre entier de caractères (≥ 1) attendu`);
-    return { publicTitleMax: max };
+    return { publicTitleMax: n.publicTitleMax };
 }
 const AUTOSTART = ['warn', 'refuse', 'start'];
 /** Clé `hook:` de cadence.yaml. */

package/dist/deliver-lots.js

@@ -0,0 +1,37 @@
+import { isPlanOnly } from './audit.js';
+import { isAncestor, readCommits } from './git.js';
+import { citedRefs } from './link.js';
+/**
+ * Ligne des lots cités depuis la livraison précédente, ou null (première livraison, rien de cité).
+ *
+ * Plan en lecture seule : seuls les lots EN COURS sont annoncés. Ses identifiants sont de forme libre, et
+ * un message cite volontiers un numéro qui en a la forme (réserve « R1 » d'une revue) ou un lot clos
+ * nommé pour le contexte — les annoncer « livrés » ferait fermer à tort. L'état est celui du départ de
+ * la livraison : le plan a été lu avant que le script du projet ne ferme lui-même les lots qu'il livre.
+ */
+/** Lots cités par les commits livrés depuis la livraison précédente ; vide quand elle est inconnue ou hors de l'historique. */
+export function deliveredIds(ctx, prev, sha) {
+    if (!ctx.plan || !prev || prev === sha || !isAncestor(ctx.root, prev, sha))
+        return [];
+    const lots = ctx.plan.lots();
+    const known = new Set((ctx.plan.readonly ? lots.filter((l) => l.status === 'doing') : lots).map((l) => l.id));
+    const ids = new Set();
+    for (const c of readCommits(ctx.root, { range: `${prev}..${sha}` })) {
+        if (isPlanOnly(c.sha, ctx.plan, ctx.root))
+            continue; // entretien du plan : ne livre rien, même s'il cite des lots
+        for (const r of citedRefs(c, ctx.plan.refs))
+            if (known.has(r.lot))
+                ids.add(r.lot);
+    }
+    return [...ids].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+}
+export function deliveredLots(ctx, ids, prev, sha) {
+    if (!ctx.plan || !prev || prev === sha)
+        return null;
+    if (!isAncestor(ctx.root, prev, sha)) {
+        return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
+    }
+    if (ids.length === 0)
+        return null;
+    return `livré : ${ids.join(', ')} — ${ctx.plan.readonly ? "à fermer avec l'outil du projet" : 'raf done'} si l'effet est celui attendu`;
+}

package/dist/deliver.js

@@ -4,11 +4,11 @@ import { constants } from 'node:os';
 import { join, relative } from 'node:path';
 import { parse } from 'yaml';
 import { onTermination, readProcs, SIGNAL_GRACE_MS, SIGNAL_PENDING_MS, TreeTracker } from './proc.js';
-import { deliveryLots, isPlanOnly } from './audit.js';
-import { commitPaths, dirtyPaths, headSha, isAncestor, onRemote, readCommits, repoStatus, resolveCommit } from './git.js';
+import { deliveryLots } from './audit.js';
+import { commitPaths, dirtyPaths, headSha, isAncestor, onRemote, repoStatus, resolveCommit } from './git.js';
 import { planOnlySince, pollGithubCi, stamped, stepJournal } from './deliver-ci.js';
 import { PLAN_ACTIONS, planCommitMessage } from './plan-commit.js';
-import { citedRefs } from './link.js';
+import { deliveredIds, deliveredLots } from './deliver-lots.js';
 import { describeArticle, openArticleLots } from './articles.js';
 import { RafError } from './plan.js';
 import { appendDelivery, appendFailedDelivery, lastDelivery, lockAlive, lockFault, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
@@ -422,8 +422,7 @@ export async function deliver(ctx, deps) {
                 how = 'moved';
             }
         }
-        const ids = deliveredIds(ctx, lastDelivery(ctx.state), final);
-        const delivered = deliveredLots(ctx, ids, lastDelivery(ctx.state), final);
+        const prev = lastDelivery(ctx.state);
         appendDelivery(ctx.state, ctx.today, final);
         const took = `en ${Math.round((deps.now() - startedAt) / 1000)} s`;
         if (how === 'declared')
@@ -432,9 +431,7 @@ export async function deliver(ctx, deps) {
             out(stamped(deps, `✓ livré : ${final.slice(0, 7)} (tête déplacée par le script depuis ${env.CADENCE_SHORT}) ${took}`));
         else
             out(stamped(deps, `✓ livré${config.verify.length ? ' et vérifié' : ''} : ${env.CADENCE_SHORT} ${took}`));
-        if (delivered)
-            out(delivered);
-        refreshArticles(ctx, ids, final);
+        announceDelivered(ctx, prev, final);
         return 0;
     }
     finally {
@@ -504,38 +501,17 @@ async function verifyAll(ctx, deps, sha, env, step) {
     return null;
 }
 /**
- * Ligne des lots cités depuis la livraison précédente, ou null (première livraison, rien de cité).
- *
- * Plan en lecture seule : seuls les lots EN COURS sont annoncés. Ses identifiants sont de forme libre, et
- * un message cite volontiers un numéro qui en a la forme (réserve « R1 » d'une revue) ou un lot clos
- * nommé pour le contexte — les annoncer « livrés » ferait fermer à tort. L'état est celui du départ de
- * la livraison : le plan a été lu avant que le script du projet ne ferme lui-même les lots qu'il livre.
+ * Ce qui suit la ligne verte du journal, depuis la livraison verte précédente `prev` (celle d'AVANT la ligne écrite) : les lots cités
+ * par les commits livrés sont annoncés (« livré : L… »), puis le lot de l'article à rafraîchir est ouvert (L144). Partagé par deliver
+ * et par `cadence verify` (L435) : la ligne que verify écrit est une livraison, la suivante partira d'elle, les lots d'entre-deux se
+ * disent donc ici ou jamais.
  */
-/** Lots cités par les commits livrés depuis la livraison précédente ; vide quand elle est inconnue ou hors de l'historique. */
-function deliveredIds(ctx, prev, sha) {
-    if (!ctx.plan || !prev || prev === sha || !isAncestor(ctx.root, prev, sha))
-        return [];
-    const lots = ctx.plan.lots();
-    const known = new Set((ctx.plan.readonly ? lots.filter((l) => l.status === 'doing') : lots).map((l) => l.id));
-    const ids = new Set();
-    for (const c of readCommits(ctx.root, { range: `${prev}..${sha}` })) {
-        if (isPlanOnly(c.sha, ctx.plan, ctx.root))
-            continue; // entretien du plan : ne livre rien, même s'il cite des lots
-        for (const r of citedRefs(c, ctx.plan.refs))
-            if (known.has(r.lot))
-                ids.add(r.lot);
-    }
-    return [...ids].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
-}
-function deliveredLots(ctx, ids, prev, sha) {
-    if (!ctx.plan || !prev || prev === sha)
-        return null;
-    if (!isAncestor(ctx.root, prev, sha)) {
-        return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
-    }
-    if (ids.length === 0)
-        return null;
-    return `livré : ${ids.join(', ')} — ${ctx.plan.readonly ? "à fermer avec l'outil du projet" : 'raf done'} si l'effet est celui attendu`;
+export function announceDelivered(ctx, prev, sha) {
+    const ids = deliveredIds(ctx, prev, sha);
+    const delivered = deliveredLots(ctx, ids, prev, sha);
+    if (delivered)
+        ctx.out(delivered);
+    refreshArticles(ctx, ids, sha);
 }
 /**
  * Livraison verte (L144) : les lots livrés dont le titre est public changent ce que les articles externes racontent, on ouvre

package/dist/docs-ok-file.js

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { parseDocument } from 'yaml';
+import { RafError } from './plan.js';
+/** Fichier d'acquittement docs-ok d'un plan en lecture seule, relatif à la racine du dépôt (L386). */
+export const DOCS_OK_FILE = '.cadence/docs-ok.yaml';
+/** Les acquittements du fichier : lot → { date, reason }. Une entrée sans raison n'acquitte rien ; un fichier illisible est une erreur qui le nomme. */
+export function readDocsOkFile(file) {
+    if (!file || !existsSync(file))
+        return {};
+    const doc = parseDocument(readFileSync(file, 'utf8'));
+    if (doc.errors.length > 0)
+        throw new RafError(`${file} : ${doc.errors[0].message}`);
+    const raw = doc.toJSON();
+    if (raw == null)
+        return {};
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        throw new RafError(`${file} : la racine doit être un objet (lot → { date, reason })`);
+    const out = {};
+    for (const [id, v] of Object.entries(raw)) {
+        const e = v;
+        if (e && typeof e === 'object' && typeof e.reason === 'string' && e.reason.trim() !== '')
+            out[id] = { date: String(e.date ?? ''), reason: e.reason.trim() };
+    }
+    return out;
+}

package/dist/lot-lines.js

@@ -0,0 +1,51 @@
+import { gateProgress, gateText } from './audit.js';
+/** Les lignes de tête de `raf show` : titre, état détaillé (L463), objectif, dates, dépendances, drapeaux, champs d'extension (L464), acquittement docs et condition de tirage. Une ligne par fait posé, aucune pour un fait absent. */
+export function lotLines(plan, lot) {
+    const lines = [...headLines(lot), ...flagLines(lot)];
+    if (lot.docsOk)
+        lines.push(`docs-ok : ${lot.docsOk.date} — ${lot.docsOk.reason}`);
+    const gate = gateProgress(plan.lots(), lot);
+    if (lot.gate && gate)
+        lines.push(lot.gate.invalid ? `gate : ${gateText(gate)}` : `gate : ${gate.n} lots ${gate.label} faits`);
+    return lines;
+}
+function headLines(lot) {
+    const lines = [`${lot.id}  ${lot.status}  ${lot.title}`];
+    if (lot.state)
+        lines.push(`état : ${lot.state}`);
+    if (lot.goal)
+        lines.push(`goal : ${lot.goal}`);
+    const dates = [['créé', lot.created], ['démarré', lot.started], [lot.status === 'dropped' ? 'abandonné' : 'terminé', lot.finished]].filter(([, d]) => d);
+    if (dates.length)
+        lines.push(dates.map(([k, d]) => `${k} : ${d}`).join('  '));
+    if (lot.after.length)
+        lines.push(`after : ${lot.after.join(', ')}`);
+    if (lot.public)
+        lines.push(`public : ${lot.public}`);
+    return lines;
+}
+function flagLines(lot) {
+    const lines = [];
+    // L439 : le livreur lit ici si le lot est visible et s'il porte un verdict UX ; deux lignes stables, absentes d'un lot non visible.
+    if (lot.visible)
+        lines.push('visible : oui');
+    if (lot.screen)
+        lines.push(`screen : ${lot.screen}`);
+    if (lot.visible)
+        lines.push(lot.ux ? `ux : ${lot.ux.verdict}` : 'ux : absent');
+    if (lot.spec)
+        lines.push('spec : true');
+    if (lot.uses)
+        lines.push(`uses : ${lot.uses.join(', ')}`);
+    for (const [name, value] of Object.entries(lot.extras ?? {}))
+        lines.push(`${name} : ${value}`);
+    return lines;
+}
+/**
+ * Le lot tel que `raf list --json` l'exporte (L464) : les clés du fichier du plan (`docs_ok`, `state_before`, pas `docsOk` ni `stateBefore`), sans `problems` (diagnostic de `raf check`).
+ * Les noms exportés sont ceux que garantit docs/stabilite.md : renommer un champ du type interne `Lot` ne les change pas.
+ */
+export function lotJson(lot) {
+    const { docsOk, stateBefore, problems: _problems, ...rest } = lot;
+    return { ...rest, ...(docsOk ? { docs_ok: docsOk } : {}), ...(stateBefore ? { state_before: stateBefore } : {}) };
+}

package/dist/orchestrate/command.js

@@ -24,7 +24,7 @@ import { acceptationFile, acceptText, redAcceptations } from './accept.js';
 import { noTestGate, noTestText } from './no-test.js';
 import { ficheReviewText } from './fiche.js';
 import { maquetteText } from './maquette.js';
-import { costlyHypotheses, specScreen, specText } from './spec.js';
+import { budgetStage, costlyHypotheses, lightLot, specText, stageScreen } from './spec.js';
 import { fichesDuDossier } from '../spec.js';
 import { candidates, fillTargets, handedBackStreak, parsePriority, parseUntil, drawSettingsReport, readPriority, stopReason } from './continue.js';
 import { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, leadReviewedHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
@@ -320,7 +320,7 @@ export async function preflight(args, targets, io, deps, launch, opts = {}) {
         }
         const small = lot.estimate <= 0.5 || lot.quickwin;
         const goal = args.goal ?? lot.goal;
-        const screen = specScreen(t.repo, env.config.spec.dir, lot);
+        const screen = stageScreen(t.repo, env.config.spec.dir, lot, env.config.maquette);
         const state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, ...(goal ? { goal } : {}), visible: lot.visible, small, ...(screen ? { screen } : {}), ...(lot.spec && !screen ? { specLot: true } : {}), model: t.model, readOnlyPlan: plan.readonly });
         if (neighbours.repos.length)
             state.repos = neighbours.repos;
@@ -329,7 +329,7 @@ export async function preflight(args, targets, io, deps, launch, opts = {}) {
             state.express = true;
         state.light = lot.estimate <= env.config.review.threshold;
         const escalating = !!env.config.escalation;
-        state.budget = lotBudget(lot.estimate, screen ? 'screen' : lot.spec ? 'spec' : undefined, escalating);
+        state.budget = lotBudget(lot.estimate, budgetStage(lot, screen, env.config.maquette, t.repo, env.config.spec.dir), escalating);
         if (escalating)
             state.escalationReserve = ESCALATION_RESERVE;
         state.dependsOn = lot.after.filter((d) => earlier.includes(d));
@@ -442,7 +442,7 @@ function dryRun(lots, io, deps, { budget, id, multiSlot }) {
         io.out(`${lotKey(l.project, l.lot)} — ${l.title}`);
         if (l.goal)
             io.out(`  objectif donné : ${l.goal} (à la place du titre dans les briefs)`);
-        io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, l.screen ? 'screen' : l.specLot ? 'spec' : undefined, l.escalationReserve ? env.config.escalation?.model : undefined)})`);
+        io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, budgetStage(lot, l.screen, env.config.maquette, l.repo, env.config.spec.dir), l.escalationReserve ? env.config.escalation?.model : undefined)})`);
         const mine = lots.filter((o) => o.repo === l.repo);
         const together = env.config.worktrees && (mine.length > 1 || multiSlot) && !mine.some((o) => o.repos?.length) && !!repoBranch(l.repo);
         io.out(together ? `  file ${basename(l.repo)} · en parallèle des autres lots du dépôt, dans son worktree (cadence/${id}/${lotSlug(l.project, l.lot)}, créé à la prise du créneau)` : `  file ${basename(l.repo)} · ${slot < 2 ? `créneau ${slot + 1}` : 'en attente d\'un créneau'}`);
@@ -459,7 +459,7 @@ function dryRun(lots, io, deps, { budget, id, multiSlot }) {
         }
         const steps = [{ kind: 'implement', model: l.model }];
         const specStage = !!(l.screen || l.specLot);
-        if (specStage && env.config.accept)
+        if (specStage && env.config.accept && !lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir))
             steps.unshift({ kind: 'accept', model: 'sonnet' });
         if (l.screen && env.config.maquette)
             steps.unshift({ kind: 'maquette', model: env.config.review.full });
@@ -513,12 +513,12 @@ function dryRun(lots, io, deps, { budget, id, multiSlot }) {
         const vars = { chemin: l.repo, lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '', diff: 'git diff <sha de départ>..HEAD' };
         vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? env.loadPlan().lots().find((x) => x.id === lot.parent) : undefined));
         if (specStage)
-            vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, back: !!l.specLot });
+            vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, light: lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir), back: !!l.specLot });
         if (l.screen && env.config.maquette)
-            vars.maquette = maquetteText({ fiche: `${env.config.spec.dir}/<écran>/fiche.yaml`, passes: 0, max: env.config.maquetteReviews });
+            vars.maquette = maquetteText({ fiche: `${env.config.spec.dir}/<écran>/fiche.yaml`, passes: 0, max: env.config.maquetteReviews, light: lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir) });
         if (l.specLot && env.config.fiche)
             vars.fiche = ficheReviewText({ fiche: `${env.config.spec.dir}/<sujet>/fiche.yaml`, passes: 0 });
-        if (specStage && env.config.accept) {
+        if (specStage && env.config.accept && !lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir)) {
             const folder = `${env.config.spec.dir}/${l.screen ? '<écran>' : '<sujet>'}`;
             vars.accept = acceptText({ fiche: `${folder}/fiche.yaml`, maquette: `${folder}/maquette.html`, screen: !!l.screen, back: false, acceptation: acceptationFile(`${folder}/fiche.yaml`, l.lot), command: env.config.accept ?? '', test: env.config.test });
         }

package/dist/orchestrate/continue.js

@@ -9,7 +9,7 @@ import { RafError } from '../plan.js';
 import { lotBudget, projectEnv } from './command.js';
 import { readyFree } from '../ready-free.js';
 import { lotFinished, lotKey } from './state.js';
-import { specScreen } from './spec.js';
+import { budgetStage, stageScreen } from './spec.js';
 import { STOP_REQUESTED } from './cycle.js';
 /** `--until 18:00` : l'heure d'aujourd'hui (date de `now`) à partir de laquelle la vague ne tire plus de lot. */
 export function parseUntil(text, now) {
@@ -90,11 +90,13 @@ export function candidates(launch, o) {
         }
         let specDir = 'docs/specs';
         let escalating = false;
+        let maquette = true;
         let setting;
         try {
             const config = projectEnv(dir).config;
             specDir = config.spec.dir;
             escalating = !!config.escalation;
+            maquette = config.maquette;
             setting = config.continue;
         }
         catch {
@@ -108,7 +110,7 @@ export function candidates(launch, o) {
                 o.skipped?.push(`${project}:${lot.id} écarté du tirage : ${why}`);
                 continue;
             }
-            if (lotBudget(lot.estimate, specScreen(dir, specDir, lot) ? 'screen' : lot.spec ? 'spec' : undefined, escalating) > o.remaining)
+            if (lotBudget(lot.estimate, budgetStage(lot, stageScreen(dir, specDir, lot, maquette), maquette, dir, specDir), escalating) > o.remaining)
                 continue;
             out.push({ project, dir, lot });
         }