@sylad/cadence 1.6.0 → 1.8.0

package/agents/acceptance-writer.md

@@ -19,5 +19,6 @@ Follow the brief you are given. The method:
 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.
+- An acceptation file that already has `vert: true` and one fingerprint in `empreintes` for each listed test file is a green, sealed oracle: never rewrite it, its tests, `resceaux` or `empreintes`, and never touch `vert`. Write nothing, commit nothing, and hand the lot back with that finding in `questions` (a test to correct is resealed by the lead, `cadence spec reseal`). A `vert: true` file WITHOUT `empreintes` (or whose `empreintes` lack one of the listed test files) was never sealed by the program (only the cycle sets `vert`, after the seal): it proves nothing, write the oracle as the brief says, with `vert: false`.
 - 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/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', 'corrections', 'spec'].includes(tool)) {
+} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead', 'corrections', 'perf', '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'));
@@ -47,6 +47,9 @@ if (tool === 'raf') {
   cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--since 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 perf [dossier] [--since date] [--json]
+                    tableau de bord du workflow, sans modèle ni écriture : 7 derniers jours contre les 7 précédents, chaque vitesse
+                    à côté de sa qualité, ⚠ au-delà de 25 % de dégradation ; --since est un jour qui tronque les fenêtres
   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>

package/dist/audit.js

@@ -57,6 +57,7 @@ export function isPlanOnly(sha, plan, root) {
 const VERSION_JSON = /(^|\/)(package\.json|package-lock\.json|\.claude-plugin\/(plugin|marketplace)\.json)$/;
 const CHANGELOG = /(^|\/)CHANGELOG\.md$/;
 const README = /^README\.md$/;
+const WHATS_NEW = /^docs\/whats-new\.md$/;
 /** Le README sans sa section « What's new », rangée par version et donc réécrite à la release. */
 function withoutWhatsNew(text) {
     return (text ?? '').replace(/^## What's new\s*$[\s\S]*?(?=^## |(?![\s\S]))/m, '');
@@ -81,17 +82,17 @@ function withoutVersion(text) {
 }
 /**
  * Commit de version (L72) : TOUS ses fichiers sont des fichiers de version — package.json, package-lock.json,
- * .claude-plugin/plugin.json et marketplace.json, où seule la `version` change, et CHANGELOG.md, plus la section « What's new » du README (seule). Il clôt le lot
+ * .claude-plugin/plugin.json et marketplace.json, où seule la `version` change, et CHANGELOG.md, plus la section « What's new » du README (seule) et docs/whats-new.md, sa forme longue (L232). Il clôt le lot
  * après sa revue : l'exiger relu rouvrirait la porte à chaque release. Les fichiers décident, jamais le sujet.
  */
 export function isReleaseOnly(sha, root) {
     const files = changedFiles(root, sha);
     // Les noms d'abord : un fichier hors version refuse le commit sans qu'aucun contenu ne soit lu.
-    if (!files.length || !files.every((f) => CHANGELOG.test(f) || README.test(f) || VERSION_JSON.test(f)))
+    if (!files.length || !files.every((f) => CHANGELOG.test(f) || WHATS_NEW.test(f) || README.test(f) || VERSION_JSON.test(f)))
         return false;
     return (files.length > 0 &&
         files.every((f) => {
-            if (CHANGELOG.test(f))
+            if (CHANGELOG.test(f) || WHATS_NEW.test(f))
                 return true;
             if (README.test(f))
                 return withoutWhatsNew(fileAt(root, `${sha}^`, f)) === withoutWhatsNew(fileAt(root, sha, f));

package/dist/cli.js

@@ -2,7 +2,7 @@ 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 { readDocsConfig, readHookConfig, readNewsConfig, readOrchestrateConfig, readPlanConfig, readSessionConfig } from './config.js';
+import { readDocsConfig, readHookConfig, readNewsConfig, readOrchestrateConfig, readPerfConfig, readPlanConfig, readSessionConfig } from './config.js';
 import { repoSections, repoShas, resolveLotRepos } from './repos.js';
 import { audit, exemptPlanOnly, gateProgress, gateText, gateWaiting, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
@@ -22,7 +22,8 @@ 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 { classifyAll, measure, ollamaClassifier, readCache, readJournals, readRuns, renderReport, sampleKeys, serializeCache } from './corrections.js';
+import { computePerf, perfHeader, perfWindows, readPlans, readProjectDeliveries, readProjectFailedDeliveries, renderPerf } from './perf.js';
 import { findAcceptation, parseAcceptation, resealAcceptation } from './orchestrate/accept.js';
 import { checkFiche, deriveQa, readFiche, summary } from './spec.js';
 import { readHudContext } from './hud-context.js';
@@ -52,8 +53,9 @@ 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] [--budget projet:lot=+300k] [--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 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), précédées de l'en-tête perf : une ligne par ⚠ de cadence perf, rien si tout est stable
   cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--since 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 perf [dossier] [--since date] [--json]   tableau de bord du workflow, sans modèle : deux fenêtres (7 derniers jours contre les 7 précédents) lues dans dossier/.cadence/runs et les plans, chaque vitesse à côté de sa qualité, ⚠ au-delà de 25 % de dégradation ; tokens par lot selon l'estimate, part de la revue, délais création → done → livraison, durée de mur par étape, coût en euros par lot livré (grille cadence.yaml perf.prices) ; --since est un jour qui tronque les fenêtres
   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 … »)
 
@@ -66,7 +68,7 @@ publié par exemple, ainsi que le fichier d'attendus QA : docs/qa/expectations.m
 Un lot --visible attend une entrée Nouveautés (docs/nouveautes/, --dir) avec capture ; raf check le vérifie.
 Un texte qui commence par « - » se passe après « -- » : raf note L1 -- "-5 %".
 Le plan est docs/plan/raf.yaml, ou celui que nomme « plan: » dans cadence.yaml ; un plan tenu par un
-autre outil se lit sans migration (correspondance des champs, voir le README) et reste en lecture seule.
+autre outil se lit sans migration (correspondance des champs, voir docs/raf.md du paquet @sylad/cadence) et reste en lecture seule.
 Options communes : --file chemin (ou RAF_FILE), RAF_TODAY=AAAA-MM-JJ pour figer la date.`;
 /** Ajoute `line` au .gitignore de `root` s'il n'y est pas déjà (avec ou sans `/` initial ou final). Rend vrai si écrit. */
 export function ensureGitignore(root, line) {
@@ -178,6 +180,14 @@ function dispatch(argv, io) {
         else if (rows.length === 0)
             io.out(`aucun projet sous ${parent} (docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
         else {
+            // L'en-tête perf (L227) : un ⚠ par ligne avant les projets ; un dossier que perf ne lit pas n'en donne pas, et ses avertissements ne sont pas repris.
+            try {
+                for (const l of perfHeader(readPerf(parent, today, undefined, () => { })))
+                    io.out(l);
+            }
+            catch {
+                // pas de .cadence/runs, grille de prix mal formée, journaux ou plans illisibles : le tour ne change pas
+            }
             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)
@@ -199,6 +209,8 @@ function dispatch(argv, io) {
     }
     if (command === 'corrections')
         return corrections(rest, values, io);
+    if (command === 'perf')
+        return perf(rest, values, today, 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);
@@ -512,7 +524,7 @@ function dispatch(argv, io) {
             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)`);
+                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;
@@ -525,7 +537,7 @@ function dispatch(argv, io) {
             if (!gitRoot(io.cwd))
                 throw new RafError('verify : à lancer dans un dépôt git');
             if (!existsSync(configPath))
-                throw new RafError(`pas de configuration : ${configPath} (voir « cadence.yaml » dans le README)`);
+                throw new RafError(`pas de configuration : ${configPath} (voir « cadence.yaml » dans docs/deliver.md du paquet @sylad/cadence)`);
             const retry = values.retry === undefined ? 0 : Number(values.retry);
             if (!Number.isFinite(retry) || retry < 0)
                 throw new RafError(`--retry invalide : ${values.retry} (secondes, 0 ou plus)`);
@@ -866,7 +878,7 @@ function specReseal(args, reason, porteur, ctx, io) {
     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, plan.refs);
+        r = resealAcceptation(repo, json, test, reason, ctx.today, livre ? porteur : undefined, plan.refs, plan.lots().filter((l) => l.status === 'done').map((l) => l.id));
     }
     catch (e) {
         throw new RafError(e.message);
@@ -984,6 +996,55 @@ async function corrections(rest, values, io) {
     io.out(values.json ? JSON.stringify(m, null, 2) : renderReport(m));
     return 0;
 }
+/**
+ * `cadence perf` (L225) : le tableau de bord du workflow, sans modèle ni écriture, lu dans <dossier>/.cadence/runs et les plans des projets du dossier.
+ * Une erreur de saisie ou de lecture sort avec le code 1 (un ⚠ imprimé, 0). `--since` y est un jour qui tronque les fenêtres, non l'instant de `corrections --since`.
+ */
+/** `cadence perf` sur un dossier : lecture seule, une RafError dit pourquoi le dossier n'est pas lisible ; `warn` reçoit les avertissements (stderr de perf). */
+function readPerf(parent, today, since, warn) {
+    // La grille se lit avant tout journal : une grille mal formée refuse la commande sans sortie partielle (R7).
+    const prices = readPerfConfig(join(parent, 'cadence.yaml'));
+    const runsDir = join(parent, '.cadence', 'runs');
+    if (!existsSync(runsDir))
+        throw new RafError(`perf : aucun journal de vague dans ${runsDir}`);
+    const cache = readCache(join(parent, '.cadence', 'corrections.json'));
+    const journals = readJournals(runsDir);
+    const warnings = [];
+    const plans = readPlans(parent, (l) => warnings.push(l));
+    if (plans.size === 0 && warnings.length === 0)
+        warnings.push(`perf : aucun plan sous ${parent}, indicateurs du plan n/d`);
+    const deliveries = readProjectDeliveries(parent, [...plans.keys()]);
+    const failedDeliveries = readProjectFailedDeliveries(parent, [...plans.keys()]);
+    const result = computePerf({ journals, plans, cache, deliveries, failedDeliveries, prices, windows: perfWindows(today, since), today, since });
+    if (!prices)
+        warnings.push('perf : aucune grille de prix (cadence.yaml perf.prices), coût en euros n/d');
+    for (const [model, lots] of Object.entries(result.cost.withoutPrice))
+        warnings.push(`perf : modèle sans prix dans perf.prices : ${model}, coût n/d pour ${lots} lot(s)`);
+    warnings.forEach(warn);
+    return result;
+}
+function perf(rest, values, today, io) {
+    try {
+        if (rest.length > 1)
+            throw new RafError('usage : cadence perf [dossier] [--since date] [--json]');
+        if (values.since !== undefined && Number.isNaN(Date.parse(values.since)))
+            throw new RafError(`--since invalide : ${values.since} (une date ISO, ex. 2026-10-10T18:31Z)`);
+        const parent = resolve(io.cwd, rest[0] ?? '.');
+        const result = readPerf(parent, today, values.since, io.err);
+        if (values.json)
+            io.out(JSON.stringify(result, null, 2));
+        else
+            for (const l of renderPerf(result))
+                io.out(l);
+        return 0;
+    }
+    catch (e) {
+        if (!(e instanceof RafError))
+            throw e;
+        io.err(`raf: ${e.message}`);
+        return 1;
+    }
+}
 /** `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];

package/dist/config.js

@@ -178,6 +178,52 @@ export function readHookConfig(file) {
         throw new RafError(`${file} : hook.autostart : ${AUTOSTART.join(', ')} attendu`);
     return { autostart: a };
 }
+const PRICED_MODELS = ['sonnet', 'opus', 'haiku'];
+const PRICE_KEYS = ['input', 'output', 'cacheRead'];
+/** Clé `perf.prices` de cadence.yaml : la grille de prix du coût par lot livré ; null sans grille (clé absente ou vide). */
+export function readPerfConfig(file) {
+    if (!existsSync(file))
+        return null;
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const perf = raw?.perf;
+    if (perf == null)
+        return null;
+    if (!isObject(perf))
+        throw new RafError(`${file} : perf doit être un objet { prices }`);
+    for (const k of Object.keys(perf))
+        if (k !== 'prices')
+            throw new RafError(`${file} : perf.${k} inconnu (attendu : prices)`);
+    const prices = perf.prices;
+    if (prices == null)
+        return null;
+    if (!isObject(prices))
+        throw new RafError(`${file} : perf.prices doit être un objet { ${PRICED_MODELS.join(', ')} }`);
+    const grid = {};
+    for (const [model, price] of Object.entries(prices)) {
+        if (!PRICED_MODELS.includes(model))
+            throw new RafError(`${file} : perf.prices.${model} inconnu (attendu : ${PRICED_MODELS.join(', ')})`);
+        if (!isObject(price))
+            throw new RafError(`${file} : perf.prices.${model} doit être un objet { ${PRICE_KEYS.join(', ')} }`);
+        for (const k of Object.keys(price))
+            if (!PRICE_KEYS.includes(k))
+                throw new RafError(`${file} : perf.prices.${model}.${k} inconnu (attendu : ${PRICE_KEYS.join(', ')})`);
+        const entry = {};
+        for (const k of PRICE_KEYS) {
+            const v = price[k];
+            if (typeof v !== 'number' || !Number.isFinite(v) || v < 0)
+                throw new RafError(`${file} : perf.prices.${model}.${k} : nombre ≥ 0 attendu (€ par million de tokens)`);
+            entry[k] = v;
+        }
+        grid[model] = entry;
+    }
+    return Object.keys(grid).length === 0 ? null : grid;
+}
 /**
  * Clé `session:` de cadence.yaml : les faits propres au projet (son script de reprise, de clôture),
  * joués par cadence au lieu d'être remplacés.

package/dist/corrections.js

@@ -14,7 +14,7 @@ const LABELS = {
     'sans-constat': 'sans revue (tests rouges)',
     'non-classe': 'non classé',
 };
-const isReview = (kind) => kind.startsWith('review') || kind === 'ux';
+export const isReview = (kind) => kind.startsWith('review') || kind === 'ux';
 function readJson(file) {
     try {
         return JSON.parse(readFileSync(file, 'utf8'));
@@ -37,15 +37,21 @@ function findingsOf(report) {
     const list = Array.isArray(body?.constats) ? body.constats : [];
     return list.map((c) => (typeof c === 'string' ? c : c?.texte)).filter((t) => typeof t === 'string' && t.length > 0);
 }
+const USAGE_KEYS = ['input', 'cacheWrite', 'cacheRead', 'output'];
+/** Les quatre compteurs d'une étape quand ce sont tous des nombres. */
+function usageOf(tokens) {
+    if (!tokens || !USAGE_KEYS.every((k) => typeof tokens[k] === 'number'))
+        return undefined;
+    return { input: tokens.input, cacheWrite: tokens.cacheWrite, cacheRead: tokens.cacheRead, output: tokens.output };
+}
 /**
- * Lit les journaux de vague `<runs>/<vague>/<projet>--<lot>.json`. Un lot compte (dénominateur) dès qu'une session
- * d'écriture a abouti (`until` : date ISO, ne lit que les vagues créées jusque-là et, dans chacune, les étapes terminées (`ended`) jusque-là, pour une mesure que ni les vagues suivantes ni une vague encore en cours ne changent ; une vague ou une étape sans date lisible est écartée ; `since` : date ISO, ne garde que les lots des vagues créées strictement après, avec toutes leurs passes : une vague rend tous ses briefs depuis la copie de l'outil figée à sa création, c'est la date de la vague, non celle du début d'un lot, qui dit quel brief il a reçu, sauf pour une vague reprise sans instantané ou, avec `--budget projet:lot=+N`, depuis un instantané d'avant L223 : elle tourne alors avec le dist/ et les gabarits courants ; `--until` plus `--since` ne font le total sans borne que si aucune vague créée avant la borne n'est encore reprenable) ; chaque pas `fix` abouti est une passe, rattachée aux constats de la dernière revue qui la précède.
+ * Lit TOUS les journaux de vague `<runs>/<vague>/<projet>--<lot>.json` lisibles (seuls un journal sans `steps` lisible ou, sous `until` ou `since`, une vague sans date de création lisible sont écartés) : c'est la lecture que partagent `readRuns` et `cadence perf` (L225), le filtre « session implement aboutie » n'est pas ici mais dans leurs prédicats (`implemented`). Chaque pas `fix` abouti est une passe, rattachée aux constats de la dernière revue qui la précède.
+ * `until` : date ISO, ne lit que les vagues créées jusque-là et, dans chacune, les étapes terminées (`ended`) jusque-là ; une vague ou une étape sans date lisible est écartée. `since` : date ISO, ne garde que les vagues créées strictement après.
  */
-export function readRuns(runsDir, until, since) {
-    const lots = [];
-    const passes = [];
+export function readJournals(runsDir, until, since) {
+    const journals = [];
     if (!existsSync(runsDir))
-        return { lots, passes };
+        return journals;
     const limit = until === undefined ? Infinity : Date.parse(until);
     const from = since === undefined ? undefined : Date.parse(since);
     // Sous `until`, une étape compte si elle est terminée avant la date ; sans date de fin lisible, elle est écartée.
@@ -54,15 +60,16 @@ export function readRuns(runsDir, until, since) {
         const waveDir = join(runsDir, wave);
         if (!statSync(waveDir).isDirectory())
             continue;
-        if (until !== undefined || from !== undefined) {
-            // Les vagues nommées à la main (ol-gains-1) n'ont pas d'horodatage dans leur nom : on lit `created` dans wave.json.
-            const created = Date.parse(readJson(join(waveDir, 'wave.json'))?.created);
-            if (until !== undefined && !(created <= limit))
-                continue;
-            // `since` est strict : une vague créée pile à la borne reste dans l'avant de `until` (inclusif), les deux mesures ne se recouvrent jamais ; sans date de création lisible, la vague est dans aucune.
-            if (from !== undefined && !(created > from))
-                continue;
-        }
+        const waveJson = readJson(join(waveDir, 'wave.json'));
+        // Les vagues nommées à la main (ol-gains-1) n'ont pas d'horodatage dans leur nom : on lit `created` dans wave.json.
+        const created = Date.parse(waveJson?.created);
+        if (until !== undefined && !(created <= limit))
+            continue;
+        // `since` est strict : une vague créée pile à la borne reste dans l'avant de `until` (inclusif), les deux mesures ne se recouvrent jamais ; sans date de création lisible, la vague est dans aucune.
+        if (from !== undefined && !(created > from))
+            continue;
+        const waveReadable = waveJson !== null && typeof waveJson === 'object';
+        const waveCreated = Number.isNaN(created) ? undefined : waveJson.created;
         for (const file of readdirSync(waveDir).sort()) {
             if (!file.endsWith('.json') || file === 'wave.json')
                 continue;
@@ -71,20 +78,48 @@ export function readRuns(runsDir, until, since) {
                 continue;
             const steps = rec.steps.filter((s) => s && typeof s === 'object');
             const done = (s) => s.status === 'ok' && inTime(s);
-            if (!steps.some((s) => s.kind === 'implement' && done(s)))
-                continue;
             const name = basename(file, '.json');
             const fixSteps = steps.filter((s) => s.kind === 'fix' && done(s));
-            lots.push({ project: rec.project, lot: rec.lot, visible: !!rec.visible, fixes: fixSteps.length });
-            for (const fix of fixSteps) {
+            const passes = fixSteps.map((fix) => {
                 const review = [...steps].reverse().find((s) => s.n < fix.n && isReview(s.kind) && s.report);
                 // Une passe fix entre la revue et celle-ci a déjà traité ces constats : cette passe-ci (tests rouges) n'en a pas.
                 const handled = review ? fixSteps.some((f) => f.n > review.n && f.n < fix.n) : false;
                 const findings = review?.report && !handled ? findingsOf(readJson(join(waveDir, name, review.report))) : [];
-                passes.push({ key: `${wave}/${name}/${fix.n}`, project: rec.project, lot: rec.lot, visible: !!rec.visible, findings, commits: fix.commits ?? [] });
-            }
+                return { key: `${wave}/${name}/${fix.n}`, project: rec.project, lot: rec.lot, visible: !!rec.visible, findings, commits: fix.commits ?? [], ...(fix.ended ? { fixEnded: fix.ended } : {}) };
+            });
+            journals.push({
+                wave,
+                ...(waveCreated ? { waveCreated } : {}),
+                waveReadable,
+                project: rec.project,
+                lot: rec.lot,
+                visible: !!rec.visible,
+                status: String(rec.status),
+                ...(typeof rec.budget === 'number' ? { budget: rec.budget } : {}),
+                steps: steps.map((s) => {
+                    const usage = usageOf(s.tokens);
+                    return { n: s.n, kind: s.kind, status: s.status, ...(typeof s.model === 'string' ? { model: s.model } : {}), ...(s.started ? { started: s.started } : {}), ...(s.ended ? { ended: s.ended } : {}), ...(typeof s.tokens?.counted === 'number' ? { counted: s.tokens.counted } : {}), ...(usage ? { usage } : {}) };
+                }),
+                implemented: steps.some((s) => s.kind === 'implement' && done(s)),
+                passes,
+            });
         }
     }
+    return journals;
+}
+/**
+ * Les lots et passes de correction des journaux de `<runs>`. Un lot compte (dénominateur) dès qu'une session d'écriture a abouti (`until` : date ISO, ne lit que les vagues créées jusque-là et, dans chacune, les étapes terminées (`ended`) jusque-là, pour une mesure que ni les vagues suivantes ni une vague encore en cours ne changent ; `since` : date ISO, ne garde que les lots des vagues créées strictement après, avec toutes leurs passes : une vague rend tous ses briefs depuis la copie de l'outil figée à sa création, c'est la date de la vague, non celle du début d'un lot, qui dit quel brief il a reçu, sauf pour une vague reprise sans instantané ou, avec `--budget projet:lot=+N`, depuis un instantané d'avant L223 : elle tourne alors avec le dist/ et les gabarits courants ; `--until` plus `--since` ne font le total sans borne que si aucune vague créée avant la borne n'est encore reprenable).
+ */
+export function readRuns(runsDir, until, since) {
+    const lots = [];
+    const passes = [];
+    for (const j of readJournals(runsDir, until, since)) {
+        if (!j.implemented)
+            continue;
+        lots.push({ project: j.project, lot: j.lot, visible: j.visible, fixes: j.passes.length });
+        for (const { fixEnded: _ended, ...pass } of j.passes)
+            passes.push(pass);
+    }
     return { lots, passes };
 }
 const tally = () => ({ lots: 0, atLeast1: 0, atLeast2: 0, passes: 0 });

package/dist/deliver.js

@@ -7,7 +7,7 @@ import { headSha, isAncestor, onRemote, readCommits, repoStatus, resolveCommit }
 import { citedRefs } from './link.js';
 import { describeArticle, openArticleLots } from './articles.js';
 import { RafError } from './plan.js';
-import { appendDelivery, lastDelivery, lockAlive, lockFault, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
+import { appendDelivery, appendFailedDelivery, lastDelivery, lockAlive, lockFault, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
 const POLL_CI = 15_000;
 const CI_APPEAR = 300_000;
 /** Intervalle de réessai d'une vérification : celui de deliver ET de `cadence verify --retry`. */
@@ -260,6 +260,13 @@ export async function deliver(ctx, deps) {
     try {
         const fail = (msg) => {
             err(`deliver : ${msg}`);
+            // Une livraison rouge s'inscrit au journal des rouges (perf) ; son écriture ne change ni le code ni le message d'échec.
+            try {
+                appendFailedDelivery(ctx.state, ctx.today, sha, msg);
+            }
+            catch (e) {
+                err(`deliver : journal des livraisons rouges non écrit : ${e.message}`);
+            }
             return 1;
         };
         out(`Livraison de ${env.CADENCE_SHORT} (${branch})`);

package/dist/orchestrate/accept.js

@@ -126,9 +126,9 @@ export function sealAcceptation(repo, path) {
  * ne laisse aucun chemin de correction. Seule l'empreinte du test nommé est refaite (les autres fichiers listés restent inchangés), la raison et les deux
  * empreintes vont dans `resceaux`. Le commit (test + acceptation) est à faire : il devient le commit rouge.
  * La fiche est celle du commit rouge, ou (L217) une fiche amendée par des commits qui citent tous le lot (`refsOf` : `plan.refs`, lu comme `citedRefs` ;
- * lot livré : le lot ou son `porteur`) et commitée : l'entrée porte alors `ficheAmendee`, le sha court du dernier commit qui l'a touchée.
+ * lot livré : le lot, son `porteur` ou, L229, l'un des `livres`, les lots done du plan — la fiche vivante fait foi) et commitée : l'entrée porte alors `ficheAmendee`, le sha court du dernier commit qui l'a touchée.
  */
-export function resealAcceptation(repo, path, test, reason, today, porteur, refsOf = () => []) {
+export function resealAcceptation(repo, path, test, reason, today, porteur, refsOf = () => [], livres = []) {
     const file = join(repo, path);
     const a = parseAcceptation(readFileSync(file, 'utf8'));
     if (typeof a === 'string')
@@ -156,9 +156,13 @@ export function resealAcceptation(repo, path, test, reason, today, porteur, refs
     if (!gitOk(repo, 'diff', '--quiet', red, '--', a.fiche)) {
         if (!existsSync(join(repo, a.fiche)))
             throw new Error(`la fiche ${a.fiche} a été supprimée ou renommée depuis le commit rouge ${red.slice(0, 7)} : le rescellé ne vaut que pour une fiche présente`);
-        const citant = new Set([a.lot, ...(porteur ? [porteur] : [])]);
+        const citant = new Set([a.lot, ...(porteur ? [porteur, ...livres] : [])]);
         const commits = git(repo, 'log', '--format=%H%x1f%s%x1f%b%x1e', `${red}..HEAD`, '--', a.fiche).split('\x1e').map((r) => r.replace(/^\n/, '')).filter(Boolean).map((r) => { const [sha = '', subject = '', body = ''] = r.split('\x1f'); return { sha, day: '', subject, body: body.trim() }; });
         const fautif = commits.find((c) => !citedRefs(c, refsOf).some((r) => citant.has(r.lot)));
+        if (fautif && porteur) {
+            const cites = [...new Set(citedRefs(fautif, refsOf).map((r) => r.lot))];
+            throw new Error(`la fiche ${a.fiche} a été modifiée depuis le commit rouge ${red.slice(0, 7)} par un commit qui ne cite ni ${a.lot}, ni le porteur ${porteur}, ni un lot livré : ${fautif.sha.slice(0, 7)} (cite : ${cites.length ? cites.join(', ') : 'aucun lot'}) — faire citer le porteur ou un lot livré par ce commit (le réécrire avant qu'il soit poussé) ou, sinon, rescelle à la main avec le lead`);
+        }
         if (fautif)
             throw new Error(`la fiche ${a.fiche} a été modifiée depuis le commit rouge ${red.slice(0, 7)} par un commit qui ne cite pas ${a.lot} : ${fautif.sha.slice(0, 7)}`);
         ficheAmendee = commits[0]?.sha.slice(0, 7);
@@ -405,6 +409,7 @@ export function acceptText(o) {
         isAcceptList(o.command)
             ? `The project declares several dedicated commands (\`orchestrate.accept\`, one per test runner), each of which runs ONLY the acceptance tests of this lot that sit under its root (the folder of its leading \`cd <folder> &&\`, else the repository): ${commands.map((x) => `\`${x}\` (root \`${acceptRoot(x) || '.'}\`)`).join(', ')}. Each is run from the repository root and gets \`CADENCE_ACCEPTATION\` (the absolute path of the lot's \`acceptation.json\`, also substituted for \`{acceptation}\`) and \`CADENCE_ACCEPTATION_ROOT\` (its root); it takes only the files listed under its root, a command with no listed file under its root is not run, and a listed file under no root is refused. Put each test file where its runner looks, and list every file in \`fichiers\`.${o.test ? ` The project's ordinary test command is \`${o.test}\`: it must stay green with your red tests committed.` : ''}`
             : `The project declares the dedicated command that runs ONLY the acceptance tests of this lot (\`orchestrate.accept\`): \`${commands[0]}\` (from the repository root; the program sets \`CADENCE_ACCEPTATION\` to the absolute path of the lot's \`acceptation.json\`, and replaces \`{acceptation}\` with it).${o.test ? ` The project's ordinary test command is \`${o.test}\`: it must stay green with your red tests committed.` : ''}`,
+        `If \`${o.acceptation}\` already exists with \`vert: true\` and \`empreintes\`, the lot's oracle is green and sealed: never rewrite it, nor its tests, \`resceaux\` or \`empreintes\`, and never set \`vert\` (a corrected test is resealed by the lead, \`cadence spec reseal\`). Write nothing, commit nothing, and hand the lot back with that finding in \`questions\`. A \`vert: true\` file WITHOUT \`empreintes\` (or whose \`empreintes\` lack one of the listed test files) was never sealed by the program (only the cycle sets \`vert\`, after the seal): it proves nothing, so write the oracle as described below, with \`vert: false\`.`,
         `Write \`${o.acceptation}\` (one file per lot, next to the sheet: another lot on the same ${screen ? 'screen' : 'subject'} has its own, which you never touch, nor its tests — give your test files names of your own): \`{ "lot": "<lot>", "fiche": "${o.fiche}", "fichiers": ["<test file>", …], "vert": false }\` (paths relative to the repository). If the tests need a build or a browser (Playwright, Chromium, \`dist\`), add \`"e2e": true\` to it: those files then stay out of the ordinary runner and the unit CI even once green (they would turn it red without \`dist\` or Chromium) and belong to the project's e2e suite, run after the build (\`acceptationE2e()\` of the runner template lists them). The ordinary test config of the project (shared with its CI) must exclude those files while \`vert\` is false; the dedicated config includes only them. Both read the file with this runner template (copy it into the project, e.g. \`tests/acceptation-runner.mjs\`):`,
     ];
     if (o.runner)

package/dist/orchestrate/briefs.js

@@ -24,7 +24,7 @@ export function reposText(role, lot, repos) {
         `\`raf commits ${lot}\` lists them all; read the diff of the neighbouring ones with \`git -C <path> log\` / \`git -C <path> show\` (${repos.map((r) => `git -C ${r.path} log`).join(' ; ')}), and review them like the rest. You are read-only there too.`,
     ].join('\n');
 }
-/** Consigne d'implémentation d'un lot `visible` : son entrée Nouveautés (convention de `cadence news`, voir le README). */
+/** Consigne d'implémentation d'un lot `visible` : son entrée Nouveautés (convention de `cadence news`, voir docs/news.md du paquet @sylad/cadence). */
 export function newsText(lot, captureDir) {
     return [
         `This lot is visible: write its News entry. Run \`cadence news new ${lot}\` (it creates \`docs/nouveautes/<date>-<slug>.md\`), then write the text in terms of what changes for the user, factual (what the user sees or can now do, no implementation detail, no promise).`,

package/dist/orchestrate/command.js

@@ -486,6 +486,9 @@ export async function orchestrate(argv, io, deps) {
         throw new RafError('--status ne se combine pas avec --drop / --stop-after-current');
     if (args.resume !== undefined && args.stopAfterCurrent)
         throw new RafError('--resume ne se combine pas avec --stop-after-current (il reprend la vague, il ne l\'arrête pas)');
+    // L228 : la reprise n'a pas de simulation — elle relève le budget, réécrit wave.json et relance les sessions. Refusée ici, avant le réexec de l'instantané (une vague ancienne ne connaît pas ce refus).
+    if (args.resume !== undefined && args.dryRun)
+        throw new RafError('--resume ne se combine pas avec --dry-run (la reprise écrit l\'état de la vague et relance les sessions, elle ne se simule pas)');
     if (args.lotBudgets.length && args.resume === undefined)
         throw new RafError("--budget projet:lot=+N ne vaut qu'avec --resume");
     if (args.since !== undefined && !args.waits)

package/dist/orchestrate/cycle.js

@@ -1079,9 +1079,11 @@ function codeAfterFiche(c, fiche) {
 /** L'acceptation du lot : celle que git suit déjà pour lui (même un ancien `acceptation.json`), sinon `acceptation-<lot>.json` à côté de la fiche. */
 const lotAcceptation = (c, fiche) => findAcceptation(c.lot.repo, c.config.spec.dir, c.lot.lot) ?? acceptationFile(fiche, c.lot.lot);
 const listed = (c, json) => existsSync(join(c.lot.repo, json));
+/** Une acceptation porte-t-elle une empreinte par fichier listé ? Le contenu n'est pas comparé (L233) : `empreintes: {}` ou celles d'un autre fichier ne scellent rien. */
+const hasSeals = (doc) => !!doc.empreintes && doc.fichiers.every((f) => !!doc.empreintes[posix.normalize(f)]);
 /**
- * Une acceptation conforme et SCELLÉE par le programme (empreintes posées), rouge ou verte (`vert: true`, lot relancé dans une nouvelle vague) :
- * elle n'a pu être écrite qu'après la revue de la maquette et les tests rouges, qui ne sont donc pas rejoués. Sans `orchestrate.accept`, aucune preuve.
+ * Une acceptation conforme et SCELLÉE par le programme (empreintes posées), rouge ou verte (`vert: true`, lot relancé dans une nouvelle vague ; une verte et scellée vaut
+ * preuve même si son scellé ne tient plus, L233) : elle n'a pu être écrite qu'après la revue de la maquette et les tests rouges, qui ne sont donc pas rejoués. Sans `orchestrate.accept`, aucune preuve.
  */
 function acceptationProof(c, fiche) {
     const l = c.lot;
@@ -1089,18 +1091,24 @@ function acceptationProof(c, fiche) {
     if (!c.config.accept || !listed(c, json))
         return false;
     const doc = parseAcceptation(readFileSync(join(l.repo, json), 'utf8'));
-    if (typeof doc === 'string' || !doc.empreintes)
+    if (typeof doc === 'string')
         return false;
+    // Un lot déjà vert (L233) n'a plus d'oracle à écrire : le cycle seul a pu poser `vert: true`, après le scellé et les tests rouges. Même une preuve qui ne tient plus
+    // (test rescellé ou corrigé depuis, fiche amendée) ne renvoie jamais à accept, qui réécrirait un oracle vert et exigerait des tests rouges : le lot part à implement ou à la revue.
+    // Une verte porte une empreinte par fichier listé, sinon elle n'a jamais été scellée (`empreintes: {}` ou celles d'un autre fichier ne prouvent rien).
+    if (!hasSeals(doc))
+        return false;
+    if (doc.vert)
+        return true;
     // Le scellé n'est posé que par le programme : chaque fichier listé doit porter l'empreinte git de son contenu actuel (une clé `empreintes` vide ou copiée d'un autre lot ne prouve rien).
-    const emp = doc.empreintes;
+    const emp = doc.empreintes ?? {};
     const sealed = doc.fichiers.every((f) => {
         const norm = posix.normalize(f);
         return existsSync(join(l.repo, norm)) && emp[norm] === git(l.repo, 'hash-object', '--', norm).trim();
     });
     if (!sealed)
         return false;
-    const vertMsg = checkAcceptation(l.repo, json, l.lot, fiche).filter((p) => !(doc.vert && p.includes('vert: true à l\'écriture')));
-    return vertMsg.length === 0;
+    return checkAcceptation(l.repo, json, l.lot, fiche).length === 0;
 }
 /** Chemins salis par une session : suivis modifiés, nouveaux fichiers non suivis, et ceux des dépôts voisins. */
 function dirtAfter(done) {
@@ -1399,6 +1407,34 @@ async function acceptProblems(c, fiche, json, headBefore) {
     }
     return out;
 }
+/**
+ * Écart de l'acceptation verte et scellée `json` par rapport à ce qu'elle était à `first` (tête d'avant la première session accept du lot), ou null.
+ * Admis : le même contenu, ou un rescellé du lead (`cadence spec reseal`, L200) : `vert` et `empreintes` toujours posés, journal `resceaux` allongé, aucun commit
+ * du fichier dans une session de la vague, fichier propre. Tout le reste (vert: false, journal effacé, réécriture commitée par la session) est rendu au lead (L233).
+ */
+function greenDrift(c, json, first, before, was) {
+    const l = c.lot;
+    if (!listed(c, json))
+        return 'acceptation.json supprimé depuis la première session accept (verrou des tests d\'acceptation)';
+    const text = readFileSync(join(l.repo, json), 'utf8');
+    // `before` vient de git() qui rogne les blancs de fin, le fichier écrit par le programme finit par un saut de ligne : les deux se comparent rognés.
+    if (text.trim() === before.trim())
+        return null;
+    const now = parseAcceptation(text);
+    const dirty = git(l.repo, 'status', '--porcelain', '--', json).trim() !== '';
+    let bySession = false;
+    try {
+        const mine = waveCommits(c, l.repo);
+        bySession = git(l.repo, 'log', '--format=%H', `${first}..HEAD`, '--', json).split('\n').some((sha) => sha && mine(sha));
+    }
+    catch {
+        bySession = true;
+    }
+    const journal = (a) => a.resceaux?.length ?? 0;
+    if (typeof now !== 'string' && now.vert && now.empreintes && journal(now) > journal(was) && !bySession && !dirty)
+        return null;
+    return 'acceptation verte réécrite depuis la première session accept (vert, empreintes ou resceaux changés ; seul un rescellé du lead, `cadence spec reseal`, est admis) : remettre le fichier comme avant la session, par exemple `git checkout <commit vert> -- <fichier>` puis `--resume`';
+}
 /**
  * Étape accept (L173, spec etape-spec S5) : une session distincte de l'implémenteur écrit, depuis la fiche et la maquette seules, les tests
  * d'acceptation rouges. Le programme vérifie (acceptation.json conforme, autres lots intacts, commande dédiée rouge, config.test verte),
@@ -1413,6 +1449,32 @@ async function acceptStep(c) {
         return;
     }
     const json = lotAcceptation(c, fiche);
+    // Un lot déjà vert et scellé (L233) n'a plus d'oracle à écrire, même quand `next` vaut encore accept (question posée pendant accept, puis réponse du lead) : jamais de session accept.
+    // Le fichier est lu tel qu'il était avant la première session accept du lot : la seconde passe voit le fichier écrit par la session, qui ne doit pas être vert (checkAcceptation).
+    const first = l.steps.find((s) => s.kind === 'accept')?.headBefore;
+    let text = null;
+    try {
+        text = first ? git(l.repo, 'show', `${first}:${json}`) : listed(c, json) ? readFileSync(join(l.repo, json), 'utf8') : null;
+    }
+    catch {
+        text = null;
+    }
+    const doc = text === null ? null : parseAcceptation(text);
+    if (doc && typeof doc !== 'string' && doc.vert && hasSeals(doc)) {
+        // Le fichier actuel doit être celui de `first` : une session accept qui a réécrit puis commité l'oracle avant de poser sa question (le verrou ne s'applique pas à l'étape accept, `skip`)
+        // ne se fait pas adopter comme nouveau commit rouge. Seul un rescellé du lead (journal `resceaux` allongé, commit hors de toute session, fichier propre) est une différence admise.
+        const drift = first ? greenDrift(c, json, first, text, doc) : null;
+        if (drift) {
+            stop(c, 'handed-back', `verrou des tests d'acceptation : ${json} : ${drift}`);
+            return;
+        }
+        l.accept = { acceptation: json, rouge: redSha(l.repo, json) ?? '' };
+        l.next = 'implement';
+        // Un lot en question n'a plus rien à demander : la réponse du lead (« ne réécris rien ») est prise en compte par ce choix, elle ne repart pas dans le brief d'implement.
+        l.pendingAnswer = null;
+        transition(c, 'implementing', 'acceptation déjà verte : accept ignoré');
+        return;
+    }
     const done = await session(c, 'accept');
     if (!done)
         return;