@sylad/cadence 1.7.0 → 1.9.0

package/dist/perf.js

@@ -0,0 +1,620 @@
+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 { FAIL_CLASSES, readDeliveries, readFailedEntries } 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;
+/** Durées de mur : sous ce nombre d'étapes dans l'une des deux fenêtres, pas de tendance (L280). Mesuré sur 12–18-10 contre 05–11 et 17–23-10 contre 10–16 : sous 10 étapes, la variation d'une fenêtre à l'autre n'est pas interprétable (`accept` −61 % sur 7, `ux` +31 % sur 5, sans changement du travail). */
+const MIN_STEPS = 10;
+/** 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 étapes de la chaîne spec : un lot qui en a une est mesuré à part pour ses tokens (L240). */
+const SPEC_CHAIN = new Set(['spec', 'fiche', 'maquette', 'accept']);
+/**
+ * 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',
+    precheck: 'le précheck livre peu de « oui » : le restreindre ou le confier au modèle local',
+    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, minSample = MIN_SAMPLE) {
+    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 < minSample || lots.previous < minSample))
+            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 };
+}
+/** Ordre des classes de tokens : estimate croissant, la classe « +spec » après la classe ordinaire du même estimate. */
+const byEstimateKey = (a, b) => parseFloat(a) - parseFloat(b) || a.length - b.length;
+/** 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;
+    const byReview = {};
+    for (const { pass, day } of passes) {
+        if (!inWindow(day, w))
+            continue;
+        if (pass.findings.length === 0) {
+            withoutFindings++;
+            continue;
+        }
+        if (pass.reviewKind)
+            byReview[pass.reviewKind] = (byReview[pass.reviewKind] ?? 0) + 1;
+        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, byReview };
+}
+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);
+    // Une session qui voit l'application : l'étape ux, et la review-small d'un petit lot visible (sa seule revue d'ergonomie, `seesApp` du cycle) ; celle d'un lot plus gros n'est qu'une revue de code (L283).
+    const seesApp = (j, s) => s.status === 'ok' && (s.kind === 'ux' || (s.kind === 'review-small' && j.small));
+    const ux = both(windows, (w) => {
+        const set = visibleRendered(w);
+        return set.length === 0 ? null : set.reduce((sum, d) => sum + d.j.steps.filter((s) => seesApp(d.j, s)).length, 0) / set.length;
+    });
+    const dedicatedUx = both(windows, (w) => {
+        const set = visibleRendered(w);
+        return set.length === 0 ? null : set.filter((d) => d.j.steps.some((s) => s.kind === 'ux' && s.status === 'ok')).length / set.length;
+    });
+    const prechecked = (w) => rendered(w).filter((d) => d.j.precheck !== undefined);
+    const precheckYes = both(windows, (w) => {
+        const set = prechecked(w);
+        return set.length === 0 ? null : set.filter((d) => d.j.precheck === 'oui').length / 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, minSample = MIN_SAMPLE) => indicator(vals.current, vals.previous, lots, windows, dir, twin, nullNote, minSample);
+    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;
+            // Un lot passé par la chaîne spec (écran ou back) coûte plus que le lot ordinaire de même estimate (mesuré le 12–18-10 : +150 k à l'estimate 0,5, +30 k à 1 ; 450 k est l'écart de budget, pas l'écart mesuré) : classe à part, sinon l'arrivée de ces lots dans une fenêtre passe pour un lot ordinaire plus lourd (L240).
+            const key = `${p.estimate}${d.j.steps.some((x) => SPEC_CHAIN.has(x.kind)) ? '+spec' : ''}`;
+            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(byEstimateKey);
+    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, null, MIN_STEPS);
+    }
+    // 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), dedicatedUx: mk(dedicatedUx, visibleCounts, null, null) };
+    const precheck = { yes: mk(precheckYes, both(windows, (w) => prechecked(w).length), null, null) };
+    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 breakdown = (w) => {
+        const b = { count: 0, byClass: { refus: 0, ci: 0, deploiement: 0, verification: 0, inconnue: 0 }, byProject: {} };
+        for (const [project, entries] of input.failures ?? []) {
+            for (const e of entries.filter((x) => inWindow(x.day, w))) {
+                const cls = e.cls ?? 'inconnue';
+                b.count += 1;
+                b.byClass[cls] += 1;
+                const p = (b.byProject[project] ??= {});
+                p[cls] = (p[cls] ?? 0) + 1;
+            }
+        }
+        return b;
+    };
+    const quality = {
+        reds: both(windows, breakdown),
+        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, precheck, 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 quatorze premières lignes de `indicatorLines` sont celles de L225 (dont la part des lots visibles revus par une étape ux, L283, et la part de « oui » du précheck, L288) et les deux de qualité de livraison de L227 ; les suivantes sont celles de L226. */
+const LEGACY_LINES = 14;
+/** 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]) => byEstimateKey(a, 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 des lots visibles revus par une étape ux', kind: 'share', decision: 'ux' }, r.interventions.dedicatedUx],
+        [{ label: 'part de « oui » du précheck', kind: 'share', decision: 'precheck' }, r.precheck.yes],
+        [{ 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;
+}
+const RED_LABELS = { refus: 'refus avant action', ci: 'CI', deploiement: 'déploiement', verification: 'vérification', inconnue: 'non classée' };
+/** Deux lignes (par classe, par projet) des livraisons rouges de la fenêtre courante, la plus grosse d'abord ; aucune sans livraison rouge. */
+function redBreakdownLines(b) {
+    if (b.count === 0)
+        return [];
+    const order = (a, c) => c[1] - a[1] || a[0].localeCompare(c[0]);
+    // À égalité, l'ordre des étapes de la livraison (refus, CI, déploiement, vérification), les lignes sans classe en dernier.
+    const rank = (k) => (k === 'inconnue' ? FAIL_CLASSES.length : FAIL_CLASSES.indexOf(k));
+    const classes = (counts) => Object.entries(counts).filter(([, n]) => n > 0).sort((a, c) => c[1] - a[1] || rank(a[0]) - rank(c[0])).map(([k, n]) => [RED_LABELS[k], n]);
+    const byProject = Object.entries(b.byProject)
+        .map(([name, counts]) => [name, Object.values(counts).reduce((a, n) => a + n, 0), classes(counts)])
+        .sort((a, c) => order([a[0], a[1]], [c[0], c[1]]));
+    return [
+        `  livraisons rouges par classe (fenêtre courante) : ${classes(b.byClass).map(([k, n]) => `${k} ${n}`).join(' · ')}`,
+        `  livraisons rouges par projet : ${byProject.map(([name, n, cl]) => `${name} ${n} (${cl.map(([k, c]) => `${k} ${c}`).join(', ')})`).join(' · ')}`,
+    ];
+}
+/** 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']);
+    out.push(...redBreakdownLines(r.quality.reds.current));
+    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}${c.unclassified > 0 ? ' · à classer : cadence corrections --classify' : ''}`);
+    const origins = Object.entries(c.byReview).sort(([a, x], [b, y]) => y - x || a.localeCompare(b));
+    if (origins.length > 0)
+        out.push(`  origine des passes à constats : ${origins.map(([k, n]) => `${k} ${n}`).join(' · ')}`);
+    section('Interventions du lead', ['lots terminés hors vague', 'sessions ux par lot visible', 'part des lots visibles revus par une étape ux']);
+    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'})`);
+    section('Contrôle préalable', ['part de « oui » du précheck']);
+    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 livraisons rouges (jour, classe, raison) de chaque projet du dossier, lues 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 readProjectFailedEntries(parent, projects) {
+    const failed = new Map();
+    for (const name of projects) {
+        try {
+            failed.set(name, readFailedEntries(join(gitCommonDir(join(parent, name)), 'cadence')));
+        }
+        catch {
+            // pas un dépôt git : aucune livraison rouge pour ce projet
+        }
+    }
+    return failed;
+}