@sylad/cadence 1.7.0 → 1.8.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.7.0",
+      "version": "1.8.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.7.0",
+  "version": "1.8.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/README.md

@@ -32,7 +32,7 @@ Then `raf start L1`, commit with `feat(L1): …`, `raf now` to see where you are
 | [docs/lead.md](docs/lead.md) | the lead workflow and `cadence lead tour` |
 | [docs/stabilite.md](docs/stabilite.md) | what is guaranteed from 1.0.0 and what is not |
 
-Also: [news](docs/news.md) (changelog, UX, code and QA reviews, documentation that follows the code), [session](docs/session.md), [corrections](docs/corrections.md), [skills and agents](docs/skills.md), [cadence-hud](docs/cadence-hud.md), [releasing](docs/releasing.md), [overview](docs/overview.md), [how it all works](docs/fonctionnement.md) (four figures).
+Also: [news](docs/news.md) (changelog, UX, code and QA reviews, documentation that follows the code), [session](docs/session.md), [corrections](docs/corrections.md), [perf](docs/perf.md), [skills and agents](docs/skills.md), [cadence-hud](docs/cadence-hud.md), [releasing](docs/releasing.md), [overview](docs/overview.md), [how it all works](docs/fonctionnement.md) (four figures).
 
 <details>
 <summary>The four tools in short</summary>
@@ -40,7 +40,8 @@ Also: [news](docs/news.md) (changelog, UX, code and QA reviews, documentation th
 - **raf** (French *reste à faire*, "what is left to do"): the plan, linked to your commits by the lot id in the message, computed from `git log` and never stored.
 - **news**: a user-facing changelog with screenshots, tied to the plan; a lot is not done until its entry is written.
 - **session**: `session start` and `session close` gather the facts of a work session.
-- **deliver**: wait for the CI of the pushed commit, run the deploy commands, then **verify the effect**; a delivery is done only when its checks pass.
+- **deliver**: wait for the CI of the pushed commit, run the deploy commands, then **verify the effect**; a delivery is done only when its checks pass. A failed delivery is logged as a *red delivery*.
+- **perf**: `cadence perf` is the dashboard of the workflow (speed next to quality, `⚠` on a trend), including the red deliveries and the blocking QA findings; `cadence lead tour` opens with its *perf header*, one line per `⚠`, nothing when stable ([docs/perf.md](docs/perf.md)).
 
 Reviews are opt-in gates: `ux-reviewer` (no user-facing change is done before its usability review), `code-reviewer` (no lot with commits is done before its code review) and `qa-reviewer`, which walks the delivered app in a real browser.
 
@@ -50,6 +51,7 @@ Reviews are opt-in gates: `ux-reviewer` (no user-facing change is done before it
 
 Two lines per version; the long form is in [docs/whats-new.md](docs/whats-new.md) and the full history, with dates, in [CHANGELOG.md](CHANGELOG.md).
 
+- **1.8.0**: `cadence perf` shows the speed of the workflow next to its quality (cost in euros per delivered lot, red deliveries, blocking QA findings), and `cadence lead tour` opens with a perf header.
 - **1.7.0**: `cadence orchestrate` no longer replays `accept` on a green sealed acceptation and refuses `--resume --dry-run`; `spec reseal --porteur` accepts a sheet amended by a delivered lot; the README becomes a short home page.
 - **1.6.0**: the mockup review sweeps everything in its first report and runs up to `orchestrate.maquetteReviews` times (3 by default); the acceptance lock names the first offending commit.
 - **1.5.1**: publishes 1.5.0 (tagged, never published): one UX review per lot, replay of a lot handed back for its budget, a self-check list in the briefs, a `tests.yml` workflow.

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/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 … »)
 
@@ -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);
@@ -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/perf.js

@@ -0,0 +1,559 @@
+import { join, relative, sep } from 'node:path';
+import { planLoader } from './config.js';
+import { CAUSES, isReview as isReviewKind } from './corrections.js';
+import { addDays, diffDays, isDay, toDay } from './dates.js';
+import { gitCommonDir } from './git.js';
+import { findProjects } from './lead.js';
+import { readDeliveries, readFailedDeliveries } from './state.js';
+/** Au-delà de cette dégradation relative, un indicateur porte un ⚠ (R12). */
+const DEGRADATION = 0.25;
+/** Sous ce nombre de lots dans l'une des deux fenêtres, pas de tendance (R13). */
+const MIN_SAMPLE = 5;
+/** Goulot net (R19) : une cause pèse au moins cette part des passes classées, avec au moins MIN_CLASSIFIED passes classées. */
+const BOTTLENECK_SHARE = 0.5;
+const MIN_CLASSIFIED = 10;
+/**
+ * Les deux fenêtres de 7 jours calendaires locaux : la courante finit à `today` inclus, la précédente la précède.
+ * `since` (jour ISO ou instant) ignore tout ce qui le précède : la fenêtre qui commence avant lui est tronquée à lui.
+ */
+export function perfWindows(today, since) {
+    const sinceDay = since === undefined ? undefined : isDay(since) ? since : toDay(new Date(since));
+    const make = (from, to) => {
+        if (sinceDay === undefined || sinceDay <= from)
+            return { from, to, days: 7, truncated: false };
+        return { from: sinceDay, to, days: sinceDay > to ? 0 : diffDays(sinceDay, to) + 1, truncated: true };
+    };
+    return { current: make(addDays(today, -6), today), previous: make(addDays(today, -13), addDays(today, -7)) };
+}
+const FINISHED = new Set(['ready', 'handed-back', 'failed']);
+const finished = (j) => FINISHED.has(j.status);
+/** Un journal est daté par la fin de sa dernière étape, à défaut par la création de sa vague ; sans date lisible il est écarté (R4). */
+function dated(j) {
+    const ends = j.steps.map((s) => Date.parse(s.ended ?? '')).filter((t) => !Number.isNaN(t));
+    const at = ends.length ? Math.max(...ends) : Date.parse(j.waveCreated ?? '');
+    return Number.isNaN(at) ? null : { j, at, day: toDay(new Date(at)) };
+}
+const inWindow = (day, w) => w.days > 0 && day >= w.from && day <= w.to;
+/** Le lot d'un plan qui correspond à l'id du journal : l'id lui-même, à défaut le lot parent d'un id « <lot>/<sous-tâche> » (R10). */
+function planLot(plans, project, lot) {
+    const lots = plans.get(project);
+    if (!lots)
+        return undefined;
+    return lots.find((l) => l.id === lot) ?? (lot.includes('/') ? lots.find((l) => l.id === lot.slice(0, lot.indexOf('/'))) : undefined);
+}
+/** Rang d'affichage d'une sorte d'étape : l'ordre du cycle, les sortes inconnues après. */
+const KIND_ORDER = ['spec', 'maquette', 'fiche', 'precheck', 'implement', 'review', 'review-small', 'ux', 'fix', 'accept'];
+const kindRank = (kind) => (KIND_ORDER.includes(kind) ? KIND_ORDER.indexOf(kind) : KIND_ORDER.length);
+/** Part de `counted` rangée en entrée quand une étape ne porte que ce compteur (journal ancien) : le reste est en sortie (R8 b). */
+const COUNTED_INPUT_SHARE = 0.9;
+/** Coût en euros d'une étape (R8) ; le nom du modèle sans prix quand il en faudrait un. */
+function stepEuros(step, prices) {
+    if (step.model === 'local')
+        return 0;
+    const usage = step.usage ?? (step.counted === undefined ? null : { input: COUNTED_INPUT_SHARE * step.counted, cacheWrite: 0, cacheRead: 0, output: (1 - COUNTED_INPUT_SHARE) * step.counted });
+    if (!usage)
+        return 0;
+    const price = step.model === 'sonnet' || step.model === 'opus' || step.model === 'haiku' ? prices[step.model] : undefined;
+    if (!price)
+        return { missing: step.model === 'sonnet' || step.model === 'opus' || step.model === 'haiku' ? step.model : 'inconnu' };
+    return ((usage.input + usage.cacheWrite) * price.input + usage.output * price.output + usage.cacheRead * price.cacheRead) / 1_000_000;
+}
+const median = (xs) => {
+    if (xs.length === 0)
+        return null;
+    const s = [...xs].sort((a, b) => a - b);
+    const mid = s.length >> 1;
+    return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+};
+/** Ce qu'on lit d'une note de plan : sans le préfixe de date « JJ-MM », « JJ-MM hh:mm » et le séparateur « : ». */
+const NOTE_PREFIX = /^\s*\d{1,2}-\d{1,2}(?:\s+\d{1,2}:\d{2})?\s*:?\s*/;
+const QA_DEFECT = /(?<!\b0\s)(?<!\baucun\s)\b(?:bloquant|majeur)/i;
+/** Une note « QA … bloquant/majeur » (R9) : commence par QA et contient bloquant ou majeur non précédé de « 0 » ou « aucun ». */
+export function isQaDefectNote(text) {
+    const body = text.replace(NOTE_PREFIX, '');
+    return body.startsWith('QA') && QA_DEFECT.test(body);
+}
+const QA_BLOCKING = /(?<!\b0\s)(?<!\baucun\s)\bbloquant/i;
+/** Une note « QA … bloquant » (L227) : commence par QA et contient bloquant non précédé de « 0 » ou « aucun » ; « majeur » seul ne compte pas. */
+export function isQaBlockingNote(text) {
+    const body = text.replace(NOTE_PREFIX, '');
+    return body.startsWith('QA') && QA_BLOCKING.test(body);
+}
+/** Les décisions que chaque indicateur éclaire (commentaire de la fiche), dites au bout d'une ligne ⚠. */
+const DECISIONS = {
+    rendered: 'le flux baisse : chercher le goulot avant d\'ajouter des lots',
+    delivered: 'le flux baisse : chercher le goulot avant d\'ajouter des lots',
+    onBudget: 'les budgets sont-ils justes ? relever le plancher (L218)',
+    escaped: 'la vitesse se paie en qualité : durcir la revue avant d\'accélérer',
+    medianPasses: 'la première écriture n\'est pas assez bonne : durcir la fiche ou le brief',
+    atLeast2: 'la première écriture n\'est pas assez bonne : durcir la fiche ou le brief',
+    firstTime: 'la première écriture n\'est pas assez bonne : durcir la fiche ou le brief',
+    handedOut: 'la vague s\'arrête trop tôt ou le lead la rattrape à la main : revoir la fin de cycle',
+    ux: 'la revue d\'ergonomie coûte plus d\'un tour : renforcer la maquette',
+    tokens: 'l\'estimate est mal calibrée : redécouper le lot ou recaler l\'estimate et les budgets',
+    reviewShare: 'la revue pèse trop face à l\'écriture : alléger (seuil du lot léger, orchestrate.review.threshold)',
+    createdToDone: 'la file de lots s\'allonge : chercher le goulot de priorisation avant d\'ajouter des lots',
+    doneToDelivered: 'on livre trop rarement : livrer par lots plus petits',
+    cost: 'le modèle ou l\'effort d\'une étape est-il juste ? changer le modèle de cette étape',
+    redDeliveries: 'la livraison casse : corriger CI, déploiement ou vérification avant d\'ajouter des lots',
+    qaBlocking: 'la revue laisse passer des défauts graves : durcir la revue avant de livrer davantage',
+    duration: 'cette étape est lente : revoir ses timeouts, son effort ou son modèle',
+};
+function indicator(current, previous, lots, windows, dir, twin, nullNote = null) {
+    const change = current !== null && previous !== null && previous !== 0 ? (current - previous) / previous : null;
+    const worse = current !== null && previous !== null && dir !== null && (dir === 'down' ? current < previous : current > previous);
+    const truncated = windows.current.truncated || windows.previous.truncated;
+    let note = current === null && previous === null ? nullNote : null;
+    let warn = false;
+    if (dir !== null && current !== null && previous !== null) {
+        const degraded = worse && (previous === 0 || Math.abs(change) > DEGRADATION + 1e-9);
+        if (truncated)
+            note = 'fenêtre tronquée';
+        else if (degraded && (lots.current < MIN_SAMPLE || lots.previous < MIN_SAMPLE))
+            note = 'pas de tendance : échantillon';
+        else if (degraded && previous === 0)
+            note = 'pas de tendance : précédente nulle';
+        else
+            warn = degraded;
+    }
+    return { current, previous, change, warn, twin, lots, note };
+}
+/** Les deux valeurs d'un indicateur, calculées fenêtre par fenêtre. */
+const both = (windows, f) => ({ current: f(windows.current), previous: f(windows.previous) });
+function causeWindow(passes, w, cache) {
+    const counts = new Map();
+    let unclassified = 0;
+    let withoutFindings = 0;
+    for (const { pass, day } of passes) {
+        if (!inWindow(day, w))
+            continue;
+        if (pass.findings.length === 0) {
+            withoutFindings++;
+            continue;
+        }
+        const c = cache.get(pass.key);
+        if (!c) {
+            unclassified++;
+            continue;
+        }
+        const cause = c.manual ?? c.cause;
+        counts.set(cause, (counts.get(cause) ?? 0) + 1);
+    }
+    const classified = [...counts.values()].reduce((a, b) => a + b, 0);
+    const top = CAUSES.filter((c) => counts.has(c))
+        .map((cause) => ({ cause, passes: counts.get(cause), share: counts.get(cause) / classified }))
+        .sort((a, b) => b.passes - a.passes)
+        .slice(0, 3);
+    const withFindings = classified + unclassified;
+    return { top, classified, unclassified, withoutFindings, unclassifiedShare: withFindings === 0 ? null : unclassified / withFindings };
+}
+export function computePerf(input) {
+    const { plans, cache, windows, today } = input;
+    const hasPlans = plans.size > 0;
+    // --since (R3) : une vague créée avant ce jour n'est pas lue, même si ses lots finissent après.
+    const sinceDay = input.since === undefined ? undefined : isDay(input.since) ? input.since : toDay(new Date(input.since));
+    const readable = (j) => j.waveReadable && (sinceDay === undefined || (j.waveCreated !== undefined && toDay(new Date(j.waveCreated)) >= sinceDay));
+    const all = input.journals.filter(readable).map(dated).filter((d) => d !== null);
+    const rendered = (w) => all.filter((d) => finished(d.j) && inWindow(d.day, w));
+    const twinEscaped = 'throughput.escaped';
+    // Débit (R4, R5, R9)
+    const rendus = both(windows, rendered);
+    const ready = both(windows, (w) => (rendered(w).length === 0 ? null : rendered(w).filter((d) => d.j.status === 'ready').length));
+    const perDay = (w) => (w.days === 0 || rendered(w).length === 0 ? null : rendered(w).length / w.days);
+    const deliveredCount = (w) => [...plans.values()].flat().filter((l) => l.status === 'done' && l.finished !== undefined && inWindow(l.finished, w)).length;
+    const delivered = both(windows, (w) => (hasPlans && deliveredCount(w) > 0 ? deliveredCount(w) : null));
+    const withBudget = (w) => rendered(w).filter((d) => d.j.budget !== undefined);
+    const onBudget = both(windows, (w) => {
+        const set = withBudget(w);
+        return set.length === 0 ? null : set.filter((d) => d.j.steps.reduce((sum, s) => sum + (s.counted ?? 0), 0) <= d.j.budget).length / set.length;
+    });
+    // Défauts échappés (R9)
+    const recognised = [...plans.values()].some((lots) => lots.some((l) => l.notes.some((n) => isQaDefectNote(n.text))));
+    const escapedOf = (w) => {
+        if (!recognised || w.days === 0)
+            return null;
+        const keys = new Set();
+        for (const [project, lots] of plans) {
+            for (const l of lots) {
+                if (l.status !== 'done' || l.finished === undefined)
+                    continue;
+                if (l.notes.some((n) => isDay(n.date) && inWindow(n.date, w) && l.finished <= n.date && isQaDefectNote(n.text)))
+                    keys.add(`${project}\0${l.id}`);
+            }
+        }
+        return keys.size;
+    };
+    const escapedNote = recognised ? null : 'aucune note QA reconnue : convention à fixer (L227)';
+    const lotsOf = both(windows, (w) => rendered(w).length);
+    // Passes de correction (R6, R7, R23)
+    const withPasses = all.filter((d) => finished(d.j) && d.j.implemented);
+    const lotsIn = (w) => withPasses.filter((d) => inWindow(d.day, w));
+    const medianPasses = both(windows, (w) => median(lotsIn(w).map((d) => d.j.passes.length)));
+    const share = (w, pred) => {
+        const set = lotsIn(w);
+        return set.length === 0 ? null : set.filter((d) => pred(d.j.passes.length)).length / set.length;
+    };
+    const lotCounts = both(windows, (w) => lotsIn(w).length);
+    const passDays = withPasses.flatMap((d) => d.j.passes.map((pass) => ({ pass, day: pass.fixEnded && !Number.isNaN(Date.parse(pass.fixEnded)) ? toDay(new Date(pass.fixEnded)) : d.day })));
+    const causes = { current: causeWindow(passDays, windows.current, cache), previous: causeWindow(passDays, windows.previous, cache) };
+    // Interventions du lead (R10, R15)
+    const lastOf = new Map();
+    for (const d of all) {
+        const key = `${d.j.project}\0${d.j.lot}`;
+        const prev = lastOf.get(key);
+        if (!prev || d.at >= prev.at)
+            lastOf.set(key, d);
+    }
+    const handedOutOf = (w) => rendered(w).filter((d) => {
+        if (d.j.status !== 'handed-back' && d.j.status !== 'failed')
+            return false;
+        if (lastOf.get(`${d.j.project}\0${d.j.lot}`) !== d)
+            return false;
+        const p = planLot(plans, d.j.project, d.j.lot);
+        return p !== undefined && p.status === 'done' && p.finished !== undefined && p.finished >= d.day;
+    }).length;
+    const handedCount = both(windows, (w) => (hasPlans && rendered(w).length > 0 ? handedOutOf(w) : null));
+    const handedOut = both(windows, (w) => {
+        const n = rendered(w).length;
+        return !hasPlans || n === 0 ? null : handedOutOf(w) / n;
+    });
+    const visibleRendered = (w) => rendered(w).filter((d) => d.j.visible);
+    const ux = both(windows, (w) => {
+        const set = visibleRendered(w);
+        return set.length === 0 ? null : set.reduce((sum, d) => sum + d.j.steps.filter((s) => s.kind === 'ux' && s.status === 'ok').length, 0) / set.length;
+    });
+    const visibleCounts = both(windows, (w) => visibleRendered(w).length);
+    const budgetCounts = both(windows, (w) => withBudget(w).length);
+    const mk = (vals, lots, dir, twin, nullNote = null) => indicator(vals.current, vals.previous, lots, windows, dir, twin, nullNote);
+    const planNote = hasPlans ? null : 'plan illisible ou absent';
+    // Tokens par estimate et part de revue (R2, R3)
+    const twinFirstTime = 'corrections.firstTime';
+    const tokensByClass = (w) => {
+        const classes = new Map();
+        for (const d of rendered(w)) {
+            const p = planLot(plans, d.j.project, d.j.lot);
+            const counted = d.j.steps.filter((x) => x.counted !== undefined);
+            if (!p || counted.length === 0)
+                continue;
+            const key = String(p.estimate);
+            classes.set(key, [...(classes.get(key) ?? []), counted.reduce((sum, x) => sum + x.counted, 0)]);
+        }
+        return classes;
+    };
+    const byClass = both(windows, tokensByClass);
+    const byEstimate = {};
+    const classKeys = [...new Set([...byClass.current.keys(), ...byClass.previous.keys()])].sort((a, b) => Number(a) - Number(b));
+    for (const key of classKeys) {
+        const vals = both(windows, (w) => median((w === windows.current ? byClass.current : byClass.previous).get(key) ?? []));
+        byEstimate[key] = mk(vals, { current: byClass.current.get(key)?.length ?? 0, previous: byClass.previous.get(key)?.length ?? 0 }, 'up', twinFirstTime);
+    }
+    const reviewShare = both(windows, (w) => {
+        let review = 0;
+        let all = 0;
+        for (const d of rendered(w))
+            for (const x of d.j.steps) {
+                all += x.counted ?? 0;
+                if (isReviewKind(x.kind))
+                    review += x.counted ?? 0;
+            }
+        return all === 0 ? null : review / all;
+    });
+    // Délais création → done et done → livraison (R4, R5) : les lots du plan done dont finished tombe dans la fenêtre
+    const doneIn = (w) => [...plans].flatMap(([project, lots]) => lots.filter((l) => l.status === 'done' && l.finished !== undefined && inWindow(l.finished, w)).map((lot) => ({ project, lot })));
+    const timed = (w) => doneIn(w).filter(({ lot }) => isDay(lot.created) && lot.finished >= lot.created);
+    const createdToDone = both(windows, (w) => timed(w).map(({ lot }) => diffDays(lot.created, lot.finished)));
+    const doneToDelivered = both(windows, (w) => timed(w).flatMap(({ project, lot }) => {
+        const next = (input.deliveries?.get(project) ?? []).filter((d) => d >= lot.finished).sort()[0];
+        return next === undefined ? [] : [diffDays(lot.finished, next)];
+    }));
+    const sizes = (v) => ({ current: v.current.length, previous: v.previous.length });
+    // Durée de mur par sorte d'étape (R6) : rangée par le jour de la fin de l'étape
+    const walls = all.filter((d) => finished(d.j)).flatMap((d) => d.j.steps.flatMap((x) => {
+        const from = Date.parse(x.started ?? '');
+        const to = Date.parse(x.ended ?? '');
+        return x.status === 'ok' && !Number.isNaN(from) && !Number.isNaN(to) && to >= from ? [{ kind: x.kind, minutes: (to - from) / 60_000, day: toDay(new Date(to)) }] : [];
+    }));
+    const wallsOf = (kind, w) => walls.filter((x) => x.kind === kind && inWindow(x.day, w)).map((x) => x.minutes);
+    const durations = {};
+    const wallKinds = [...new Set(walls.filter((x) => inWindow(x.day, windows.current) || inWindow(x.day, windows.previous)).map((x) => x.kind))].sort((a, b) => kindRank(a) - kindRank(b) || a.localeCompare(b));
+    for (const kind of wallKinds) {
+        const v = both(windows, (w) => wallsOf(kind, w));
+        durations[kind] = mk({ current: median(v.current), previous: median(v.previous) }, sizes(v), 'up', twinFirstTime);
+    }
+    // Coût par lot livré (R8 à R10)
+    const prices = input.prices ?? null;
+    const journalsOf = new Map();
+    for (const d of all) {
+        const p = planLot(plans, d.j.project, d.j.lot);
+        if (p)
+            journalsOf.set(`${d.j.project}\0${p.id}`, [...(journalsOf.get(`${d.j.project}\0${p.id}`) ?? []), d]);
+    }
+    const costOf = (w) => {
+        const euros = [];
+        const missing = new Map();
+        let withoutJournal = 0;
+        for (const { project, lot } of doneIn(w)) {
+            const journals = journalsOf.get(`${project}\0${lot.id}`);
+            if (!journals) {
+                withoutJournal++;
+                continue;
+            }
+            if (!prices)
+                continue;
+            let sum = 0;
+            const lacking = new Set();
+            for (const step of journals.flatMap((d) => d.j.steps)) {
+                const e = stepEuros(step, prices);
+                if (typeof e === 'number')
+                    sum += e;
+                else
+                    lacking.add(e.missing);
+            }
+            for (const m of lacking)
+                missing.set(m, (missing.get(m) ?? 0) + 1);
+            if (lacking.size === 0)
+                euros.push(sum);
+        }
+        return { euros, missing, withoutJournal };
+    };
+    const costs = both(windows, costOf);
+    const withoutPrice = {};
+    for (const m of [...costs.current.missing.keys(), ...costs.previous.missing.keys()])
+        withoutPrice[m] = (costs.current.missing.get(m) ?? 0) + (costs.previous.missing.get(m) ?? 0);
+    const orphans = [...rendus.current, ...rendus.previous].filter((d) => planLot(plans, d.j.project, d.j.lot) === undefined).length;
+    const throughput = {
+        ready: mk(ready, lotsOf, null, twinEscaped),
+        rendered: mk(both(windows, perDay), lotsOf, 'down', twinEscaped),
+        delivered: mk(delivered, both(windows, deliveredCount), 'down', twinEscaped, planNote),
+        onBudget: mk(onBudget, budgetCounts, 'down', twinEscaped),
+        escaped: mk(both(windows, escapedOf), lotsOf, 'up', null, escapedNote),
+    };
+    const firstTime = both(windows, (w) => share(w, (n) => n === 0));
+    const correctionsInd = {
+        medianPasses: mk(medianPasses, lotCounts, 'up', 'corrections.firstTime'),
+        atLeast2: mk(both(windows, (w) => share(w, (n) => n >= 2)), lotCounts, 'up', 'corrections.firstTime'),
+        firstTime: mk(firstTime, lotCounts, 'down', null),
+        causes,
+    };
+    const handed = mk(handedOut, lotsOf, 'up', twinEscaped, planNote);
+    const interventions = { handedOut: { ...handed, count: handedCount }, ux: mk(ux, visibleCounts, 'up', twinEscaped) };
+    const tokens = { byEstimate, reviewShare: mk(reviewShare, both(windows, (w) => rendered(w).length), 'up', twinFirstTime) };
+    const delays = {
+        createdToDone: mk({ current: median(createdToDone.current), previous: median(createdToDone.previous) }, sizes(createdToDone), 'up', twinFirstTime, planNote),
+        doneToDelivered: mk({ current: median(doneToDelivered.current), previous: median(doneToDelivered.previous) }, sizes(doneToDelivered), 'up', twinFirstTime, planNote),
+    };
+    const cost = {
+        perDelivered: mk({ current: median(costs.current.euros), previous: median(costs.previous.euros) }, { current: costs.current.euros.length, previous: costs.previous.euros.length }, 'up', twinFirstTime, prices ? planNote : 'aucune grille de prix'),
+        withoutPrice,
+        withoutJournal: { current: costs.current.withoutJournal, previous: costs.previous.withoutJournal },
+    };
+    // Qualité de livraison (L227) : livraisons rouges (l'échantillon est celui des livraisons, vertes + rouges) et notes QA bloquantes
+    const daysIn = (byProject, w) => [...(byProject?.values() ?? [])].flat().filter((d) => inWindow(d, w)).length;
+    const reds = both(windows, (w) => daysIn(input.failedDeliveries, w));
+    const deliveriesOf = both(windows, (w) => daysIn(input.deliveries, w) + daysIn(input.failedDeliveries, w));
+    const blockingRecognised = [...plans.values()].some((lots) => lots.some((l) => l.notes.some((n) => isQaBlockingNote(n.text))));
+    const blockingOf = (w) => {
+        if (!blockingRecognised || w.days === 0)
+            return null;
+        return [...plans.values()].flat().filter((l) => l.status === 'done' && l.finished !== undefined).reduce((sum, l) => sum + l.notes.filter((n) => isDay(n.date) && inWindow(n.date, w) && l.finished <= n.date && isQaBlockingNote(n.text)).length, 0);
+    };
+    const quality = {
+        redDeliveries: mk(reds, deliveriesOf, 'up', 'throughput.delivered'),
+        qaBlocking: mk(both(windows, blockingOf), both(windows, deliveredCount), 'up', twinEscaped, escapedNote),
+    };
+    const result = { since: input.since ?? null, today, windows, throughput, corrections: correctionsInd, interventions, tokens, delays, durations, cost, quality, orphans, warnings: [] };
+    const bottleneck = bottleneckOf(causes.current);
+    for (const [key, ind] of indicatorLines(result))
+        if (ind.warn)
+            result.warnings.push(`⚠ ${key.label} : ${describe(ind, key.kind)} → ${DECISIONS[key.decision]}`);
+    if (bottleneck)
+        result.warnings.push(bottleneck);
+    return result;
+}
+/** Goulot net (R19) : une cause pèse au moins la moitié des passes classées de la fenêtre courante, avec au moins dix passes classées. */
+function bottleneckOf(w) {
+    const first = w.top[0];
+    if (!first || w.classified < MIN_CLASSIFIED || first.share < BOTTLENECK_SHARE)
+        return null;
+    return `⚠ goulot : ${LABELS[first.cause]} pèse ${first.passes} passes classées sur ${w.classified} → quel maillon corriger`;
+}
+const LABELS = {
+    'spec-floue': 'spec floue ou critère absent',
+    'regle-inventee': 'règle de gestion inventée',
+    'derive-architecture': "dérive d'architecture",
+    'donnees-sql': 'données / SQL',
+    'bug-code': 'bug de code',
+    'test-manquant': 'test manquant',
+    'faux-constat': 'faux constat de revue',
+};
+/** Les douze premières lignes de `indicatorLines` sont celles de L225 et les deux de qualité de livraison de L227 ; les suivantes sont celles de L226. */
+const LEGACY_LINES = 12;
+/** Les indicateurs imprimés, dans l'ordre du tableau, avec leur étiquette et la décision qu'ils éclairent. */
+function indicatorLines(r) {
+    const speed = [
+        ...Object.entries(r.tokens.byEstimate).sort(([a], [b]) => Number(a) - Number(b)).map(([k, ind]) => [{ label: `tokens par lot (estimate ${k})`, kind: 'tokens', decision: 'tokens' }, ind]),
+        [{ label: 'part des tokens de revue', kind: 'share', decision: 'reviewShare' }, r.tokens.reviewShare],
+        [{ label: 'délai création → done', kind: 'days', decision: 'createdToDone' }, r.delays.createdToDone],
+        [{ label: 'délai done → livraison', kind: 'days', decision: 'doneToDelivered' }, r.delays.doneToDelivered],
+        ...Object.entries(r.durations).map(([k, ind]) => [{ label: `durée de mur ${k}`, kind: 'min', decision: 'duration' }, ind]),
+        [{ label: 'coût par lot livré', kind: 'eur', decision: 'cost' }, r.cost.perDelivered],
+    ];
+    return [
+        [{ label: 'prêts', kind: 'count', decision: 'rendered' }, r.throughput.ready],
+        [{ label: 'rendus par jour', kind: 'rate', decision: 'rendered' }, r.throughput.rendered],
+        [{ label: 'livrés', kind: 'count', decision: 'delivered' }, r.throughput.delivered],
+        [{ label: 'part des rendus sur budget', kind: 'share', decision: 'onBudget' }, r.throughput.onBudget],
+        [{ label: 'médiane de passes de correction par lot', kind: 'num', decision: 'medianPasses' }, r.corrections.medianPasses],
+        [{ label: 'part des lots à au moins 2 passes', kind: 'share', decision: 'atLeast2' }, r.corrections.atLeast2],
+        [{ label: 'lots terminés hors vague', kind: 'share', decision: 'handedOut' }, r.interventions.handedOut],
+        [{ label: 'sessions ux par lot visible', kind: 'num', decision: 'ux' }, r.interventions.ux],
+        [{ label: 'part conforme du premier coup', kind: 'share', decision: 'firstTime' }, r.corrections.firstTime],
+        [{ label: 'défauts échappés', kind: 'count', decision: 'escaped' }, r.throughput.escaped],
+        [{ label: 'livraisons rouges', kind: 'count', decision: 'redDeliveries' }, r.quality.redDeliveries],
+        [{ label: 'constats QA bloquants', kind: 'count', decision: 'qaBlocking' }, r.quality.qaBlocking],
+        ...speed,
+    ];
+}
+const num = (v) => (Number.isInteger(v) ? String(v) : v.toFixed(1).replace('.', ','));
+const pct = (v) => `${Math.round(100 * v)} %`;
+function value(v, kind) {
+    if (v === null)
+        return 'n/d';
+    if (kind === 'share')
+        return pct(v);
+    if (kind === 'tokens')
+        return `${num(v / 1000)} k`;
+    if (kind === 'days')
+        return `${num(v)} j`;
+    if (kind === 'min')
+        return `${num(v)} min`;
+    if (kind === 'eur')
+        return `${v.toFixed(2).replace('.', ',')} €`;
+    return num(v);
+}
+const signed = (c) => `${c >= 0 ? '+' : '−'}${Math.round(100 * Math.abs(c))} %`;
+/** « courante (précédente prev, variation) » d'un indicateur. */
+function describe(ind, kind) {
+    return `${value(ind.current, kind)} (précédente ${value(ind.previous, kind)}${ind.change === null ? '' : `, ${signed(ind.change)}`})`;
+}
+/** Les lignes que désigne le chemin `twin` d'un indicateur. */
+function twinsByPath(lines) {
+    const at = (label) => lines.find(([l]) => l.label === label);
+    return new Map([
+        ['throughput.escaped', at('défauts échappés')],
+        ['throughput.delivered', at('livrés')],
+        ['corrections.firstTime', at('part conforme du premier coup')],
+    ]);
+}
+/**
+ * L'en-tête perf du tour (L227) : une ligne par ⚠ de `result.warnings`, dans le même ordre. La ligne d'un ⚠ de tendance dit la valeur
+ * de son jumeau de qualité (vitesse et qualité côte à côte) et finit par sa décision ; le goulot net est repris tel quel.
+ */
+export function perfHeader(r) {
+    const lines = indicatorLines(r);
+    const byPath = twinsByPath(lines);
+    const header = [];
+    for (const [line, ind] of lines) {
+        if (!ind.warn)
+            continue;
+        const twin = ind.twin ? byPath.get(ind.twin) : undefined;
+        header.push(`⚠ ${line.label} : ${describe(ind, line.kind)}${twin ? ` · ${twin[0].label} : ${describe(twin[1], twin[0].kind)}` : ''} → ${DECISIONS[line.decision]}`);
+    }
+    header.push(...r.warnings.filter((w) => w.startsWith('⚠ goulot')));
+    return header;
+}
+/** Le tableau en texte : chaque indicateur de vitesse sur la même ligne que son jumeau de qualité (R8). */
+export function renderPerf(r) {
+    const lines = indicatorLines(r);
+    const byPath = twinsByPath(lines);
+    // Second jumeau d'affichage (L227) : la ligne « livrés » dit aussi les livraisons rouges, celle des défauts échappés les constats QA bloquants.
+    const quality = new Map([
+        ['livrés', lines.find(([l]) => l.label === 'livraisons rouges')],
+        ['défauts échappés', lines.find(([l]) => l.label === 'constats QA bloquants')],
+    ]);
+    const w = r.windows;
+    const win = (x) => `${x.from} → ${x.to} (${x.days} j${x.truncated ? ', tronquée par --since' : ''})`;
+    const out = [`cadence perf · aujourd'hui ${r.today}${r.since ? ` · depuis ${r.since}` : ''}`, `fenêtre courante : ${win(w.current)}`, `fenêtre précédente : ${win(w.previous)}`];
+    const row = ([line, ind]) => {
+        const twin = ind.twin ? byPath.get(ind.twin) : null;
+        const extra = quality.get(line.label);
+        const parts = [`${ind.warn || extra?.[1].warn ? '⚠' : ' '} ${line.label} : ${describe(ind, line.kind)}`];
+        if (twin)
+            parts.push(`${twin[0].label} : ${describe(twin[1], twin[0].kind)}${twin[1].note && twin[1].current === null ? ` — ${twin[1].note}` : ''}`);
+        if (extra)
+            parts.push(`${extra[0].label} : ${describe(extra[1], extra[0].kind)}${extra[1].note ? ` — ${extra[1].note}` : ''}`);
+        if (ind.note)
+            parts.push(ind.note);
+        if (ind.warn)
+            parts.push(`→ ${DECISIONS[line.decision]}`);
+        if (extra?.[1].warn)
+            parts.push(`→ ${DECISIONS[extra[0].decision]}`);
+        return parts.join(' · ');
+    };
+    const section = (title, labels) => {
+        out.push('', title);
+        for (const l of lines.filter(([x]) => labels.includes(x.label)))
+            out.push(row(l));
+    };
+    section('Débit', ['prêts', 'rendus par jour', 'livrés', 'part des rendus sur budget', 'défauts échappés']);
+    section('Passes de correction', ['médiane de passes de correction par lot', 'part des lots à au moins 2 passes', 'part conforme du premier coup']);
+    const c = r.corrections.causes.current;
+    const top = c.top.map((t, i) => `${i + 1}. ${LABELS[t.cause]} ${t.passes} (${pct(t.share)})`).join(' · ');
+    out.push(`  causes dominantes (${c.classified} passes classées) : ${top || 'aucune'} · non classé : ${c.unclassifiedShare === null ? 'n/d' : pct(c.unclassifiedShare)} · sans revue (tests rouges) : ${c.withoutFindings}`);
+    section('Interventions du lead', ['lots terminés hors vague', 'sessions ux par lot visible']);
+    const h = r.interventions.handedOut.count;
+    out.push(`  lots rendus puis terminés hors vague : ${h.current ?? 'n/d'} (précédente ${h.previous ?? 'n/d'})`);
+    out.push('', 'Tokens, délais et durées (médianes par lot ou par étape)');
+    for (const l of lines.slice(LEGACY_LINES))
+        out.push(row(l));
+    for (const wr of r.warnings.filter((x) => x.startsWith('⚠ goulot')))
+        out.push('', wr);
+    const noJournal = r.cost.withoutJournal.current + r.cost.withoutJournal.previous;
+    if (noJournal > 0)
+        out.push('', `${noJournal} lot(s) livré(s) sans journal`);
+    if (r.orphans > 0)
+        out.push('', `${r.orphans} lot(s) de journal sans plan`);
+    return out;
+}
+/** Les plans des projets de `parent` (un niveau d'imbrication, R22) ; un plan illisible est sauté avec un avertissement (R16). */
+export function readPlans(parent, warn) {
+    const plans = new Map();
+    for (const dir of findProjects(parent, 2)) {
+        const name = relative(parent, dir).split(sep).join('/');
+        try {
+            plans.set(name, planLoader(dir)().lots());
+        }
+        catch {
+            warn(`perf : plan illisible, projet ${name} sauté`);
+        }
+    }
+    return plans;
+}
+/** Les jours de livraison de chaque projet du dossier, lus dans `<gitCommonDir>/cadence/deliveries.log` de son dépôt (R5). Sans dépôt git ni journal de livraison, le projet est absent de la carte ; rien n'est créé. */
+export function readProjectDeliveries(parent, projects) {
+    const deliveries = new Map();
+    for (const name of projects) {
+        try {
+            const days = readDeliveries(join(gitCommonDir(join(parent, name)), 'cadence'));
+            if (days)
+                deliveries.set(name, days);
+        }
+        catch {
+            // pas un dépôt git : délai de livraison n/d pour ce projet
+        }
+    }
+    return deliveries;
+}
+/** Les jours de livraison rouge de chaque projet du dossier, lus dans `<gitCommonDir>/cadence/deliveries-failed.log` (L227). Un projet sans journal compte 0 rouge ; un projet qui n'est pas un dépôt git est absent de la carte ; rien n'est créé. */
+export function readProjectFailedDeliveries(parent, projects) {
+    const failed = new Map();
+    for (const name of projects) {
+        try {
+            failed.set(name, readFailedDeliveries(join(gitCommonDir(join(parent, name)), 'cadence')));
+        }
+        catch {
+            // pas un dépôt git : aucune livraison rouge pour ce projet
+        }
+    }
+    return failed;
+}

package/dist/state.js

@@ -1,5 +1,6 @@
 import { appendFileSync, existsSync, linkSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { isDay } from './dates.js';
 import { gitCommonDir, gitPath } from './git.js';
 /** État local propre au worktree (notes de clôture). */
 export function stateDir(cwd) {
@@ -155,6 +156,10 @@ export function pidAlive(pid) {
 export function appendDelivery(dir, day, sha) {
     appendFileSync(join(dir, 'deliveries.log'), `${day} ${sha}\n`);
 }
+/** Ajoute une livraison rouge (« jour sha raison ») à `deliveries-failed.log` ; la raison est la première ligne du message d'échec. */
+export function appendFailedDelivery(dir, day, sha, reason) {
+    appendFileSync(join(dir, 'deliveries-failed.log'), `${day} ${sha} ${reason.split('\n')[0].trim()}\n`);
+}
 export function lastDelivery(dir) {
     const file = join(dir, 'deliveries.log');
     if (!existsSync(file))
@@ -162,3 +167,27 @@ export function lastDelivery(dir) {
     const last = readFileSync(file, 'utf8').trim().split('\n').pop();
     return last?.split(' ')[1] ?? null;
 }
+/** Tous les jours de `deliveries.log` (une ligne « jour sha » par livraison verte), dans l'ordre du fichier ; null si le fichier est absent ou illisible. Lecture seule : ne crée rien. */
+export function readDeliveries(dir) {
+    try {
+        return readFileSync(join(dir, 'deliveries.log'), 'utf8')
+            .split('\n')
+            .map((l) => l.split(' ')[0])
+            .filter(isDay);
+    }
+    catch {
+        return null;
+    }
+}
+/** Les jours de `deliveries-failed.log` (une ligne « jour sha raison » par livraison rouge), dans l'ordre du fichier ; une ligne illisible est ignorée, un fichier absent ou illisible donne aucune livraison rouge. Lecture seule : ne crée rien. */
+export function readFailedDeliveries(dir) {
+    try {
+        return readFileSync(join(dir, 'deliveries-failed.log'), 'utf8')
+            .split('\n')
+            .map((l) => l.split(' ')[0])
+            .filter(isDay);
+    }
+    catch {
+        return [];
+    }
+}

package/docs/corrections.md

@@ -21,4 +21,4 @@ new passes, and a pass the model could not answer stays out of the cache. `--sam
 evenly over the sorted keys, with their findings and the model's cause, to be read by hand; a `manual` field written
 beside a pass in the cache file (one of the seven causes, else the command refuses the file) overrides the model's cause in every table and gives the **agreement rate** of the model
 on the reviewed sample. `--until date` (ISO, e.g. `2026-10-10T18:31Z`) reads only the waves created up to then (`created` in the wave's `wave.json`) and, in them, only the steps ended by then (`ended`), so that neither later waves nor a wave still running at that time change a published baseline; a wave or a step with no readable date is left out. `--since date` (ISO, same format) keeps only the lots of the waves **created after** that date (`created` in the wave's `wave.json`), **with all their passes**: a wave renders every brief from the copy of the tool frozen when it is created (`<wave>/tool/`), so the creation date of the wave, not the start of a lot, tells which brief the lot was given. A `--continue` wave created before a change of brief therefore does not give it to its lots, even those that start after the change (a difference of two unbounded runs is wrong as soon as a wave straddles the date); the exception is a wave resumed (`--resume`) without a snapshot (older than L61) or, with `--budget project:lot=+N`, from a snapshot older than L223: it runs with the current `dist/` and templates, so it does receive the new brief. A wave with no readable `created` is left out, by `--since` as by `--until`. `--since` is strict and `--until` inclusive, so a wave created exactly at the date is on the `--until` side only and the two sets never overlap; `--since` and `--until` can be combined (a window of creation dates). Together `--until d` and `--since d` split the waves, and they add up to the unbounded total only when `d` is set while no wave is running (between two sessions, as `npm run service` requires; `cadence orchestrate --status` shows none, **and** no wave created before `d` is still resumable: `--status` lists only the live waves, an interrupted or suspended one is not shown and `--resume` would replay passes after `d`; list them with `jq -r 'select(.status != "done") | "\(.id) \(.status) \(.created)"' <folder>/.cadence/runs/*/wave.json`, and finish each before setting `d` or never resume it): a wave created before `d` that ends a pass after `d` leaves that pass in neither (`--until` does not read it, so that a published baseline does not move), and a gap between the sum and the unbounded total means `d` fell inside a wave. `--json` prints the measure as data. The command reads the journals and writes nothing but the cache.
-The first baseline is in [docs/mesures/corrections-2026-10-10.md](mesures/corrections-2026-10-10.md); `test/corrections-mesure.test.ts` replays its command on the journals and checks the document's results word for word (skipped when the journals are not there). The measure of the screen-sheet step against the visible lots of this baseline (L176: 8 lots with a sheet, verdict per row of the success table, token cost beside the passes avoided) is in [docs/mesures/etape-spec-2026-10-12.md](mesures/etape-spec-2026-10-12.md); the target of its third row is ≤ 8 %, half the 16 % reference.
+The first baseline is in [docs/mesures/corrections-2026-10-10.md](mesures/corrections-2026-10-10.md); `test/corrections-mesure.test.ts` replays its command on the journals and checks the document's results word for word (skipped when the journals are not there). The measure of the screen-sheet step against the visible lots of this baseline (L176: 8 lots with a sheet, verdict per row of the success table, token cost beside the passes avoided) is in [docs/mesures/etape-spec-2026-10-12.md](mesures/etape-spec-2026-10-12.md); the target of its third row is ≤ 8 %, half the 16 % reference. The measure of the back-end spec step against the non-visible lots (L190: 10 lots with a back-end sheet, passes by cause, token cost beside the passes avoided) is in [docs/mesures/etape-spec-back-2026-10-16.md](mesures/etape-spec-back-2026-10-16.md).

package/docs/lead.md

@@ -129,6 +129,8 @@ beta · en cours rien · dérive aucune · notes : aucune · prochain T2 Second
 | `attend` | only when a lot waits on its `gate`: `attend L190` |
 | `dépôt` | `non commité` (modified or untracked files), `non poussé` (commits ahead of the upstream), `livraison en cours` (live delivery lock); `propre` otherwise |
 
+Before the project lines the tour prints the **perf header** (L227): one line per `⚠` of `cadence perf` for the folder, in the order of `perf`, each ending with its decision and, for a trend, the value of its quality twin (speed and quality side by side); the net-bottleneck `⚠ goulot` line is relayed as is. Nothing is printed when no `⚠` stands, and the output is then the one of a tour without header. The header is read with `perf`'s own reading of the folder (projects up to two levels, whatever `--depth`) and only in the text output: `--json` is unchanged. When `perf` cannot read the folder (no `.cadence/runs`, malformed price grid, unreadable journals or plans) the tour prints no header, reports no perf error and exits 0. The [lead skill](skills.md) reads the header before proposing the three lots and opens an improvement lot only on a trend confirmed on two windows or a net bottleneck.
+
 When an orchestrated wave is live, one more line closes the tour (not part of `--json`): `vagues en cours : 1 · sessions en cours : 0 · créneaux libres : 1 sur 2` — the lead reads the free slots there instead of computing them (L141). The `sur M` is the cap the human set (`CADENCE_MAX_SESSIONS`, 2 by default), not a fixed 2 (L208); an invalid value falls back to 2 in this display.
 
 `--json` prints the same content as an array of objects (`project`, `doing`, `drift`, `notes`, `waiting` (only when a lot waits on its `gate`),

package/docs/perf.md

@@ -0,0 +1,84 @@
+[← cadence](../README.md)
+
+# perf
+
+`cadence perf [folder] [--since date] [--json]` is the permanent dashboard of the workflow. It calls no model, writes nothing
+(no journal, no plan, no cache) and reads, from the folder (default: the current one), the wave journals
+`<folder>/.cadence/runs/<wave>/<project>--<lot>.json` (with each wave's `wave.json`) and the plan of every project of the folder
+(one nesting level, like `cadence corrections`: `group/gamma`). Exit code `0`, even when a `⚠` is printed; `1` on a usage or read error.
+
+It compares two windows of 7 calendar days (local days): the **current** one (the last 7 days, today included) and the **previous**
+one (the 7 days before). Every speed indicator is printed on the same line as its **quality twin**, never alone ("fast *and* well"):
+
+| Family | Indicator | Twin | Decision it informs |
+|---|---|---|---|
+| Throughput | lots ready, lots handed back per day, lots delivered (plan `done` with `finished` in the window), share of handed-back lots within their token budget | escaped defects | is the flow dropping? look for the bottleneck before adding lots; are the budgets right? |
+| Corrections | median of `fix` passes per lot, share of lots with 2 passes or more | share of lots right the first time (no `fix` pass) | is the first write good enough? harden the sheet or the brief |
+| Corrections | dominant causes (top 3 of the classified passes, the unclassified share apart) | — | which link to fix |
+| Lead interventions | lots handed back by a wave then finished outside it, `ux` sessions per visible lot | escaped defects | does the wave stop too early? does the ergonomics review cost more than one round? |
+
+A line starts with `⚠` and ends with the decision it informs when its value is **worse than the previous window by more than 25 %**
+(a drop for the throughput and the share right the first time; a rise for passes, interventions and escaped defects). No `⚠`, and the line says
+why, when one window holds fewer than 5 lots for the indicator, when the previous value is zero, or when `--since` truncates a window.
+A window with no lot for an indicator (no rendered lot for ready lots, no delivered lot for delivered, none at all for a window entirely before `--since`) gives `n/d` (`null` in JSON), never `0`. A **clear bottleneck** (one cause weighing at least half of the classified passes of the
+current window, with at least 10 classified passes) is flagged by a `⚠` even without a trend.
+
+- **Dating.** A journal is dated by the end of its last step (else by the creation of its wave); a journal without a readable date is left out. A correction pass is dated
+  by the end of its `fix` step. The classification of a pass is `cadence corrections`' (same reading, `src/corrections.ts`): without finding to read it is `sans-constat`,
+  otherwise the cause of `<folder>/.cadence/corrections.json` (a manual cause first), `non-classe` when absent from it. `perf` never classifies: run `cadence corrections --classify`.
+- **Escaped defects** = distinct lots with a plan note dated in the window, written after the lot was done, that starts with `QA` (after the `DD-MM` date prefix) and
+  contains `bloquant` or `majeur` not preceded by `0` or `aucun`. Until a plan holds such a note the value is `n/d` ("aucune note QA reconnue : convention à fixer (L227)"). Reopened lots are not counted: the plan does not date a reopening.
+- **Lead interventions.** A lot counts when its last journal (all waves of the folder) is `handed-back` or `failed` and its plan lot is `done` with `finished` on or after the day it was handed back.
+  A journal joins its plan by the project name (the path of the project relative to the folder) and the `lot` field of the journal; an id `Q4/accueil-4-ux12` joins the plan lot `Q4`. Journals with no plan lot are counted aside (`N lot(s) de journal sans plan`) and never counted as finished outside the wave.
+  An unreadable plan skips its project with a warning on the error output and the other projects are read; the indicators that read the plans are `n/d` only when no plan is readable.
+- **`--since date`** is an ISO date that ignores everything before that day in both windows (a wave created before that day is not read, even if its lots end after it); a window starting before it is *truncated* (its per-day rates divide by the days covered, no `⚠`).
+  It is **not** the instant of `cadence corrections --since` (waves created strictly after).
+- **`--json`** prints one object `{ since, today, windows: { current, previous }, throughput, corrections, interventions, tokens, delays, durations, cost, orphans, warnings }`; every indicator carries
+  `{ current, previous, change, warn, twin, lots, note }` (`twin`: the path of its quality twin, e.g. `throughput.escaped`). Same values as the text.
+
+## Tokens, delays, wall time and cost (L226)
+
+The same two windows, the same `⚠` (more than 25 % worse, at least 5 lots or steps in each window, previous value not zero, no truncated window) and the same
+quality twin (the share of lots right the first time) on the same line. A rise is the worse direction for each of them.
+
+| Indicator | Reading | Decision it informs |
+|---|---|---|
+| tokens per lot, by estimate | median of the counted tokens (sum of `tokens.counted` of every step) of the rendered journals of the window whose lot joins the plan, one class per exact estimate (`0.5`, `1`, `2`…); a failed lot counts, a journal with no readable tokens or without plan lot does not | is the estimate calibrated? redo the split or the budgets |
+| share of review tokens | counted tokens of the steps whose kind starts with `review` or is `ux`, over the counted tokens of all steps of the rendered journals; a ratio, `n/d` without journal | does the review weigh too much against the writing? lighten it (`orchestrate.review.threshold`) |
+| delay created → done | median of `finished − created` (calendar days) of the plan lots `done` with `finished` in the window and both dates readable | is the queue growing? |
+| delay done → delivery | median of the days between `finished` and the first line of the repository's `deliveries.log` on or after it (`<git common dir>/cadence/`, one repository per project, worktrees included; read without creating anything); `n/d` for a project that is not a git repository, has no log or no later line | deliver in smaller batches? |
+| wall time per step kind | median of `ended − started` in minutes of the `ok` steps with both bounds readable, ranked in the window by the local day of `ended`; one line per kind seen | which step is slow? timeouts, effort or model |
+| cost per delivered lot | median in euros of the sum, over every step of every journal of the lot (all waves), of the step cost; lots `done` in the window with at least one journal | is the model chosen for each step right? |
+
+**Price grid.** Declared in the `cadence.yaml` of the folder, euros per million tokens, the three prices mandatory for a declared model:
+
+```yaml
+perf:
+  prices:
+    sonnet: { input: 3, output: 15, cacheRead: 0.3 }
+    opus: { input: 15, output: 75, cacheRead: 1.5 }
+    haiku: { input: 1, output: 5, cacheRead: 0.1 }
+```
+
+An unknown key (under `perf`, under a model, or a model other than `sonnet`, `opus`, `haiku`), a negative or non-numeric price, or an unreadable file refuses the command before any journal is read (`raf: …`, exit 1, no output).
+Without `perf.prices` (absent or empty) the cost is `n/d` and a warning says where to declare it; the other indicators are served.
+
+**Cost of a step** = (`input` + `cacheWrite`) × input price + `output` × output price + `cacheRead` × cacheRead price, per million tokens, at the price of the step's own model. Assumptions written in the sheet (`docs/specs/perf-tokens-delais-cout/fiche.yaml`, R8):
+cache writes are billed at the input price (the grid has no write price, so the cost is slightly underestimated if they are billed more); a step that only carries `counted` (an old journal) is split 90 % input, 10 % output, no cache read;
+a step without any readable token costs 0 € (the lot stays in the population); a `local` step costs 0 € whatever its counters (outside quota and budget) and needs no price.
+A lot with a step of a model that has no price in the grid (or no readable `model`, named `inconnu`) is left out of the cost and a warning on the error output names the model and the number of lots; delivered lots without any journal are counted aside (`N lot(s) livré(s) sans journal`). No `⚠` on a cost that is `n/d`.
+
+No indicator of produced volume (lines of code, commits, total tokens or euros of a window) is printed or exposed: only per-lot medians, median durations and shares come out. Tokens and euros compare lots of the same size; they never set a spending target.
+
+## Delivery quality and the tour header (L227)
+
+`cadence deliver` appends one line `day sha reason` to `<git common dir>/cadence/deliveries-failed.log` for every failure after the lock is taken (script, CI, deploy or check; the reason is the first line of the failure message). A green delivery or a refusal before the lock writes nothing there; `deliveries.log` is unchanged. A failed write of that log leaves the exit code and the failure message of the delivery as they are and adds the warning `deliver : journal des livraisons rouges non écrit : <cause>` on the error output. An exception or a crash of `deliver` writes no line.
+
+| Indicator | Reading | Twin | Decision it informs |
+|---|---|---|---|
+| red deliveries | lines of every project's `deliveries-failed.log` dated in the window; a repository without the file counts `0` (not `n/d`), an unreadable line, or an unreadable file, counts nothing; printed on the « livrés » line | delivered lots | the delivery breaks: fix CI, deploy or checks before adding lots |
+| blocking QA findings | plan notes dated in the window, on a lot already `done` at the note's date, that start with `QA` and contain `bloquant` not preceded by `0` or `aucun` (`majeur` alone does not count); counted note by note, unlike the escaped defects; `n/d` until a note is recognised; printed on the escaped-defects line | escaped defects | the review lets serious defects through: harden the review before delivering more |
+
+Both are judged like the other indicators (`⚠` above +25 %). For red deliveries the sample is the deliveries of the window, green and red (at least 5 per window); for blocking QA findings it is the plan lots `done` in the window (at least 5 per window). `--json` adds `quality: { redDeliveries, qaBlocking }` (Indicator format, `twin` `throughput.delivered` and `throughput.escaped`); every other key is unchanged, and `throughput.delivered.twin` stays `throughput.escaped`.
+
+`cadence lead tour` prints the `⚠` lines of `perf` as its **perf header** (see [lead tour](lead.md#lead-tour)).

package/docs/whats-new.md

@@ -4,6 +4,8 @@
 
 The long form of the README's « What's new » (the README keeps two lines per version). The full history, with the date of each version, is in [CHANGELOG.md](../CHANGELOG.md).
 
+**1.8.0**: `cadence perf [folder] [--since date] [--json]` is the permanent dashboard of the workflow, without a model: the last 7 days against the 7 before, read in `.cadence/runs`, with a `⚠` on a trend or a bottleneck (L225); `perf.prices` prices the lots in euros (L226); `cadence deliver` writes `deliveries-failed.log` and `cadence lead tour` opens with a perf header (L227). The measure of the back-end spec step on 10 lots is in `docs/mesures` (L190). The release was blocked by a test that required an entry under `[Unreleased]` (L235). Details: [docs/perf.md](perf.md).
+
 **1.7.0**: `cadence orchestrate` no longer replays the `accept` step of a lot whose acceptation is green and sealed, e.g. after a `cadence spec reseal`, and the `accept` brief and the `acceptance-writer` agent may no longer rewrite a green oracle (L233); `cadence orchestrate --resume … --dry-run` is refused before anything is written instead of resuming the wave for real (L228); `cadence spec reseal <delivered lot> … --porteur` accepts a sheet amended by commits of another delivered lot, and its refusal names the commit and the way out (L229); the README is a short home page (about 5 kB instead of 208 kB in the package), the rest moved unchanged to `docs/` pages checked by `scripts/check-links.mjs`, and a commit that touches only the version fields, the CHANGELOG, « What's new » and `docs/whats-new.md` is a version commit for `raf check` and `raf done` (L232).
 
 **1.6.0**: the mockup review sweeps everything in its first report and runs up to `orchestrate.maquetteReviews` times (new key, default 3 instead of 2), and a review may mark a finding `inchange` (L230); the acceptance lock opens its exception only through a commit of the lot in progress that amends the sheet after the red commit, and names the first offending commit (L231).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "A small, repo-native working method: a versioned plan linked to your commits, a changelog with screenshots, session rituals and deliveries proven by their effect.",
   "license": "MIT",
   "author": "Sylvain Ladoire",
@@ -26,6 +26,7 @@
     "docs/news.md",
     "docs/session.md",
     "docs/corrections.md",
+    "docs/perf.md",
     "docs/skills.md",
     "docs/cadence-hud.md",
     "docs/releasing.md",

package/skills/lead/SKILL.md

@@ -40,6 +40,13 @@ repository state — and exits 0 even when a project is in error (its line says
 content. Read the lines yourself; open a project's own `cadence session start` only for the one you need to
 look at closer.
 
+The tour opens with the **perf header**: one line per `⚠` of `cadence perf` (speed and quality side by side), nothing
+when everything is stable. Read it **before proposing the three items** and relay each `⚠` in one line in your report.
+Open an **improvement lot** only on a trend confirmed on two windows (a `⚠` of trend: two windows compared, enough lots, window
+not truncated) or on a net bottleneck (`⚠ goulot`): at most one improvement lot per tour, in addition to the three, never in
+their place, and the human decides. Never open a lot for a micro-optimisation or for the variation of a single window.
+Without a `⚠`, the header is empty and you say nothing about perf.
+
 Then report to the human in a compact table — one row per project — and propose **three** items
 across projects, each with project, lot id and one sentence of justification: finish what is in
 progress, then drift that blocks a delivery, then ready quick wins. **Stop and wait for the priority.**