@sylad/cadence 1.26.0 → 1.28.0

package/dist/corrections.js

@@ -274,11 +274,172 @@ export function readCache(file) {
 export function serializeCache(cache) {
     return JSON.stringify(Object.fromEntries([...cache].sort(([a], [b]) => a.localeCompare(b))), null, 2) + '\n';
 }
+/** Les sous-causes d'une passe « bug de code » (L447, R1), dans l'ordre où le rapport les liste. */
+export const SOUS_CAUSES = ['cas-limite', 'test-casse', 'contrat-mal-lu', 'appelant-oublie', 'affirmation-fausse', 'test-vide', 'autre'];
+const SOUS_LABELS = {
+    'cas-limite': 'cas limite',
+    'test-casse': 'test cassé',
+    'contrat-mal-lu': 'contrat mal lu',
+    'appelant-oublie': 'appelant oublié',
+    'affirmation-fausse': 'affirmation fausse',
+    'test-vide': 'test vide',
+    autre: 'autre',
+};
+/** Ce que chaque valeur veut dire, une ligne chacune : le prompt du modèle de sous-cause (R10). */
+const SOUS_DEFINITIONS = {
+    'cas-limite': 'un cas limite (entrée vide, absente, en double, d\'un autre type, refusée, forme réelle des données) que le code ne tient pas ou qu\'aucun test ne couvre',
+    'test-casse': 'un test existant que le changement casse',
+    'contrat-mal-lu': 'un contrat, une fiche ou un énoncé de lot mal lu : le code fait autre chose que ce qui est écrit',
+    'appelant-oublie': 'un appelant, un consommateur ou un autre site à changer a été oublié',
+    'affirmation-fausse': 'une documentation, un commentaire, un message ou un rapport affirme une chose fausse (chiffre, « jamais », « toujours », ancien comportement)',
+    'test-vide': 'un test qui ne peut pas échouer, ou un comportement ajouté sans test',
+    autre: 'tout bug de code qui n\'entre dans aucune des valeurs précédentes',
+};
+/** Les maillons de la chaîne où un mécanisme peut être posé (R2). */
+export const MAILLONS = ['brief implement', 'auto-vérification avant rendu', 'porte locale', 'fiche'];
+/** Le maillon dont relève chaque sous-cause (R2, hypothèse) ; `autre` n'en désigne aucun. */
+export const MAILLON_DE = {
+    'cas-limite': 'brief implement',
+    'test-vide': 'brief implement',
+    'affirmation-fausse': 'auto-vérification avant rendu',
+    'appelant-oublie': 'auto-vérification avant rendu',
+    'test-casse': 'porte locale',
+    'contrat-mal-lu': 'fiche',
+    autre: null,
+};
+/** Seuils de désignation du maillon dominant (R2, hypothèse) : passes sous-classées au moins, et part minimale du maillon en tête, en %. */
+export const MAILLON_MIN_PASSES = 10;
+export const MAILLON_MIN_PART = 40;
+/** Extrait une sous-cause connue d'une réponse (JSON `{sous}`) ; null sinon. */
+export function parseSousCause(text) {
+    try {
+        const s = JSON.parse(text)?.sous;
+        return typeof s === 'string' && SOUS_CAUSES.includes(s) ? s : null;
+    }
+    catch {
+        return null;
+    }
+}
+const SOUS_SYSTEM = `Tu sous-classes une passe de correction déjà classée « bug de code » : une session a écrit du code, une revue a formulé des constats, une session de correction les a traités. Réponds par UNE sous-cause, celle du constat le plus grave. Les valeurs :
+${SOUS_CAUSES.map((s) => `- ${s} : ${SOUS_DEFINITIONS[s]} ;`).join('\n')}`;
+/** Sous-classeur sur un modèle local servi par Ollama (comme `ollamaClassifier` : /api/chat, température 0, sortie contrainte par un schéma à sept valeurs). */
+export function ollamaSousClassifier(opts) {
+    const doFetch = opts.fetch ?? fetch;
+    return async (pass) => {
+        const findings = pass.findings.map((f, i) => `${i + 1}. ${f.slice(0, 1500)}`).join('\n');
+        const user = `Lot ${pass.project} ${pass.lot}.\nConstats de la revue :\n${findings}\n\nCommits de la correction :\n${pass.commits.join('\n') || '(aucun)'}`;
+        try {
+            const res = await doFetch(`${opts.url.replace(/\/$/, '')}/api/chat`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    model: opts.model,
+                    stream: false,
+                    options: { temperature: 0 },
+                    format: { type: 'object', properties: { sous: { type: 'string', enum: [...SOUS_CAUSES] }, raison: { type: 'string' } }, required: ['sous', 'raison'] },
+                    messages: [{ role: 'system', content: SOUS_SYSTEM }, { role: 'user', content: user }],
+                }),
+            });
+            if (!res.ok)
+                return null;
+            const body = (await res.json());
+            return parseSousCause(body.message?.content ?? '');
+        }
+        catch {
+            return null;
+        }
+    };
+}
+/** La cause retenue d'une passe à constats : la relecture à la main, sinon le modèle ; absente sans classement. */
+const retainedCause = (cache, p) => {
+    const c = cache.get(p.key);
+    return c ? (c.manual ?? c.cause) : undefined;
+};
+/** Les passes à sous-classer : à constats, de cause retenue bug-code (R1). */
+export const bugCodePasses = (passes, cache) => passes.filter((p) => p.findings.length > 0 && retainedCause(cache, p) === 'bug-code');
+/** Sous-classe les passes bug-code absentes du cache des sous-causes ; un échec n'y entre pas (R3). Rend le nombre d'entrées ajoutées. */
+export async function classifySous(passes, cache, sousCache, classify, model, progress, checkpoint) {
+    const todo = bugCodePasses(passes, cache).filter((p) => !sousCache.has(p.key));
+    let done = 0;
+    let added = 0;
+    for (const p of todo) {
+        const sous = await classify(p);
+        if (sous) {
+            sousCache.set(p.key, { sous, by: `ollama:${model}` });
+            added++;
+        }
+        done++;
+        progress?.(done, todo.length);
+        if (checkpoint && added > 0 && done % checkpoint.every === 0)
+            checkpoint.save();
+    }
+    return added;
+}
+export function readSousCache(file) {
+    let raw = null;
+    if (existsSync(file)) {
+        raw = readJson(file);
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+            throw new RafError(`${file} : JSON illisible (un objet clé → classement est attendu), corrigez ou supprimez le fichier`);
+    }
+    const known = (s) => typeof s === 'string' && SOUS_CAUSES.includes(s);
+    const entries = Object.entries((raw ?? {}));
+    for (const [key, c] of entries) {
+        if (!known(c?.sous))
+            throw new RafError(`${file} : sous-cause inconnue pour ${key} : ${String(c?.sous)}`);
+        if (c.manual !== undefined && !known(c.manual))
+            throw new RafError(`${file} : sous-cause inconnue pour ${key} : ${String(c.manual)}`);
+    }
+    return new Map(entries);
+}
+export function serializeSousCache(cache) {
+    return JSON.stringify(Object.fromEntries([...cache].sort(([a], [b]) => a.localeCompare(b))), null, 2) + '\n';
+}
+/** Désigne le maillon dominant : le plus lourd en passes, si au moins MAILLON_MIN_PASSES sont sous-classées et qu'il pèse MAILLON_MIN_PART % d'elles ; ni égalité en tête ni `autre` ne désignent (R2). */
+export function dominantMaillon(parSousCause) {
+    const total = SOUS_CAUSES.reduce((n, s) => n + parSousCause[s], 0);
+    if (total < MAILLON_MIN_PASSES)
+        return { nom: null, raison: `${total} passes sous-classées, il en faut au moins ${MAILLON_MIN_PASSES}` };
+    const poids = MAILLONS.map((m) => ({ m, passes: SOUS_CAUSES.filter((s) => MAILLON_DE[s] === m).reduce((n, s) => n + parSousCause[s], 0) })).sort((a, b) => b.passes - a.passes);
+    const [first, second] = poids;
+    if (first.passes > 0 && first.passes === second.passes)
+        return { nom: null, raison: `égalité en tête entre ${first.m} et ${second.m} (${first.passes} passes chacun)` };
+    if (first.passes * 100 < MAILLON_MIN_PART * total)
+        return { nom: null, raison: `aucun maillon à ${MAILLON_MIN_PART} % des passes sous-classées (le premier : ${first.passes} sur ${total})` };
+    return { nom: first.m, raison: `${first.passes} passes sur ${total} sous-classées (${Math.round((100 * first.passes) / total)} %)` };
+}
+/** Compte les sous-causes des passes bug-code données (R4 : manual prime ; R12 : une entrée du cache hors de ces passes n'est pas lue). Rend null sans passe bug-code (R9). */
+export function bugCodeOf(passes, sousCache) {
+    if (passes.length === 0)
+        return null;
+    const parSousCause = Object.fromEntries(SOUS_CAUSES.map((s) => [s, 0]));
+    let classees = 0;
+    for (const p of passes) {
+        const c = sousCache.get(p.key);
+        if (!c)
+            continue;
+        parSousCause[c.manual ?? c.sous]++;
+        classees++;
+    }
+    return { classees, sansSousCause: passes.length - classees, parSousCause, maillon: dominantMaillon(parSousCause) };
+}
+/** Les sous-causes dans l'ordre décroissant des passes (à égalité, l'ordre de SOUS_CAUSES), celles sans passe écartées. */
+export function sousCausesRanked(b) {
+    return SOUS_CAUSES.map((sous, i) => ({ sous, label: SOUS_LABELS[sous], passes: b.parSousCause[sous], i })).filter((x) => x.passes > 0).sort((a, b2) => b2.passes - a.passes || a.i - b2.i);
+}
+/** La section « Bug de code par sous-cause » de `cadence corrections` (A1) : sous-cause, passes, part des passes sous-classées, maillon. */
+export function renderSousCauses(b) {
+    const out = ['### Bug de code par sous-cause', '', `${b.classees} passes sous-classées sur ${b.classees + b.sansSousCause}${b.sansSousCause > 0 ? ` · sans sous-cause : ${b.sansSousCause} (à classer : cadence corrections --classify)` : ''}.`, ''];
+    if (b.classees > 0)
+        out.push('| Sous-cause | Passes | Part | Maillon |', '|---|---|---|---|', ...sousCausesRanked(b).map((r) => `| ${r.label} | ${r.passes} | ${pct(r.passes, b.classees)} | ${MAILLON_DE[r.sous] ?? 'aucun'} |`), '');
+    out.push(`Maillon dominant : ${b.maillon.nom ?? `aucun (${b.maillon.raison})`}${b.maillon.nom ? ` — ${b.maillon.raison}` : ''}.`, '');
+    return out;
+}
 const pct = (a, b) => (b === 0 ? '—' : `${Math.round((100 * a) / b)} %`);
 /** Les causes qu'une meilleure spécification évite (critère de réussite de l'étape spec). */
 const SPEC_CAUSES = ['spec-floue', 'regle-inventee', 'test-manquant'];
 const row = (name, t) => `| ${name} | ${t.lots} | ${t.atLeast1} (${pct(t.atLeast1, t.lots)}) | ${t.atLeast2} (${pct(t.atLeast2, t.lots)}) | ${t.passes} |`;
-export function renderReport(m) {
+export function renderReport(m, bugCode) {
     const all = [...CAUSES, 'sans-constat', 'non-classe'];
     const used = all.filter((c) => (c !== 'non-classe' && c !== 'sans-constat') || m.byCause[c] > 0);
     const projects = Object.keys(m.byProject).sort();
@@ -299,5 +460,7 @@ export function renderReport(m) {
     out.push('');
     if (m.agreement.reviewed > 0)
         out.push(`Échantillon relu à la main : ${m.agreement.reviewed} passes, le modèle local est d'accord avec la relecture sur ${m.agreement.agree} (${pct(m.agreement.agree, m.agreement.reviewed)}) ; la cause relue prime dans les tableaux.`, '');
+    if (bugCode)
+        out.push(...renderSousCauses(bugCode));
     return out.join('\n');
 }

package/dist/lead.js

@@ -16,11 +16,11 @@ import { cadenceHome } from './orchestrate/registry.js';
 import { staleNotes, staleText } from './stale-notes.js';
 import { noTestGate, noTestText } from './orchestrate/no-test.js';
 import { KEPT_TITLE, keptLine, keptTrees } from './orchestrate/worktree.js';
-/** Clé `lead.ux` du cadence.yaml du dossier parent (L197) : qui pose le verdict UX (`raf ux`) d'un lot visible. `human` (défaut) : l'humain ; `lead` : le lead, l'humain n'étant consulté qu'en cas de doute. */
-export function readLeadUx(parent) {
+/** Le bloc `lead:` du cadence.yaml du dossier parent (absent = `undefined`) ; un `lead` qui n'est pas une table est refusé en nommant `key`. */
+function readLeadBlock(parent, key, expected) {
     const file = join(parent, 'cadence.yaml');
     if (!existsSync(file))
-        return 'human';
+        return undefined;
     let raw;
     try {
         raw = parse(readFileSync(file, 'utf8'));
@@ -30,16 +30,33 @@ export function readLeadUx(parent) {
     }
     const l = raw?.lead;
     if (l == null)
-        return 'human';
-    const ux = l.ux;
+        return undefined;
     if (typeof l !== 'object' || Array.isArray(l))
-        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+        throw new RafError(`${file} : ${key} doit être ${expected}`);
+    return { file, block: l };
+}
+/** Clé `lead.ux` du cadence.yaml du dossier parent (L197) : qui pose le verdict UX (`raf ux`) d'un lot visible. `human` (défaut) : l'humain ; `lead` : le lead, l'humain n'étant consulté qu'en cas de doute. */
+export function readLeadUx(parent) {
+    const found = readLeadBlock(parent, 'lead.ux', '« lead » ou « human »');
+    const ux = found?.block.ux;
     if (ux == null)
         return 'human';
     if (ux !== 'lead' && ux !== 'human')
-        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+        throw new RafError(`${found.file} : lead.ux doit être « lead » ou « human »`);
     return ux;
 }
+/** Seuil de contexte du lead quand `lead.contextThreshold` n'est pas posé (L437). */
+export const CONTEXT_THRESHOLD_DEFAULT = 150_000;
+/** Clé `lead.contextThreshold` du cadence.yaml du dossier (L437) : le nombre de tokens de contexte à partir duquel le lead ne lance plus de vague. En tokens et non en % : 60 % d'une fenêtre de 1M valait 600k. Un entier ≥ 1, sinon refus. */
+export function readLeadContextThreshold(parent) {
+    const found = readLeadBlock(parent, 'lead.contextThreshold', 'un entier ≥ 1 (tokens)');
+    const t = found?.block.contextThreshold;
+    if (t == null)
+        return CONTEXT_THRESHOLD_DEFAULT;
+    if (typeof t !== 'number' || !Number.isInteger(t) || t < 1)
+        throw new RafError(`${found.file} : lead.contextThreshold doit être un entier ≥ 1 (tokens), pas ${JSON.stringify(t)}`);
+    return t;
+}
 /** Clé `depth:` du cadence.yaml du dossier parent (L201, issue #8), à côté de `priority:` : combien de niveaux `lead tour` parcourt (1 : sous-dossiers directs, le défaut). */
 export function readDepth(parent) {
     const file = join(parent, 'cadence.yaml');

package/dist/orchestrate/cycle.js

@@ -6,7 +6,7 @@ import { delimiter, dirname, isAbsolute, join, posix, relative, resolve } from '
 import { copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { coveredTasks, lotCommits, lotWork } from '../audit.js';
-import { readDocsConfig, readPlanConfig } from '../config.js';
+import { planLoader, readDocsConfig, readPlanConfig } from '../config.js';
 import { PLAN_ACTIONS, leadAnswerMessage, planCommitMessage } from '../plan-commit.js';
 import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
@@ -2318,15 +2318,42 @@ async function work(c, kind) {
 const noCommitNote = (l) => (l.warnings.some((w) => w.startsWith('passe des mineurs sans commit')) ? ' sans commit' : '');
 /** Revue de code qui clôt le cycle : complète, ou courte une fois la passe des mineurs jouée. */
 const codeReview = (l) => (l.minorPass ? 'review-small' : 'review');
+/** Note d'un lot que sa session a rendu `visible` après le lancement de la vague (L454) : son verdict UX n'existe pas encore, le lead le sait. */
+const VISIBLE_ADDED = 'visible ajouté en cours de vague, étape UX à jouer';
+/**
+ * Relit `visible` dans le plan du worktree après une session d'écriture (L454) : un lot que sa session a rendu visible (warhammer L37 et L43,
+ * 30-10) est lancé non visible, et sortait « prêt » sans étape UX. Il le devient dans l'état du lot, donc l'UX est jouée (`uxAfterReview`, ou la
+ * revue courte d'un petit lot) ; sans application déclarée, il est rendu avec la note. Un plan illisible, ou un lot qui n'est plus visible
+ * dans le plan, laisse l'état tel quel (retirer `visible` en cours de vague n'est pas traité).
+ */
+function addedVisible(c) {
+    const l = c.lot;
+    if (l.visible)
+        return;
+    let now;
+    try {
+        now = (wd(c) === l.repo ? c.loadPlan() : planLoader(wd(c))()).lot(l.lot).visible;
+    }
+    catch {
+        return;
+    }
+    if (!now)
+        return;
+    l.visible = true;
+    if (!c.config.ux)
+        l.uxNote = `${VISIBLE_ADDED} (aucune application déclarée : cadence.yaml orchestrate.ux)`;
+    c.wave.log(`${lotKey(l.project, l.lot)} · ${VISIBLE_ADDED}`);
+}
 /**
  * Première étape après un travail d'écriture (L221) : la revue de code, jamais l'UX. La revue UX d'un lot visible est jouée une seule fois,
  * après la dernière revue de code conforme (`uxAfterReview`), sur le code qui sera livré.
  */
 function firstReview(c) {
     const l = c.lot;
+    addedVisible(c);
     if (l.small)
         return l.visible || l.minorPass ? 'review-small' : 'review'; // passe unique code + ergonomie ; sans écran, une revue de code
-    if (l.visible && !c.config.ux)
+    if (l.visible && !c.config.ux && !l.uxNote?.startsWith(VISIBLE_ADDED))
         l.uxNote = 'UX à faire par le lead (aucune application déclarée : cadence.yaml orchestrate.ux)';
     return codeReview(l);
 }

package/dist/perf.js

@@ -1,6 +1,6 @@
 import { join, relative, sep } from 'node:path';
 import { planLoader } from './config.js';
-import { CAUSES, isReview as isReviewKind } from './corrections.js';
+import { bugCodeOf, CAUSES, isReview as isReviewKind, sousCausesRanked } from './corrections.js';
 import { addDays, diffDays, isDay, toDay } from './dates.js';
 import { gitCommonDir } from './git.js';
 import { findProjects } from './lead.js';
@@ -129,8 +129,9 @@ function indicator(current, previous, lots, windows, dir, twin, nullNote = null,
 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) {
+function causeWindow(passes, w, cache, sousCache) {
     const counts = new Map();
+    const bugCodePasses = [];
     let unclassified = 0;
     let withoutFindings = 0;
     const byReview = {};
@@ -150,14 +151,17 @@ function causeWindow(passes, w, cache) {
         }
         const cause = c.manual ?? c.cause;
         counts.set(cause, (counts.get(cause) ?? 0) + 1);
+        if (cause === 'bug-code')
+            bugCodePasses.push(pass);
     }
+    const bugCode = sousCache ? bugCodeOf(bugCodePasses, sousCache) : null;
     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 };
+    return { top, classified, unclassified, withoutFindings, unclassifiedShare: withFindings === 0 ? null : unclassified / withFindings, byReview, ...(bugCode ? { bugCode } : {}) };
 }
 /** 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);
@@ -222,7 +226,7 @@ export function computePerf(input) {
     };
     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) };
+    const causes = { current: causeWindow(passDays, windows.current, cache, input.sousCache), previous: causeWindow(passDays, windows.previous, cache) };
     // Interventions du lead (R10, R15)
     const lastOf = new Map();
     for (const d of all) {
@@ -630,6 +634,14 @@ function redBreakdownLines(b) {
         `  livraisons rouges par projet : ${byProject.map(([name, n, cl]) => `${name} ${n} (${cl.map(([k, c]) => `${k} ${c}`).join(', ')})`).join(' · ')}`,
     ];
 }
+/** La ligne des sous-causes bug-code sous « causes dominantes » (L447, R6/R7) : sans sous-cause classée, elle dit comment les classer. */
+function bugCodeLine(b) {
+    if (b.classees === 0)
+        return `  bug de code (${b.sansSousCause} passes) : sous-causes n/d · à classer : cadence corrections --classify`;
+    const ranked = sousCausesRanked(b).map((r, i) => `${i + 1}. ${r.label} ${r.passes}`).join(' · ');
+    const maillon = b.maillon.nom ?? `aucun (${b.maillon.raison})`;
+    return `  bug de code (${b.classees} passes sous-classées sur ${b.classees + b.sansSousCause}) : ${ranked}${b.sansSousCause > 0 ? ` · sans sous-cause : ${b.sansSousCause}` : ''} · maillon dominant : ${maillon}`;
+}
 /** 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);
@@ -669,6 +681,8 @@ export function renderPerf(r) {
     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' : ''}`);
+    if (c.bugCode)
+        out.push(bugCodeLine(c.bugCode));
     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(' · ')}`);

package/dist/priority.js

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join, relative, sep } from 'node:path';
+import { Document, isScalar, isSeq, parseDocument } from 'yaml';
+import { findProjects, readDepth } from './lead.js';
+import { priorityRank, readPriority } from './orchestrate/continue.js';
+import { RafError } from './plan.js';
+import { setKey } from './config-set.js';
+/**
+ * `cadence lead priority <projet> --before|--after <projet>` (L449) : place `project` juste avant ou après `target` dans l'ordre des projets du dossier,
+ * en réécrivant la liste `priority:` de son cadence.yaml (créé s'il manque). Les projets sont nommés comme `lead tour` les nomme.
+ * La liste écrite nomme tous les projets du dossier, dans l'ordre affiché : un nom qui en couvrait plusieurs par préfixe (`maritime` pour `maritime-atlas`) devient explicite
+ * (le commentaire de sa ligne passe sur le premier projet qu'il couvrait), et un nom qui ne couvre aucun projet reste en fin de liste. Le reste du fichier, commentaires compris, est gardé (setKey). Un fichier illisible, ou une clé qui n'est pas une liste, est refusé sans rien écrire.
+ */
+export function movePriority(parent, project, place, target, depth) {
+    const file = join(parent, 'cadence.yaml');
+    const declared = readPriority(parent); // refuse un yaml illisible ou une clé qui n'est pas une liste de noms
+    const projects = findProjects(parent, depth ?? readDepth(parent)).map((dir) => ({ key: basename(dir), name: relative(parent, dir).split(sep).join('/') }));
+    const byName = new Map(projects.map((p) => [p.name, p]));
+    for (const n of [project, target])
+        if (!byName.has(n))
+            throw new RafError(`projet inconnu : ${n} (projets de ${parent} : ${projects.map((p) => p.name).join(', ') || 'aucun'})`);
+    if (project === target)
+        throw new RafError(`${project} : le même projet des deux côtés`);
+    const keys = projects.map((p) => p.key);
+    const twice = keys.find((k, i) => keys.indexOf(k) !== i);
+    if (twice)
+        throw new RafError(`deux projets s'appellent ${twice} : la liste priority: les nomme par leur dossier et ne peut pas les distinguer`);
+    const ranked = [...projects].sort((a, b) => priorityRank(a.key, declared) - priorityRank(b.key, declared) || a.key.localeCompare(b.key) || a.name.localeCompare(b.name));
+    const without = ranked.filter((p) => p.name !== project);
+    const at = without.findIndex((p) => p.name === target) + (place === 'after' ? 1 : 0);
+    const moved = [...without.slice(0, at), byName.get(project), ...without.slice(at)];
+    const order = moved.map((p) => p.name);
+    if (order.every((n, i) => n === ranked[i].name))
+        return { order, changed: false };
+    const unmatched = declared.filter((n) => !keys.some((k) => k === n || k.startsWith(`${n}-`)));
+    const list = [...moved.map((p) => p.key), ...unmatched];
+    // la liste écrite doit restituer l'ordre voulu : un nom qui en préfixe un autre (`shop` et `shop-web`) les rangerait ensemble
+    const back = [...projects].sort((a, b) => priorityRank(a.key, list) - priorityRank(b.key, list) || a.key.localeCompare(b.key) || a.name.localeCompare(b.name)).map((p) => p.name);
+    if (back.some((n, i) => n !== order[i])) {
+        const clash = keys.find((k) => keys.some((o) => o !== k && o.startsWith(`${k}-`)));
+        throw new RafError(`${project} ne peut pas être placé ${place === 'before' ? 'avant' : 'après'} ${target} : la liste priority: nomme un projet par son dossier, et ${clash ?? 'un nom'} est le début du nom d'un autre projet (« ${clash ?? 'x'}- »), qui le suit toujours — rien n'est écrit`);
+    }
+    const text = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    const old = parseDocument(text).get('priority', true);
+    // les noms déjà dans la liste gardent leur nœud, donc le commentaire de leur ligne ; un nom qui couvrait des projets par préfixe (`maritime`)
+    // donne le sien au premier projet qu'il couvre, dans l'ordre écrit, sous le nom explicite ; les autres sont des nœuds neufs
+    const kept = new Map();
+    const scalars = isSeq(old) ? old.items.filter((item) => isScalar(item) && typeof item.value === 'string') : [];
+    for (const item of scalars)
+        if (!kept.has(item.value.trim()))
+            kept.set(item.value.trim(), item); // deux fois le même nom : le premier nœud compte, comme pour le rang
+    for (const item of scalars) {
+        const n = item.value.trim();
+        if (kept.get(n) !== item || keys.includes(n))
+            continue; // un nom qui est déjà un projet garde son nœud et n'en donne pas une copie à `nom-…`
+        const covered = list.find((k) => !kept.has(k) && k.startsWith(`${n}-`));
+        if (covered === undefined)
+            continue;
+        const explicit = item.clone();
+        explicit.value = covered;
+        kept.set(covered, explicit);
+    }
+    const value = new Document(list);
+    if (isSeq(value.contents)) {
+        value.contents.items = list.map((n) => kept.get(n) ?? value.createNode(n));
+        value.contents.flow = isSeq(old) && old.flow === true; // la liste en ligne reste en ligne
+        // la séquence porte le commentaire de la ligne de la clé et celui écrit avant son premier nom : la nouvelle les reprend
+        if (isSeq(old)) {
+            value.contents.commentBefore = old.commentBefore;
+            value.contents.comment = old.comment;
+        }
+    }
+    const next = setKey(text, 'priority', value);
+    if (next !== null)
+        writeFileSync(file, next);
+    return { order, changed: next !== null };
+}

package/dist/verify-gate.js

@@ -127,7 +127,8 @@ async function playGate(ctx) {
     }
     let recorded = { reason: 'aucune porte de vague enregistrée pour ce sha' };
     try {
-        recorded = recordedGate(ctx.launchDirs ?? [], repo, sha, steps, ctx.planFile);
+        // Un test qui lit le plan (orchestrate.gate.readsPlan, L450) voit un autre contenu après un `raf done` : les commits de plan seuls ne sont pas traversés.
+        recorded = recordedGate(ctx.launchDirs ?? [], repo, sha, steps, config.gate ? undefined : ctx.planFile);
     }
     catch (e) {
         recorded = { reason: `état des vagues illisible (${gitFailure(e)})` };
@@ -143,7 +144,7 @@ async function playGate(ctx) {
         out(`verify --gate ${short} : vert`);
         return 0;
     }
-    const replayReason = `verdict rejoué : ${recorded.reason}`;
+    const replayReason = `verdict rejoué : ${recorded.reason}${config.gate && ctx.planFile ? ' (orchestrate.gate.readsPlan : un test lit le plan, les commits de plan seuls ne reprennent pas le verdict d\'un sha dessous)' : ''}`;
     const obstacle = mainTreeObstacle(repo, sha);
     const mode = ctx.verify?.inPlace;
     if (mode === true && obstacle) {

package/docs/cadence-hud.md

@@ -81,6 +81,8 @@ A project shows at most 5 lots (L411), the first ones in the order above (so tho
 
 **Reordering (L402).** Drag a lot onto another lot of the same project and of the same display group (or a sub-task onto another sub-task of its lot, same group): press on the row, move with the button held, release. While you drag, the row you started from shows `●` and the row under the pointer shows where it will land, `⇡` (before it) or `⇣` (after it), or a red `⊘` when it belongs to another parent or to another display group (L410) and the drop will be refused. The keyboard does the same wherever the panel is drawn by a `Client` region (terminal and desktop app): click a row (or press ↑ / ↓ once the panel has the focus), then **Alt**+↑ / **Alt**+↓ moves the selected lot before its previous sibling / after its next one. Only the rows the panel shows take part (L411): a lot hidden behind `+ N lots`, or the sub-lots of a closed lot, are not rows, so they are never a target — Alt+↓ on the fifth lot, the last row before the `+ N lots` button, moves nothing, like Alt+↓ on the last row of a project; open the rest (or the lot) first, and the drop runs `raf move` as usual. The `+ N lots` / `moins` button sits outside the `Client` region, after the project's rows. The drop runs `raf move <id> --before|--after <id>` ([raf move](raf.md)) in the project folder, then the panel reads the plans again and says, under the title, `✔ L13 placé avant L10 — le plan est modifié, à commiter (raf move ne commite pas)`: the panel never commits, the plan file is yours to commit. Everything is relative to what the panel shows, in the L410 order, not to the order of the plan: the row you drop on, and the "previous" and "next" sibling of Alt+↑ / Alt+↓, are the ones displayed around the lot, and `raf move` is given that lot as its target. **A lot is reordered only inside its display group** (L410: in progress, free, blocked): dropping a lot on a lot of another group is refused, `raf` is not called and nothing moves. While you drag, the row under the pointer shows the red `⊘` (as for another parent), and on release the panel says why, by group: `✖ L411 est en cours : un lot libre se range parmi les libres` (the words: `en cours` / `libre` / `bloqué`; the lot is named by what it is, `un lot` or `une sous-tâche`). A parent with an in-progress sub-lot is shown with the lots in progress, so it counts as one of them. Alt+↑ / Alt+↓ toward a displayed neighbour of another group gets the same refusal; at the edge of the displayed rows (or before the `+ N lots` button) nothing happens. (Case that led to this: plan L402 L403 L407 L411, L403 free dropped on L411 in progress moved L403 below L407 and hid it behind `+ 11 lots`.) Inside a group the screen follows the plan, so a gesture that goes through always shows: the lot moves where you dropped it. A drop that would leave the order of the group as it is — the lot is already right before (or after) the target among the lots of its group — runs nothing and says `• L10 est déjà avant L13 dans le plan : rien à déplacer`; no gesture of the panel leads there (the screen follows the plan inside a group), the check guards a request the drawing did not make. The same holds between the sub-tasks of a lot. The `déjà` check is made on the table the panel last read: from a successful `raf move` until the end of a re-reading started *after* it (`cadence lead tour` takes several seconds; a reading already in flight read the old plan, so another one follows it) the table is held stale: no `déjà` short-circuit, `raf move` runs and decides (the group refusal stays: it depends on the states, not on the order). A refusal is written under the title with its reason and nothing moves: a wave holds the repository (`move : orchestration en cours …`), a plan kept by another tool (`plan en lecture seule : … — le modifier avec l'outil du projet`, the message does not name that tool's command: `raf` does not know it, so look in the project), an archived lot, different parents (`L402 et L401/2 n'ont pas le même parent …`) or different display groups (`L411 est en cours : …`), the last two checked before `raf` runs; `raf` missing from the `PATH` says so. On a surface with no `Client` region (mobile, editor) the panel stays read-only (`lecture seule` in its title).
 
+**Reordering the projects (L449).** Above the tree, `ordre des projets (priority:) — glisser, ou Alt+↑ / Alt+↓` and one row per project (`cadence  7 lots non clos`; `illisible` for a project the tour could not read), in the order of `priority:`. It is drawn only where the lots can be reordered (a `Client` region: terminal and desktop app), when the folder has two projects or more, and when the panel is tall enough to keep a row for each project and one lot under it (otherwise the tree has the room). Drag a project onto another (`●` the row you hold, `⇡` / `⇣` where it will land) or click it and press **Alt**+↑ / **Alt**+↓ (↑ / ↓ alone select): the drop runs `cadence lead priority <project> --before|--after <project> <folder>` ([lead priority](lead.md#lead-priority)), which rewrites the `priority:` list of the `cadence.yaml` of the parent folder, comments kept; the panel then reads the plans again and says under the title `✔ ol placé avant cadence — priority: du cadence.yaml est modifiée, à commiter`. This order is the one of the tour, of `cadence orchestrate --continue` and of the panel itself. The panel never commits. A refusal is written under the title with its reason (`✖ /dev/cadence.yaml illisible : …`, a `priority:` that is not a list) and nothing is written; `cadence` missing from the `PATH` says so; a project already at that place says `• … est déjà avant …`. The error row `cadence.yaml` that the tour adds for an unreadable file is not a project and cannot be moved or targeted.
+
 States: `▶ en cours` (doing), `○ libre` (todo, no open `after:`), `⊘ bloqué` (todo, an `after:` is still open); a lot in a wave takes the wave's state and words, as the band writes them (`… en attente`, `⟳ implémente`, `⟳ relit`, `⟳ corrige`, `? QUESTION`, `✔ prêt`, `↩ rendu`, `✖ échec`, `⏸ suspendu`). In a native plan the sub-tasks of an open lot (`L401/2`) are its sub-lots (`├`/`└`); they only read `▶ en cours` or `○ à faire`, and are not counted in the project's `N lots non clos`. In a plan kept by another tool the sub-lots come from `parent:`. An `after:` id that is closed or unknown is struck through and blocks nothing. A project the tour could not read shows `illisible : <error>`; the others stay.
 
 Before the first reading the panel says `Lecture des plans…`; if `cadence lead tour` does not answer it says `Lots illisibles : cadence lead tour n'a pas répondu. Nouvelle lecture dans une minute.` (a failed re-reading keeps the last table); a `cadence` too old to give the `lots` field says `Lots indisponibles : cadence est trop ancien, mettez-le à jour.`; with no open lot, `Aucun lot non clos dans les projets de ce dossier.`. A tree taller than the panel ends with `… +N lots de plus`. Under 60 columns the `after:` list moves to its own line and the title is cut with `…`, never the id or the state.

package/docs/corrections.md

@@ -2,7 +2,7 @@
 
 # corrections
 
-`cadence corrections [folder] [--classify [--model m]] [--cache file] [--sample n] [--until date] [--since date] [--json]` measures how often a wave
+`cadence corrections [folder] [--classify [--model m]] [--cache file] [--cache-sous-causes file] [--sample n] [--until date] [--since date] [--json]` measures how often a wave
 has to correct itself. From the folder a wave was launched from (default: the current one) it reads the journals
 `<folder>/.cadence/runs/<wave>/<project>--<lot>.json` of **every project** and prints:
 
@@ -23,3 +23,13 @@ beside a pass in the cache file (one of the seven causes, else the command refus
 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 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).
 The reading of the « bug de code » passes of the 23–29-10 window, the block added to the `implement` brief against them (L428) and the protocol to measure its effect on two `cadence perf` windows are in [docs/mesures/bug-code-2026-10-29.md](mesures/bug-code-2026-10-29.md).
+
+## Sub-causes of the « bug de code » passes (L447)
+
+The cause `bug-code` alone is 69 % of the classified passes (74 of 107, 24→30-10) and does not say *which* bug. A pass whose retained cause (`manual`, else the model's) is `bug-code` and that has review findings is therefore also given **one sub-cause** from a closed list of seven: `cas-limite` (edge case not tested or not held), `test-casse` (an existing test broken by the change), `contrat-mal-lu` (contract, sheet or lot statement misread), `appelant-oublie` (a caller or another site to change was forgotten), `affirmation-fausse` (a document, comment or report that is false), `test-vide` (a test that cannot fail, or a behaviour with no test) and `autre`. A pass of another cause, or with no finding, is never sent to the model for this.
+
+- `--classify` first classifies the causes as before, then asks the same local model for the sub-cause of each `bug-code` pass that has none (temperature 0, output constrained to the seven values, findings cut to 1500 characters). The answers are cached in `<folder>/.cadence/corrections-sous-causes.json` (or `--cache-sous-causes file`): an object `pass key → { sous, by, manual? }`. A failed answer (Ollama down, non-2xx status, value outside the list) leaves the pass out of the cache, counted « sans sous-cause » and taken again by the next `--classify`; `corrections.json` is not touched. A `manual` field (one of the seven values) beats the model in every table. An entry whose key is not a `bug-code` pass of the window (re-classified, cause changed by hand, key absent from the window) is ignored: neither counted, erased nor refused.
+- An unreadable file (not a JSON object) or an unknown sub-cause makes the command refuse with exit code 1, naming the file (and the key), without printing or rewriting anything; an absent file reads as empty. Without `--classify` the file is read, never written.
+- The report gains the section « Bug de code par sous-cause » (sub-cause, passes, share of the sub-classified passes, link) and a line « Maillon dominant ». `--json` gains the key `bugCode` — `{ classees, sansSousCause, parSousCause, maillon: { nom, raison } }`. With no `bug-code` pass in the window nothing is added: the text report and the JSON keys are those of before.
+
+**The link.** Each sub-cause belongs to one link of the chain: `cas-limite` and `test-vide` to the `implement` brief, `affirmation-fausse` and `appelant-oublie` to the self-check before handing back, `test-casse` to the local gate, `contrat-mal-lu` to the sheet, `autre` to none. The **dominant link** is the one whose sub-causes weigh the most passes; it is named only when at least 10 passes are sub-classified and its passes are at least 40 % of them. With fewer, with a link under 40 %, or with two links tied at the top, the line says « aucun » and why. The two thresholds and the table are constants of `src/corrections.ts` (hypotheses: the link is recomputed at each read, nothing stores it). `cadence perf` prints the same count under « causes dominantes » for the current 7-day window — `bug de code (N passes sous-classées sur M) : 1. cas limite … · maillon dominant : …` — reading the cache without writing it: an absent file gives `sous-causes n/d · à classer : cadence corrections --classify`, an unreadable one a warning on stderr (`perf : <file> illisible, sous-causes n/d`) and no line, exit code 0 in both cases (`corrections.causes.current.bugCode` in `--json`). Over 7 days the 10-pass threshold is often not reached: « aucun » is then the usual answer, not an error.

package/docs/deliver.md

@@ -308,6 +308,8 @@ verify --gate 6b0d9aa : vert
 
 Nothing runs: no worktree, no copy of the dependencies, exit 0. Otherwise the gate is **replayed** exactly as described above, and the line right after the one telling where it ran gives the reason: `verdict rejoué : aucune porte de vague enregistrée pour ce sha` (no wave state, another sha such as the head after an integration that rebased, a commit that also touches another file (a plan-only commit is crossed, L444), another repository), `arbre différent de celui contrôlé`, `arbre non enregistré` (state written before L397), or `l'enregistrement (vague …, lot …) ne couvre pas en vert test (…)` (a red, missing or changed step). A recorded red is never repeated as a verdict: it is replayed. The verdict read is the one of the wave's gate (with `orchestrate.testReplay` applied), not a new run: to force a replay, ask for a sha the wave did not check.
 
+**A test that reads the plan (L450).** Crossing the plan-only commits assumes that no test reads the plan. On 30-10 avatar-pandora's `plan-page.e2e`, which reads `.cadence/raf.yaml`, went red after the `raf done` of L8 while the head gate, taking over the wave's verdict under that commit, saw nothing. A project whose gate has such a test declares it: `orchestrate.gate: { readsPlan: true }` (or `readsPlan: [e2e/plan-page.e2e.ts]`, the paths of the tests that read it; a non-empty list of relative paths without `..`, anything else is refused when `cadence.yaml` is read). The verdict of a sha *below* plan-only commits is then never taken over: the gate is replayed at the sha asked, and the reason line ends with `(orchestrate.gate.readsPlan : un test lit le plan, …)`. A verdict recorded at the very sha asked is still taken over. Absent or `false`: unchanged. The pre-push hook keeps crossing plan-only commits (its rule, L432, is not changed here).
+
 ```yaml
 # cadence.yaml
 verify:

package/docs/fonctionnement-lead-dark.svg

@@ -50,11 +50,11 @@
 <text x="920" y="171.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#e6edf3">Delivers</text>
 <text x="920" y="186.5" text-anchor="middle" font-size="11.5" fill="#8b949e">push + deliver</text>
 <rect x="1000" y="146" width="128" height="58" rx="6" fill="#0d1117" stroke="#8b949e" stroke-width="1.5"/>
-<text x="1064" y="171.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#e6edf3">&lt; 60 % ?</text>
+<text x="1064" y="171.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#e6edf3">&lt; limit ?</text>
 <text x="1064" y="186.5" text-anchor="middle" font-size="11.5" font-family="ui-monospace,SFMono-Regular,Menlo,monospace" fill="#8b949e">session context</text>
 <rect x="1144" y="146" width="128" height="58" rx="6" fill="#0d1117" stroke="#8b949e" stroke-width="1.5"/>
 <text x="1208" y="171.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#e6edf3">Close</text>
-<text x="1208" y="186.5" text-anchor="middle" font-size="11.5" fill="#8b949e">if ≥ 60 %</text>
+<text x="1208" y="186.5" text-anchor="middle" font-size="11.5" fill="#8b949e">if limit reached</text>
 <rect x="280" y="246" width="128" height="58" rx="6" fill="#0d1117" stroke="#8b949e" stroke-width="1.5"/>
 <text x="344" y="271.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#e6edf3">Lots</text>
 <text x="344" y="286.5" text-anchor="middle" font-size="11.5" fill="#8b949e">figure 2, per lot</text>

package/docs/fonctionnement-lead-light.svg

@@ -50,11 +50,11 @@
 <text x="920" y="171.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#1f2328">Delivers</text>
 <text x="920" y="186.5" text-anchor="middle" font-size="11.5" fill="#57606a">push + deliver</text>
 <rect x="1000" y="146" width="128" height="58" rx="6" fill="#ffffff" stroke="#57606a" stroke-width="1.5"/>
-<text x="1064" y="171.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#1f2328">&lt; 60 % ?</text>
+<text x="1064" y="171.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#1f2328">&lt; limit ?</text>
 <text x="1064" y="186.5" text-anchor="middle" font-size="11.5" font-family="ui-monospace,SFMono-Regular,Menlo,monospace" fill="#57606a">session context</text>
 <rect x="1144" y="146" width="128" height="58" rx="6" fill="#ffffff" stroke="#57606a" stroke-width="1.5"/>
 <text x="1208" y="171.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#1f2328">Close</text>
-<text x="1208" y="186.5" text-anchor="middle" font-size="11.5" fill="#57606a">if ≥ 60 %</text>
+<text x="1208" y="186.5" text-anchor="middle" font-size="11.5" fill="#57606a">if limit reached</text>
 <rect x="280" y="246" width="128" height="58" rx="6" fill="#ffffff" stroke="#57606a" stroke-width="1.5"/>
 <text x="344" y="271.5" text-anchor="middle" font-weight="600" font-size="13.5" fill="#1f2328">Lots</text>
 <text x="344" y="286.5" text-anchor="middle" font-size="11.5" fill="#57606a">figure 2, per lot</text>

package/docs/lead-workflow-dark.svg

@@ -130,7 +130,7 @@
 <text x="1140" y="703.5" text-anchor="middle">findings → the human</text>
 </g>
 <g id="ctx"><rect x="1241" y="337" width="158" height="66" rx="8" fill="#0c2d6b" stroke="#58a6ff" stroke-width="1.5"/>
-<text x="1320" y="358.5" text-anchor="middle" font-weight="600">Context under 60 %?</text>
+<text x="1320" y="358.5" text-anchor="middle" font-weight="600">Context under limit?</text>
 <text x="1320" y="374.5" text-anchor="middle" font-family="ui-monospace,SFMono-Regular,Menlo,monospace" font-size="11.5">session context</text>
 <text x="1320" y="390.5" text-anchor="middle">error = at threshold</text>
 </g>
@@ -175,7 +175,7 @@
 <polyline points="1320,403 1320,650" fill="none" stroke="#8b949e" stroke-width="1.6" marker-end="url(#arr)"/>
 <text x="1326" y="440" text-anchor="start" font-size="11" fill="#8b949e" class="lbl">yes: chain</text>
 <polyline points="1399,370 1421,370" fill="none" stroke="#8b949e" stroke-width="1.6" marker-end="url(#arr)"/>
-<text x="1410" y="329" text-anchor="middle" font-size="11" fill="#8b949e" class="lbl">≥ 60 %: close</text>
+<text x="1410" y="329" text-anchor="middle" font-size="11" fill="#8b949e" class="lbl">limit reached: close</text>
 <polyline points="1500,337 1500,203" fill="none" stroke="#8b949e" stroke-width="1.6" marker-end="url(#arr)"/>
 <polyline points="1320,716 1320,746 420,746 420,716" fill="none" stroke="#8b949e" stroke-width="1.6" marker-end="url(#arr)"/>
 <text x="870" y="740" text-anchor="middle" font-size="11" fill="#8b949e" class="lbl">next wave: back to step 2, the limits still apply</text>

package/docs/lead-workflow-light.svg

@@ -130,7 +130,7 @@
 <text x="1140" y="703.5" text-anchor="middle">findings → the human</text>
 </g>
 <g id="ctx"><rect x="1241" y="337" width="158" height="66" rx="8" fill="#ddf4ff" stroke="#0969da" stroke-width="1.5"/>
-<text x="1320" y="358.5" text-anchor="middle" font-weight="600">Context under 60 %?</text>
+<text x="1320" y="358.5" text-anchor="middle" font-weight="600">Context under limit?</text>
 <text x="1320" y="374.5" text-anchor="middle" font-family="ui-monospace,SFMono-Regular,Menlo,monospace" font-size="11.5">session context</text>
 <text x="1320" y="390.5" text-anchor="middle">error = at threshold</text>
 </g>
@@ -175,7 +175,7 @@
 <polyline points="1320,403 1320,650" fill="none" stroke="#57606a" stroke-width="1.6" marker-end="url(#arr)"/>
 <text x="1326" y="440" text-anchor="start" font-size="11" fill="#57606a" class="lbl">yes: chain</text>
 <polyline points="1399,370 1421,370" fill="none" stroke="#57606a" stroke-width="1.6" marker-end="url(#arr)"/>
-<text x="1410" y="329" text-anchor="middle" font-size="11" fill="#57606a" class="lbl">≥ 60 %: close</text>
+<text x="1410" y="329" text-anchor="middle" font-size="11" fill="#57606a" class="lbl">limit reached: close</text>
 <polyline points="1500,337 1500,203" fill="none" stroke="#57606a" stroke-width="1.6" marker-end="url(#arr)"/>
 <polyline points="1320,716 1320,746 420,746 420,716" fill="none" stroke="#57606a" stroke-width="1.6" marker-end="url(#arr)"/>
 <text x="870" y="740" text-anchor="middle" font-size="11" fill="#57606a" class="lbl">next wave: back to step 2, the limits still apply</text>