@sylad/cadence 1.8.0 → 1.10.0

package/dist/perf.js

@@ -4,14 +4,18 @@ 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';
+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.
@@ -89,6 +93,7 @@ const DECISIONS = {
     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)',
@@ -99,7 +104,7 @@ const DECISIONS = {
     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) {
+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;
@@ -109,7 +114,7 @@ function indicator(current, previous, lots, windows, dir, twin, nullNote = 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))
+        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';
@@ -118,12 +123,15 @@ function indicator(current, previous, lots, windows, dir, twin, nullNote = null)
     }
     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;
@@ -131,6 +139,8 @@ function causeWindow(passes, w, cache) {
             withoutFindings++;
             continue;
         }
+        if (pass.reviewKind)
+            byReview[pass.reviewKind] = (byReview[pass.reviewKind] ?? 0) + 1;
         const c = cache.get(pass.key);
         if (!c) {
             unclassified++;
@@ -145,7 +155,20 @@ function causeWindow(passes, w, cache) {
         .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 };
+    return { top, classified, unclassified, withoutFindings, unclassifiedShare: withFindings === 0 ? null : unclassified / withFindings, byReview };
+}
+/** La sorte d'étape sous laquelle la hausse se compte : `review` et `review-small` ne font qu'une (la taille du lot choisit l'une ou l'autre, `orchestrate.review.threshold` : le passage de l'une à l'autre n'est pas une hausse). */
+const carrierKind = (kind) => (kind === 'review-small' ? 'review' : kind);
+/** L'étape qui porte la hausse (L312) : la sorte d'étape dont la moyenne des jetons par lot monte le plus ; null sans hausse nette du total par lot, ou sans lot dans l'une des fenêtres. */
+function carrierOf(current, previous) {
+    if (current.length === 0 || previous.length === 0)
+        return null;
+    const mean = (lots, kind) => lots.reduce((sum, l) => sum + (l.get(kind) ?? 0), 0) / lots.length;
+    const kinds = new Set([...current, ...previous].flatMap((l) => [...l.keys()]));
+    const rises = [...kinds].map((kind) => ({ kind, delta: mean(current, kind) - mean(previous, kind) }));
+    const net = rises.reduce((sum, r) => sum + r.delta, 0);
+    const top = rises.sort((a, b) => b.delta - a.delta || a.kind.localeCompare(b.kind))[0];
+    return net > 0 && top && top.delta > 0 ? top : null;
 }
 export function computePerf(input) {
     const { plans, cache, windows, today } = input;
@@ -218,13 +241,24 @@ export function computePerf(input) {
         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) => s.kind === 'ux' && s.status === 'ok').length, 0) / set.length;
+        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) => indicator(vals.current, vals.previous, lots, windows, dir, twin, nullNote);
+    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';
@@ -235,17 +269,22 @@ export function computePerf(input) {
             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)]);
+            // 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' : ''}`;
+            const kinds = new Map();
+            for (const x of counted)
+                kinds.set(carrierKind(x.kind), (kinds.get(carrierKind(x.kind)) ?? 0) + x.counted);
+            classes.set(key, [...(classes.get(key) ?? []), { total: counted.reduce((sum, x) => sum + x.counted, 0), kinds }]);
         }
         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));
+    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 lotsOfClass = both(windows, (w) => (w === windows.current ? byClass.current : byClass.previous).get(key) ?? []);
+        const vals = both(windows, (w) => median((w === windows.current ? lotsOfClass.current : lotsOfClass.previous).map((l) => l.total)));
+        byEstimate[key] = { ...mk(vals, { current: lotsOfClass.current.length, previous: lotsOfClass.previous.length }, 'up', twinFirstTime), carrier: carrierOf(lotsOfClass.current.map((l) => l.kinds), lotsOfClass.previous.map((l) => l.kinds)) };
     }
     const reviewShare = both(windows, (w) => {
         let review = 0;
@@ -278,7 +317,7 @@ export function computePerf(input) {
     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);
+        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;
@@ -336,7 +375,8 @@ export function computePerf(input) {
         causes,
     };
     const handed = mk(handedOut, lotsOf, 'up', twinEscaped, planNote);
-    const interventions = { handedOut: { ...handed, count: handedCount }, ux: mk(ux, visibleCounts, 'up', twinEscaped) };
+    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), ...precheckMeasure(windows, rendered) };
     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),
@@ -357,19 +397,79 @@ export function computePerf(input) {
             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, tokens, delays, durations, cost, quality, orphans, warnings: [] };
+    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]}`);
+            result.warnings.push(`⚠ ${key.label} : ${describe(ind, key.kind)} → ${decisionOf(key, ind, result)}`);
     if (bottleneck)
         result.warnings.push(bottleneck);
     return result;
 }
+const minutesOf = (s) => {
+    const from = Date.parse(s.started ?? '');
+    const to = Date.parse(s.ended ?? '');
+    return Number.isNaN(from) || Number.isNaN(to) || to < from ? 0 : (to - from) / 60_000;
+};
+/** Le contrôle préalable mesuré (L322) : répartition des verdicts, durée et tokens des sessions (local, Sonnet), gain des « oui », une ligne par lot de la fenêtre courante. */
+function precheckMeasure(windows, rendered) {
+    const verdicts = (w) => {
+        const out = { oui: 0, partiel: 0, non: 0 };
+        for (const d of rendered(w))
+            if (d.j.precheck)
+                out[d.j.precheck]++;
+        return out;
+    };
+    const cost = (w) => {
+        const set = rendered(w);
+        const steps = set.flatMap((d) => d.j.steps.filter((s) => s.kind === 'precheck'));
+        const local = steps.filter((s) => s.model === 'local');
+        const sonnet = steps.filter((s) => s.model !== 'local');
+        // Un échec du local = une étape qui n'a pas fini `ok`, ou finie `ok` mais au rapport illisible (docs/perf.md : « ended without a usable report »).
+        const unusable = new Set(set.filter((d) => d.j.localUnreadable).flatMap((d) => d.j.steps.filter((s) => s.kind === 'precheck' && s.model === 'local')));
+        const implement = set.flatMap((d) => d.j.steps.filter((s) => s.kind === 'implement' && s.counted !== undefined).map((s) => s.counted));
+        const avoided = set.filter((d) => d.j.precheck === 'oui' && d.j.status === 'handed-back').length;
+        const typical = median(implement);
+        return {
+            local: { runs: local.length, failed: local.filter((s) => s.status !== 'ok' || unusable.has(s)).length, minutes: local.reduce((n, s) => n + minutesOf(s), 0) },
+            sonnet: { runs: sonnet.length, minutes: sonnet.reduce((n, s) => n + minutesOf(s), 0), tokens: sonnet.reduce((n, s) => n + (s.counted ?? 0), 0) },
+            avoided: { sessions: avoided, tokens: avoided === 0 ? 0 : typical === null ? null : avoided * typical },
+        };
+    };
+    const lots = rendered(windows.current).flatMap((d) => {
+        const steps = d.j.steps.filter((s) => s.kind === 'precheck');
+        if (steps.length === 0 && !d.j.precheck)
+            return [];
+        const local = steps.find((s) => s.model === 'local');
+        const sonnet = steps.filter((s) => s.model !== 'local');
+        return [{
+                project: d.j.project,
+                lot: d.j.lot,
+                verdict: d.j.precheck ?? null,
+                local: local ? { status: local.status === 'ok' && d.j.localUnreadable ? 'illisible' : local.status, minutes: minutesOf(local) } : null,
+                sonnet: sonnet.length ? { minutes: sonnet.reduce((n, s) => n + minutesOf(s), 0), tokens: sonnet.reduce((n, s) => n + (s.counted ?? 0), 0) } : null,
+            }];
+    });
+    return { verdicts: both(windows, verdicts), cost: both(windows, cost), lots };
+}
 /** 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];
@@ -386,12 +486,12 @@ const LABELS = {
     '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 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]) => Number(a) - Number(b)).map(([k, ind]) => [{ label: `tokens par lot (estimate ${k})`, kind: 'tokens', decision: 'tokens' }, ind]),
+        ...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],
@@ -407,6 +507,8 @@ function indicatorLines(r) {
         [{ 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],
@@ -436,6 +538,20 @@ const signed = (c) => `${c >= 0 ? '+' : '−'}${Math.round(100 * Math.abs(c))} %
 function describe(ind, kind) {
     return `${value(ind.current, kind)} (précédente ${value(ind.previous, kind)}${ind.change === null ? '' : `, ${signed(ind.change)}`})`;
 }
+/**
+ * La décision d'un ⚠ (L312). Celle des tokens par lot cite l'étape qui porte la hausse : quand la part conforme du premier coup monte en même temps,
+ * la hausse est de la qualité payée à cette étape, plus une estimate fausse ; sinon l'estimate reste suspecte, avec l'étape.
+ */
+function decisionOf(line, ind, r) {
+    const carrier = ind.carrier;
+    if (line.decision !== 'tokens' || !carrier)
+        return DECISIONS[line.decision];
+    const where = `la hausse est portée par l'étape ${carrier.kind} (+${value(carrier.delta, 'tokens')} par lot)`;
+    const { current, previous } = r.corrections.firstTime;
+    if (current !== null && previous !== null && current > previous)
+        return `${where} alors que la part conforme du premier coup monte : de la qualité payée, pas une estimate fausse ; juger cette étape (modèle, effort, passes) avant de recaler l'estimate`;
+    return `l'estimate est mal calibrée : ${where} : redécouper le lot ou recaler l'estimate et les budgets`;
+}
 /** Les lignes que désigne le chemin `twin` d'un indicateur. */
 function twinsByPath(lines) {
     const at = (label) => lines.find(([l]) => l.label === label);
@@ -457,11 +573,28 @@ export function perfHeader(r) {
         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(`⚠ ${line.label} : ${describe(ind, line.kind)}${twin ? ` · ${twin[0].label} : ${describe(twin[1], twin[0].kind)}` : ''} → ${decisionOf(line, ind, r)}`);
     }
     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);
@@ -485,7 +618,7 @@ export function renderPerf(r) {
         if (ind.note)
             parts.push(ind.note);
         if (ind.warn)
-            parts.push(`→ ${DECISIONS[line.decision]}`);
+            parts.push(`→ ${decisionOf(line, ind, r)}`);
         if (extra?.[1].warn)
             parts.push(`→ ${DECISIONS[extra[0].decision]}`);
         return parts.join(' · ');
@@ -496,13 +629,19 @@ export function renderPerf(r) {
             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}`);
-    section('Interventions du lead', ['lots terminés hors vague', 'sessions ux par lot visible']);
+    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(...precheckLines(r.precheck));
     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));
@@ -515,6 +654,30 @@ export function renderPerf(r) {
         out.push('', `${r.orphans} lot(s) de journal sans plan`);
     return out;
 }
+const plural = (n, one, many) => `${n} ${n > 1 ? many : one}`;
+/** Le contrôle préalable de la fenêtre courante (L322) : répartition, coût local puis Sonnet, gain des « oui », une ligne par lot. Rien sans session de contrôle ni verdict. */
+function precheckLines(p) {
+    const v = p.verdicts.current;
+    const c = p.cost.current;
+    if (v.oui + v.partiel + v.non + c.local.runs + c.sonnet.runs === 0)
+        return [];
+    const out = [`  précheck : oui ${v.oui} · partiel ${v.partiel} · non ${v.non}`];
+    if (c.local.runs > 0)
+        out.push(`  précheck local : ${plural(c.local.runs, 'session', 'sessions')}, ${plural(c.local.failed, 'échec', 'échecs')}, ${num(Math.round(c.local.minutes))} min`);
+    if (c.sonnet.runs > 0)
+        out.push(`  précheck Sonnet : ${plural(c.sonnet.runs, 'session', 'sessions')}, ${value(c.sonnet.tokens, 'tokens')} tokens, ${num(Math.round(c.sonnet.minutes))} min`);
+    if (c.avoided.sessions > 0)
+        out.push(`  gain des « oui » : ${plural(c.avoided.sessions, "session d'implémentation évitée", "sessions d'implémentation évitées")}${c.avoided.tokens === null ? ' (gain en tokens : n/d)' : ` (≈ ${value(c.avoided.tokens, 'tokens')} tokens)`}`);
+    for (const l of p.lots) {
+        const parts = [`${l.project}:${l.lot}`, l.verdict ?? 'sans verdict'];
+        if (l.local)
+            parts.push(`local ${l.local.status === 'ok' ? 'ok' : 'échec'} ${num(Math.round(l.local.minutes))} min`);
+        if (l.sonnet)
+            parts.push(`Sonnet ${num(Math.round(l.sonnet.minutes))} min, ${value(l.sonnet.tokens, 'tokens')} tokens`);
+        out.push(`    ${parts.join(' · ')}`);
+    }
+    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();
@@ -544,12 +707,12 @@ export function readProjectDeliveries(parent, projects) {
     }
     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) {
+/** 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, readFailedDeliveries(join(gitCommonDir(join(parent, name)), 'cadence')));
+            failed.set(name, readFailedEntries(join(gitCommonDir(join(parent, name)), 'cadence')));
         }
         catch {
             // pas un dépôt git : aucune livraison rouge pour ce projet

package/dist/plan.js

@@ -6,7 +6,18 @@ export const STATUSES = ['todo', 'doing', 'done', 'dropped'];
 export const GATE_INVALID = 'gate invalide : count: entier ≥ 1 et un critère spec: true ou screen: page attendus';
 export class RafError extends Error {
 }
-export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'screen', 'spec', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'repos', 'parent', 'gate'];
+/** Un nom de ressource partagée (L251) : un mot de lettres minuscules, chiffres, « - » et « _ ». */
+export const RESOURCE_NAME = /^[a-z0-9_-]+$/;
+export const RESOURCES_BAD_LIST = 'doit être une liste de noms de ressources';
+export const invalidResource = (name) => `ressource invalide : ${name === '' ? '(vide)' : name} (lettres minuscules, chiffres, - et _)`;
+/** Les noms de ressources de `--uses` ou de `raf uses` : chacun valide (`RafError` sinon), sans doublon, dans l'ordre donné. */
+export function cleanUses(names) {
+    for (const n of names)
+        if (!RESOURCE_NAME.test(n))
+            throw new RafError(invalidResource(n));
+    return [...new Set(names)];
+}
+export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'screen', 'spec', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'repos', 'parent', 'gate', 'goal'];
 /** Nature de l'écran d'un lot visible : nouvelle page, nouveau composant, parcours modifié. */
 export const SCREENS = ['page', 'component', 'journey'];
 export function isOpen(status) {
@@ -61,6 +72,10 @@ export class Plan {
     get hasPublicField() {
         return !this.settings.format || !!this.settings.format.fields.public || this.read().lots.some((l) => l.public !== undefined);
     }
+    /** Un plan en lecture seule porte `visible` seulement si cadence.yaml le mappe (`plan.fields.visible`) ou si un lot l'écrit déjà sous ce nom. */
+    get hasVisibleField() {
+        return !this.settings.format || !!this.settings.format.fields.visible || this.read().lots.some((l) => l.visible);
+    }
     get readonly() {
         return !!this.settings.format;
     }
@@ -238,8 +253,8 @@ export class Plan {
         return this.enableGate('reviewSince', today);
     }
     /** `commit` : sha du dernier commit compté du lot (le plan ne lit pas git), null s'il n'en a aucun. */
-    recordReview(lotId, verdict, today, commit, repos) {
-        this.recordVerdict('review', 'la revue de code', lotId, { date: today, verdict, commit, ...(repos && Object.keys(repos).length ? { repos } : {}) });
+    recordReview(lotId, verdict, today, commit, repos, reporte) {
+        this.recordVerdict('review', 'la revue de code', lotId, { date: today, verdict, commit, ...(repos && Object.keys(repos).length ? { repos } : {}), ...(reporte ? { reporte } : {}) });
     }
     enableGate(key, today) {
         this.writable();
@@ -326,11 +341,15 @@ export class Plan {
             entry.every = opts.every;
         if (opts.after?.length)
             entry.after = opts.after;
+        if (opts.uses?.length)
+            entry.uses = cleanUses(opts.uses);
         entry.created = today;
         const node = this.doc.createNode(entry);
-        const after = node.get('after');
-        if (isSeq(after))
-            after.flow = true;
+        for (const key of ['after', 'uses']) {
+            const seq = node.get(key);
+            if (isSeq(seq))
+                seq.flow = true;
+        }
         this.doc.get('lots').add(node);
         return id;
     }
@@ -341,6 +360,40 @@ export class Plan {
         node.flow = true;
         this.lotNode(lotId).set('repos', node);
     }
+    /** Acquitte l'écart `docs.sync` d'un lot (L317) : clé `docs_ok: { date, reason }`, la raison est obligatoire. Jamais sur une sous-tâche. */
+    setDocsOk(ref, reason, today) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`docs-ok se pose sur un lot, pas sur une sous-tâche : ${ref}`);
+        const why = reason.trim();
+        if (!why)
+            throw new RafError('docs-ok exige une raison : raf docs-ok <lot> --reason "pourquoi la documentation reste telle quelle"');
+        const node = this.doc.createNode({ date: today, reason: why });
+        node.flow = true;
+        this.lotNode(ref).set('docs_ok', node);
+    }
+    /** Remplace les ressources partagées d'un lot de tout statut (clé `uses:` en flow, avant `created:`) ; sans nom, retire la clé. Jamais sur une sous-tâche. */
+    setUses(ref, names) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`uses se pose sur un lot, pas sur une sous-tâche : ${ref}`);
+        const node = this.lotNode(ref);
+        const uses = cleanUses(names);
+        if (uses.length === 0) {
+            node.delete('uses');
+            return;
+        }
+        const list = this.doc.createNode(uses);
+        list.flow = true;
+        if (node.has('uses')) {
+            node.set('uses', list);
+            return;
+        }
+        const keys = node.items.map((p) => String(p.key?.value ?? p.key));
+        const created = keys.indexOf('created');
+        const after = keys.indexOf('after');
+        node.items.splice(created >= 0 ? created : after >= 0 ? after + 1 : keys.length, 0, this.doc.createPair('uses', list));
+    }
     addTask(lotId, title) {
         this.writable();
         const lot = this.lotNode(lotId);
@@ -421,6 +474,21 @@ export class Plan {
         node.delete('started');
         this.note(ref, reason.trim() ? `remis en attente : ${reason.trim()}` : 'remis en attente', today);
     }
+    /** Remplace le titre d'un lot, de tout statut, et note l'ancien titre ; refuse un titre vide ou identique. */
+    setTitle(ref, text, today) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`raf title se pose sur un lot, pas une sous-tâche : ${ref}`);
+        const title = text.trim();
+        if (title === '')
+            throw new RafError('titre vide — raf title <id> "nouveau titre"');
+        const node = this.lotNode(ref);
+        const old = String(node.get('title') ?? '');
+        if (old === title)
+            throw new RafError(`${ref} porte déjà ce titre`);
+        node.set('title', title);
+        this.note(ref, `titre remplacé : « ${old} »`, today);
+    }
     /** Pose, remplace (texte) ou efface (null) le titre public d'un lot ; la clé suit `title`. */
     setPublic(ref, text) {
         this.writable();
@@ -460,6 +528,27 @@ export class Plan {
         const keys = node.items.map((p) => String(p.key?.value ?? p.key));
         node.items.splice(keys.indexOf('visible') + 1, 0, this.doc.createPair('screen', screen));
     }
+    /** Pose (true) ou retire (false) le `visible:` d'un lot existant ; retirer est refusé tant que le lot a un `screen:` (un écran est un changement visible). */
+    setVisible(ref, on) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`visible se pose sur un lot, pas une sous-tâche : ${ref}`);
+        const node = this.lotNode(ref);
+        const lot = this.lot(ref);
+        if (!on) {
+            if (lot.screen)
+                throw new RafError(`${ref} a screen: ${lot.screen} — retirer d'abord screen: (raf screen ${ref} none), un écran est un changement visible`);
+            node.delete('visible');
+            return;
+        }
+        if (node.has('visible')) {
+            node.set('visible', true);
+            return;
+        }
+        const keys = node.items.map((p) => String(p.key?.value ?? p.key));
+        const at = Math.max(...['quickwin', 'estimate', 'status'].map((k) => keys.indexOf(k)));
+        node.items.splice(at + 1, 0, this.doc.createPair('visible', true));
+    }
     /** Pose (true) ou retire (false) le `spec:` d'un lot existant ; `screen: page` l'implique, donc on ne retire pas la spec d'un lot à page (`component` et `journey` suivent le chemin ordinaire depuis L209 : leur `spec: true` est la spec back). Renvoie false quand `screen: page` rendait la pose sans objet. */
     setSpec(ref, on) {
         this.writable();
@@ -565,6 +654,7 @@ function foreignLots(raw, format) {
             notes: typeof notes === 'string' ? [{ text: notes }] : notes,
             repos: pick('repos'),
             gate: pick('gate'),
+            goal: pick('goal'),
         }, problems);
         const parent = pick('parent');
         return { lot, parent: parent == null ? undefined : String(parent) };
@@ -578,7 +668,7 @@ function foreignLots(raw, format) {
             into.problems.push(...lot.problems.map((p) => `${lot.id} : ${p}`));
         }
         else {
-            lots.push(lot);
+            lots.push(parent ? { ...lot, parent } : lot);
         }
     }
     return lots;
@@ -622,6 +712,13 @@ function normalizeLot(raw, problems = []) {
     };
     const after = raw.after == null ? [] : Array.isArray(raw.after) ? raw.after.map(String) : [String(raw.after)];
     const last = asDay('last');
+    let uses;
+    if (raw.uses != null) {
+        if (Array.isArray(raw.uses) && raw.uses.every((n) => typeof n === 'string' && RESOURCE_NAME.test(n)))
+            uses = [...new Set(raw.uses)];
+        else
+            problems.push(`uses ${RESOURCES_BAD_LIST}`);
+    }
     let screen;
     if (raw.screen != null) {
         if (SCREENS.includes(raw.screen))
@@ -639,6 +736,8 @@ function normalizeLot(raw, problems = []) {
             problems.push(`spec : true ou false attendu (reçu « ${String(raw.spec)} »)`);
     }
     const gate = readGate(raw.gate, problems);
+    const okRaw = raw.docs_ok;
+    const docsOk = okRaw && typeof okRaw === 'object' && typeof okRaw.reason === 'string' && okRaw.reason.trim() !== '' ? { date: String(okRaw.date ?? ''), reason: okRaw.reason.trim() } : undefined;
     return {
         id: String(raw.id),
         title: String(raw.title ?? ''),
@@ -650,9 +749,11 @@ function normalizeLot(raw, problems = []) {
         ...(spec ? { spec } : {}),
         ...(gate ? { gate } : {}),
         ...(typeof raw.public === 'string' && raw.public.trim() !== '' ? { public: raw.public.trim() } : {}),
+        ...(typeof raw.goal === 'string' && raw.goal.trim() !== '' ? { goal: raw.goal.trim() } : {}),
         ...(Number.isInteger(raw.every) && raw.every > 0 ? { every: raw.every } : {}),
         ...(last ? { last } : {}),
         after,
+        ...(uses?.length ? { uses } : {}),
         created: asDay('created'),
         started: asDay('started'),
         finished: asDay('finished'),
@@ -669,6 +770,7 @@ function normalizeLot(raw, problems = []) {
         ...(repoList(raw.repos).length ? { repos: repoList(raw.repos) } : {}),
         ...(asVerdict(raw.ux) ? { ux: asVerdict(raw.ux) } : {}),
         ...(asVerdict(raw.review) ? { review: asVerdict(raw.review) } : {}),
+        ...(docsOk ? { docsOk } : {}),
         problems,
     };
 }
@@ -705,5 +807,8 @@ function asVerdict(raw) {
         if (repos.length)
             verdict.repos = Object.fromEntries(repos);
     }
+    const r = v.reporte;
+    if (r && typeof r === 'object' && !Array.isArray(r) && r.de != null && r.vers != null)
+        verdict.reporte = { de: String(r.de), vers: String(r.vers), patchId: String(r.patchId ?? '') };
     return verdict;
 }

package/dist/proc.js

@@ -12,6 +12,12 @@ let dying = false;
  * ses `trap` et le nettoyage de git (index.lock) ont ce temps pour finir avant le kill.
  */
 export const SIGNAL_GRACE_MS = 2_000;
+/**
+ * Attente, après la sortie de la commande racine, d'un signal de terminaison encore en route vers cadence tant que des
+ * processus suivis vivent ou que la racine est morte d'un tel signal : le terminal l'envoie au groupe entier, la racine
+ * peut être traitée la première.
+ */
+export const SIGNAL_PENDING_MS = 2_000;
 async function onSignal(sig) {
     if (dying)
         return; // un second signal pendant le nettoyage n'interrompt rien