@sylad/cadence 0.28.0 → 1.1.0

package/dist/audit.js

@@ -4,7 +4,8 @@ import { check } from './check.js';
 import { parse } from 'yaml';
 import { changedFiles, fileAt, readCommits } from './git.js';
 import { citedRefs, linkCommits, scopeOf } from './link.js';
-import { readDocsConfig, readNewsConfig } from './config.js';
+import { readDocsConfig, readNewsConfig, readOrchestrateConfig } from './config.js';
+import { ficheHypotheses } from './spec.js';
 import { docSyncGaps, filesOf, gapMessage } from './docsync.js';
 import { loadEntries, newsIssues, PUBLIC_TITLE_DEFAULT, publicTitleTooLong, reusedNewsTitle } from './news.js';
 import { isRecurring } from './recurring.js';
@@ -158,11 +159,22 @@ export function audit(plan, root, newsDir, today, opts = {}) {
         const m = l.public ? publicTitleTooLong(l.public, max) : reused ? publicTitleTooLong(reused, max) : null;
         return m ? [{ message: `${l.id} : ${reused && !l.public ? m.replace('titre public', 'titre public repris de la Nouveauté') : m}` }] : [];
     });
-    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, entries, newsDir), ...titles, ...gates, ...docSyncIssues(plan, root, all.byLot), ...(plan.hasPublicField ? missingPublicTitles(lots, entries) : []),
+    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, entries, newsDir, hypothesesOf(root, plan.configFile ?? join(root, 'cadence.yaml'))), ...titles, ...gates, ...docSyncIssues(plan, root, all.byLot), ...(plan.hasPublicField ? missingPublicTitles(lots, entries) : []),
         ...plan.ignore.invalid.map((src) => ({ message: `ignore : motif invalide « ${src} »` }))];
     // Un plan en lecture seule se corrige avec l'outil du projet : ne pas conseiller une commande raf qui refuserait.
     return plan.readonly ? issues.map((i) => ({ ...i, message: i.message.replace(/ — raf (start|public) .*$/, '') })) : issues;
 }
+/** Hypothèses des fiches, dans le dossier de `orchestrate.spec.dir` ; une configuration d'orchestrate illisible n'empêche pas le contrôle : dossier par défaut. */
+export function hypothesesOf(root, configFile) {
+    let dir = 'docs/specs';
+    try {
+        dir = readOrchestrateConfig(configFile).spec.dir;
+    }
+    catch {
+        // dossier par défaut
+    }
+    return ficheHypotheses(root, dir);
+}
 /**
  * Documentation en retard (L143, clé `docs.sync`) : un lot en cours — ou terminé à partir de `docs.since` — dont les commits de
  * travail touchent des chemins sans toucher le document que la règle désigne. Les commits de plan ne comptent pas.

package/dist/cli.js

@@ -3,7 +3,7 @@ import { basename, dirname, join, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 import { readDocsConfig, readHookConfig, readNewsConfig, readPlanConfig, readSessionConfig } from './config.js';
 import { repoSections, repoShas, resolveLotRepos } from './repos.js';
-import { audit, exemptPlanOnly, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
+import { audit, exemptPlanOnly, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
 import { deliver, parseDeliverConfig, realDeps } from './deliver.js';
@@ -21,13 +21,15 @@ import { findProjects, leadTour, tourLine } from './lead.js';
 import { liveLines, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
 import { cadenceHome, openLotsIn } from './orchestrate/registry.js';
+import { classifyAll, measure, ollamaClassifier, readCache, readRuns, renderReport, sampleKeys, serializeCache } from './corrections.js';
+import { checkFiche, deriveQa, readFiche, summary } from './spec.js';
 import { readHudContext } from './hud-context.js';
 import { sessionClose, sessionStart } from './session.js';
 import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
 const HELP = `raf — plan « reste à faire » versionné dans le dépôt, relié aux commits
 
   raf init [--project nom] [--prefix L] [--no-hook]
-  raf add "titre" [--estimate j] [--quickwin] [--visible] [--public "titre public"] [--every jours] [--after L2,L4] [--parent L3]
+  raf add "titre" [--estimate j] [--quickwin] [--visible [--screen page|component|journey]] [--public "titre public"] [--every jours] [--after L2,L4] [--parent L3]
   raf public <id> "titre public" | --clear   titre du lot dans le langage du public (pages Nouveautés et Plan)
   raf start <id>        raf done <id> [--force]        raf drop <id> [--reason texte]
   raf note <id> "texte"
@@ -46,6 +48,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf hook install      (pre-commit et post-commit ; cadence.yaml hook.autostart: warn|refuse|start)
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom] [--continue [--until HH:MM] [--priority a,b]]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague]
   cadence lead tour [dossier] [--idle 3] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier seul s'il est lui-même un projet (en cours, dérive, notes de clôture, prochain lot prêt, dépôt)
+  cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--json]   mesure des passes de correction des journaux dossier/.cadence/runs : lots à ≥1 et ≥2 corrections, par projet, visibles ou non, passes par cause (classées par Ollama avec --classify, hors quota)
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
@@ -106,6 +109,7 @@ function dispatch(argv, io) {
             estimate: { type: 'string' },
             quickwin: { type: 'boolean' },
             visible: { type: 'boolean' },
+            screen: { type: 'string' },
             public: { type: 'string' },
             every: { type: 'string' },
             dir: { type: 'string' },
@@ -129,6 +133,11 @@ function dispatch(argv, io) {
             ignored: { type: 'boolean' },
             notes: { type: 'boolean' },
             json: { type: 'boolean' },
+            classify: { type: 'boolean' },
+            model: { type: 'string' },
+            cache: { type: 'string' },
+            sample: { type: 'string' },
+            until: { type: 'string' },
             help: { type: 'boolean', short: 'h' },
         },
     });
@@ -168,6 +177,10 @@ function dispatch(argv, io) {
         }
         return 0;
     }
+    if (command === 'corrections')
+        return corrections(rest, values, io);
+    if (command === 'spec')
+        return spec(rest, io);
     // --all balaie les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant.
     if (command === 'session' && (values.all || values.depth !== undefined))
         return sessionAll(rest, values, io);
@@ -211,6 +224,8 @@ function dispatch(argv, io) {
             const plan = loadPlan();
             let id;
             if (values.parent) {
+                if (values.screen !== undefined)
+                    throw new RafError('--screen se pose sur un lot, pas sur une sous-tâche');
                 if (values.public !== undefined)
                     throw new RafError('--public se pose sur un lot, pas sur une sous-tâche');
                 if (values.every !== undefined)
@@ -227,7 +242,7 @@ function dispatch(argv, io) {
                     throw new RafError(`périodicité invalide : ${values.every} (un nombre entier de jours)`);
                 if (values.public !== undefined)
                     refuseLongTitle(values.public);
-                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, public: values.public, every, after });
+                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, screen: values.screen, public: values.public, every, after });
             }
             plan.save();
             io.out(id);
@@ -321,6 +336,8 @@ function dispatch(argv, io) {
                 io.out(`after : ${lot.after.join(', ')}`);
             if (lot.public)
                 io.out(`public : ${lot.public}`);
+            if (lot.screen)
+                io.out(`screen : ${lot.screen}`);
             if (notes.length) {
                 io.out('notes :');
                 // Les lignes suivantes d'une note multiligne s'alignent sous son texte, pas en colonne 0.
@@ -479,7 +496,7 @@ function dispatch(argv, io) {
             return 0;
         }
         case 'news':
-            return news(rest, loadPlan(), newsDir, today, values, io, refuseLongTitle);
+            return news(rest, loadPlan(), newsDir, today, values, io, refuseLongTitle, () => hypothesesOf(root, configPath));
         default:
             throw new RafError(`commande inconnue : ${command} (raf --help)`);
     }
@@ -665,7 +682,7 @@ function postCommit(load, newsDir, root, today, io, mode) {
     }
     return 0;
 }
-function news([sub, ...args], plan, dir, today, values, io, refuseLongTitle) {
+function news([sub, ...args], plan, dir, today, values, io, refuseLongTitle, hypotheses) {
     const lots = plan.lots();
     switch (sub) {
         case 'new': {
@@ -694,7 +711,7 @@ function news([sub, ...args], plan, dir, today, values, io, refuseLongTitle) {
         case 'check':
         case 'build': {
             const entries = loadEntries(dir);
-            const issues = newsIssues(lots, entries, dir);
+            const issues = newsIssues(lots, entries, dir, sub === 'check' ? hypotheses() : undefined);
             for (const i of issues)
                 io.out(`✗ ${i.message}`);
             // Le build refuse seulement ce qu'il ne saurait pas publier : entrée illisible, capture absente.
@@ -736,6 +753,74 @@ function morningEffects(configPath, root) {
         return [`✗ ${e.message}`];
     }
 }
+/** `cadence spec check|qa <fiche>` (L170) : code 0 valide, 1 écarts, 2 usage ou fichier illisible. `qa` imprime la section expectations.md de l'écran. */
+function spec(rest, io) {
+    const sub = rest[0];
+    if ((sub !== 'check' && sub !== 'qa') || rest.length !== 2)
+        throw new RafError('usage : cadence spec check|qa <fiche.yaml>');
+    const doc = readFiche(resolve(io.cwd, rest[1]));
+    const problems = checkFiche(doc);
+    if (sub === 'qa') {
+        // les écarts vont sur la sortie d'erreur : la sortie standard est la section, qu'on redirige vers le fichier
+        for (const m of problems)
+            io.err(`✗ ${m}`);
+        if (problems.length > 0)
+            return 1;
+        io.out(deriveQa(doc).trimEnd());
+        return 0;
+    }
+    for (const m of problems)
+        io.out(`✗ ${m}`);
+    if (problems.length > 0) {
+        io.out(`${problems.length} écart(s)`);
+        return 1;
+    }
+    io.out(summary(doc));
+    return 0;
+}
+/** `cadence corrections` (L165) : la mesure de référence des passes de correction d'une vague, lue dans <dossier>/.cadence/runs. */
+async function corrections(rest, values, io) {
+    if (rest.length > 1)
+        throw new RafError('usage : cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--json]');
+    const parent = resolve(io.cwd, rest[0] ?? '.');
+    const runsDir = join(parent, '.cadence', 'runs');
+    if (!existsSync(runsDir))
+        throw new RafError(`corrections : aucun journal de vague dans ${runsDir}`);
+    const sample = values.sample === undefined ? undefined : Number(values.sample);
+    if (sample !== undefined && !(Number.isInteger(sample) && sample > 0))
+        throw new RafError(`--sample invalide : ${values.sample}`);
+    if (values.until !== undefined && Number.isNaN(Date.parse(values.until)))
+        throw new RafError(`--until invalide : ${values.until} (une date ISO, ex. 2026-10-10T18:31Z)`);
+    const model = values.model ?? 'mistral-small3.2:24b';
+    const cacheFile = resolve(io.cwd, values.cache ?? join(parent, '.cadence', 'corrections.json'));
+    const data = readRuns(runsDir, values.until);
+    const cache = readCache(cacheFile);
+    if (values.classify) {
+        const classify = ollamaClassifier({ url: io.env.OLLAMA_HOST ?? 'http://localhost:11434', model });
+        await classifyAll(data.passes, cache, classify, model, (done, total) => {
+            if (done % 25 === 0 || done === total)
+                io.err(`classement : ${done}/${total}`);
+        }, { every: 10, save: () => writeFileSync(cacheFile, serializeCache(cache)) });
+        writeFileSync(cacheFile, serializeCache(cache));
+    }
+    if (sample !== undefined) {
+        const byKey = new Map(data.passes.map((p) => [p.key, p]));
+        // Une passe sans constat (tests rouges) n'a rien à relire : elle ne fait pas partie de l'échantillon.
+        for (const key of sampleKeys(data.passes.filter((p) => p.findings.length > 0).map((p) => p.key), sample)) {
+            const p = byKey.get(key);
+            io.out(`## ${key} (${p.project} ${p.lot}) · modèle : ${cache.get(key)?.cause ?? 'non classé'}${cache.get(key)?.manual ? ` · relu : ${cache.get(key).manual}` : ''}`);
+            for (const f of p.findings)
+                io.out(`- ${f}`);
+            for (const c of p.commits)
+                io.out(`  commit : ${c}`);
+            io.out('');
+        }
+        return 0;
+    }
+    const m = measure(data, cache);
+    io.out(values.json ? JSON.stringify(m, null, 2) : renderReport(m));
+    return 0;
+}
 /** `session start|close --all [--depth n]` : la commande jouée dans chaque projet sous le dossier courant, une section par projet. */
 async function sessionAll(rest, values, io) {
     const sub = rest[0];

package/dist/config.js

@@ -220,13 +220,13 @@ export function readSessionConfig(file) {
     return config;
 }
 const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
-export const EFFORT_STEPS = ['precheck', 'implement', 'fix', 'review', 'ux'];
+export const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'accept', 'implement', 'fix', 'review', 'ux'];
 const MODELS = ['haiku', 'sonnet', 'opus'];
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'ux', 'precheck', 'review', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'ux', 'precheck', 'prodAccess', 'spec', 'review', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
-    const config = { precheck: true, precheckLocal: false, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
+    const config = { precheck: true, maquette: true, precheckLocal: false, prodAccess: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
     if (!existsSync(file))
         return config;
     let raw;
@@ -253,19 +253,48 @@ export function readOrchestrateConfig(file) {
     for (const k of Object.keys(o))
         if (!ORCH_KEYS.includes(k))
             throw bad(`${k} inconnu (attendu : ${ORCH_KEYS.join(', ')})`);
-    for (const k of ['start', 'verdict', 'test', 'build']) {
+    for (const k of ['start', 'verdict', 'test', 'build', 'accept']) {
         if (o[k] == null)
             continue;
         if (typeof o[k] !== 'string' || !o[k].trim())
             throw bad(`${k} : commande non vide attendue`);
         config[k] = o[k].trim();
     }
+    if (o.maquette != null) {
+        if (typeof o.maquette !== 'boolean')
+            throw bad('maquette : true ou false attendu');
+        config.maquette = o.maquette;
+    }
     if (o.precheck != null) {
         if (typeof o.precheck !== 'boolean' && o.precheck !== 'local')
             throw bad('precheck : true, false ou local attendu');
         config.precheck = o.precheck !== false;
         config.precheckLocal = o.precheck === 'local';
     }
+    if (o.prodAccess != null) {
+        if (typeof o.prodAccess !== 'boolean')
+            throw bad('prodAccess : true ou false attendu');
+        config.prodAccess = o.prodAccess;
+    }
+    if (o.spec != null) {
+        if (!isObject(o.spec))
+            throw bad('spec doit être un objet { dir, render }');
+        for (const k of Object.keys(o.spec))
+            if (k !== 'dir' && k !== 'render')
+                throw bad(`spec.${k} inconnu (attendu : dir, render)`);
+        if (o.spec.dir != null) {
+            const raw = typeof o.spec.dir === 'string' ? o.spec.dir.trim().replace(/\/+$/, '') : '';
+            const d = raw === '' ? '' : posix.normalize(raw).replace(/\/+$/, '');
+            if (d === '' || isAbsolute(d) || d.split(/[\\/]/).includes('..'))
+                throw bad('spec.dir : chemin relatif non vide au dépôt attendu, sans « .. »');
+            config.spec.dir = d;
+        }
+        if (o.spec.render != null) {
+            if (typeof o.spec.render !== 'string' || !o.spec.render.trim())
+                throw bad('spec.render : commande non vide attendue');
+            config.spec.render = o.spec.render.trim();
+        }
+    }
     if (o.review != null) {
         if (!isObject(o.review))
             throw bad('review doit être un objet { threshold, light, full }');
@@ -289,7 +318,7 @@ export function readOrchestrateConfig(file) {
     }
     if (o.effort != null) {
         if (!isObject(o.effort))
-            throw bad('effort doit être un objet { precheck, implement, fix, review, ux }');
+            throw bad('effort doit être un objet { precheck, spec, maquette, accept, implement, fix, review, ux }');
         for (const [k, v] of Object.entries(o.effort)) {
             if (!EFFORT_STEPS.includes(k))
                 throw bad(`effort.${k} inconnu (attendu : ${EFFORT_STEPS.join(', ')})`);

package/dist/corrections.js

@@ -0,0 +1,228 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { RafError } from './plan.js';
+/** Les causes d'une passe de correction (L165), dans l'ordre où le rapport les liste. */
+export const CAUSES = ['spec-floue', 'regle-inventee', 'derive-architecture', 'donnees-sql', 'bug-code', 'test-manquant', 'faux-constat'];
+const LABELS = {
+    'spec-floue': 'spec floue ou critère absent',
+    'regle-inventee': 'règle de gestion inventée',
+    'derive-architecture': "dérive d'architecture",
+    'donnees-sql': 'données / SQL',
+    'bug-code': 'bug de code',
+    'test-manquant': 'test manquant',
+    'faux-constat': 'faux constat de revue',
+    'sans-constat': 'sans revue (tests rouges)',
+    'non-classe': 'non classé',
+};
+const isReview = (kind) => kind.startsWith('review') || kind === 'ux';
+function readJson(file) {
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Les textes des constats d'un rapport de revue (champ `structured`, sinon le JSON de `result`). */
+function findingsOf(report) {
+    let body = report?.structured;
+    if (!body && typeof report?.result === 'string') {
+        try {
+            body = JSON.parse(report.result);
+        }
+        catch {
+            body = null;
+        }
+    }
+    const list = Array.isArray(body?.constats) ? body.constats : [];
+    return list.map((c) => (typeof c === 'string' ? c : c?.texte)).filter((t) => typeof t === 'string' && t.length > 0);
+}
+/**
+ * Lit les journaux de vague `<runs>/<vague>/<projet>--<lot>.json`. Un lot compte (dénominateur) dès qu'une session
+ * d'écriture a abouti (`until` : date ISO, ne lit que les vagues créées jusque-là et, dans chacune, les étapes terminées (`ended`) jusque-là, pour une mesure que ni les vagues suivantes ni une vague encore en cours ne changent ; une vague ou une étape sans date lisible est écartée) ; chaque pas `fix` abouti est une passe, rattachée aux constats de la dernière revue qui la précède.
+ */
+export function readRuns(runsDir, until) {
+    const lots = [];
+    const passes = [];
+    if (!existsSync(runsDir))
+        return { lots, passes };
+    const limit = until === undefined ? Infinity : Date.parse(until);
+    // Sous `until`, une étape compte si elle est terminée avant la date ; sans date de fin lisible, elle est écartée.
+    const inTime = (s) => until === undefined || Date.parse(s.ended ?? '') <= limit;
+    for (const wave of readdirSync(runsDir).sort()) {
+        const waveDir = join(runsDir, wave);
+        if (!statSync(waveDir).isDirectory())
+            continue;
+        if (until !== undefined) {
+            // Les vagues nommées à la main (ol-gains-1) n'ont pas d'horodatage dans leur nom : on lit `created` dans wave.json.
+            const created = Date.parse(readJson(join(waveDir, 'wave.json'))?.created);
+            if (!(created <= limit))
+                continue;
+        }
+        for (const file of readdirSync(waveDir).sort()) {
+            if (!file.endsWith('.json') || file === 'wave.json')
+                continue;
+            const rec = readJson(join(waveDir, file));
+            if (!rec || !Array.isArray(rec.steps))
+                continue;
+            const steps = rec.steps.filter((s) => s && typeof s === 'object');
+            const done = (s) => s.status === 'ok' && inTime(s);
+            if (!steps.some((s) => s.kind === 'implement' && done(s)))
+                continue;
+            const name = basename(file, '.json');
+            const fixSteps = steps.filter((s) => s.kind === 'fix' && done(s));
+            lots.push({ project: rec.project, lot: rec.lot, visible: !!rec.visible, fixes: fixSteps.length });
+            for (const fix of fixSteps) {
+                const review = [...steps].reverse().find((s) => s.n < fix.n && isReview(s.kind) && s.report);
+                // Une passe fix entre la revue et celle-ci a déjà traité ces constats : cette passe-ci (tests rouges) n'en a pas.
+                const handled = review ? fixSteps.some((f) => f.n > review.n && f.n < fix.n) : false;
+                const findings = review?.report && !handled ? findingsOf(readJson(join(waveDir, name, review.report))) : [];
+                passes.push({ key: `${wave}/${name}/${fix.n}`, project: rec.project, lot: rec.lot, visible: !!rec.visible, findings, commits: fix.commits ?? [] });
+            }
+        }
+    }
+    return { lots, passes };
+}
+const tally = () => ({ lots: 0, atLeast1: 0, atLeast2: 0, passes: 0 });
+const causes = () => ({ ...Object.fromEntries([...CAUSES, 'sans-constat', 'non-classe'].map((c) => [c, 0])) });
+export function measure(data, cache) {
+    const m = { total: tally(), byProject: {}, byVisibility: { visible: tally(), hidden: tally() }, byCause: causes(), byProjectCause: {}, agreement: { reviewed: 0, agree: 0 } };
+    for (const l of data.lots) {
+        const groups = [m.total, (m.byProject[l.project] ??= tally()), l.visible ? m.byVisibility.visible : m.byVisibility.hidden];
+        for (const t of groups) {
+            t.lots++;
+            t.passes += l.fixes;
+            if (l.fixes >= 1)
+                t.atLeast1++;
+            if (l.fixes >= 2)
+                t.atLeast2++;
+        }
+    }
+    for (const p of data.passes) {
+        const c = cache.get(p.key);
+        const cause = p.findings.length === 0 ? 'sans-constat' : c ? (c.manual ?? c.cause) : 'non-classe';
+        m.byCause[cause]++;
+        (m.byProjectCause[p.project] ??= causes())[cause]++;
+        if (c?.manual && cause !== 'sans-constat') {
+            m.agreement.reviewed++;
+            if (c.manual === c.cause)
+                m.agreement.agree++;
+        }
+    }
+    return m;
+}
+/** Extrait une cause connue d'une réponse (JSON `{cause}` ou texte libre) ; null sinon. */
+export function parseCause(text) {
+    try {
+        const c = JSON.parse(text)?.cause;
+        if (typeof c === 'string' && CAUSES.includes(c))
+            return c;
+        return null;
+    }
+    catch {
+        return CAUSES.find((c) => text.includes(c)) ?? null;
+    }
+}
+const SYSTEM = `Tu classes la CAUSE d'une passe de correction dans un projet logiciel mené par vagues d'agents : une session a écrit du code, une revue a formulé des constats, une session de correction les a traités. Réponds par UNE cause, celle du constat le plus grave, en cherchant la racine de ce qui a obligé à corriger.
+Règle de départ : si le code livré ne fait pas ce que le lot ou le commit annonce, ou fait faux (logique, cas limite, condition trop large, rendu qui ne s'applique pas, accessibilité, état périmé, travail annoncé mais non fait), c'est bug-code.
+- bug-code : le code livré est faux ou incomplet par rapport à une intention CLAIRE ;
+- spec-floue : UNIQUEMENT si le constat dit que l'énoncé du lot est ambigu, muet, contradictoire ou sans critère mesurable et que la session a dû deviner ; un constat qui compare le code à un énoncé précis n'est PAS spec-floue ;
+- regle-inventee : la session a ajouté de son chef une règle de gestion, un seuil, un message ou un comportement que le lot ne demandait pas ;
+- derive-architecture : une convention ou une règle écrite du projet (CLAUDE.md, README, documentation, structure, duplication, couche contournée, agent ou brief incohérent) n'est pas suivie ;
+- donnees-sql : requête, schéma, migration, format ou contenu de données faux ;
+- test-manquant : le code est juste mais un comportement n'est pas couvert, ou un test ne vérifie pas ce que son titre promet ;
+- faux-constat : la revue se trompe (le code était correct, constat infondé, hors lot, sans effet réel).`;
+/** Classeur sur un modèle local servi par Ollama (/api/chat, température 0, sortie contrainte par un schéma) : hors quota Anthropic. */
+export function ollamaClassifier(opts) {
+    const doFetch = opts.fetch ?? fetch;
+    return async (pass) => {
+        const findings = pass.findings.length ? pass.findings.map((f, i) => `${i + 1}. ${f.slice(0, 1500)}`).join('\n') : '(aucun constat lisible)';
+        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: { cause: { type: 'string', enum: [...CAUSES] }, raison: { type: 'string' } }, required: ['cause', 'raison'] },
+                    messages: [{ role: 'system', content: SYSTEM }, { role: 'user', content: user }],
+                }),
+            });
+            if (!res.ok)
+                return null;
+            const body = (await res.json());
+            return parseCause(body.message?.content ?? '');
+        }
+        catch {
+            return null;
+        }
+    };
+}
+/** Classe les passes absentes du cache, une à une ; un échec n'entre pas au cache (une relance le reprend). */
+export async function classifyAll(passes, cache, classify, model, progress, checkpoint) {
+    const todo = passes.filter((p) => p.findings.length > 0 && !cache.has(p.key));
+    let done = 0;
+    for (const p of todo) {
+        const cause = await classify(p);
+        if (cause)
+            cache.set(p.key, { cause, by: `ollama:${model}` });
+        done++;
+        progress?.(done, todo.length);
+        // Sauvegarde périodique : une interruption (Ctrl-C, Ollama tombé) ne perd que les derniers classements.
+        if (checkpoint && done % checkpoint.every === 0)
+            checkpoint.save();
+    }
+    if (checkpoint && done % checkpoint.every !== 0)
+        checkpoint.save();
+}
+/** n clés réparties à intervalle régulier dans l'ordre trié : le même échantillon à chaque lecture. */
+export function sampleKeys(keys, n) {
+    const sorted = [...keys].sort();
+    if (sorted.length <= n)
+        return sorted;
+    const step = sorted.length / n;
+    return Array.from({ length: n }, (_, i) => sorted[Math.floor(i * step)]);
+}
+export function readCache(file) {
+    let raw = null;
+    if (existsSync(file)) {
+        // Un fichier illisible lu comme vide serait réécrit par --classify et perdrait les relectures saisies à la main.
+        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 = (c) => typeof c === 'string' && CAUSES.includes(c);
+    const entries = Object.entries((raw ?? {}));
+    // Une cause inconnue (faute de frappe dans une relecture) ferait disparaître la passe des tableaux : on refuse le fichier.
+    for (const [key, c] of entries) {
+        if (!known(c?.cause))
+            throw new RafError(`${file} : cause inconnue pour ${key} : ${String(c?.cause)}`);
+        if (c.manual !== undefined && !known(c.manual))
+            throw new RafError(`${file} : relecture inconnue pour ${key} : ${String(c.manual)} (causes : ${CAUSES.join(', ')})`);
+    }
+    return new Map(entries);
+}
+export function serializeCache(cache) {
+    return JSON.stringify(Object.fromEntries([...cache].sort(([a], [b]) => a.localeCompare(b))), null, 2) + '\n';
+}
+const pct = (a, b) => (b === 0 ? '—' : `${Math.round((100 * a) / b)} %`);
+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) {
+    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();
+    const passes = m.total.passes;
+    const out = [];
+    out.push(`**${m.total.lots} lots** passés par une session d'écriture, **${passes} passes de correction** : ${pct(m.total.atLeast1, m.total.lots)} des lots ont eu au moins une correction, ${pct(m.total.atLeast2, m.total.lots)} au moins deux.`, '');
+    out.push('### Par cause', '', '| Cause | Passes | Part |', '|---|---|---|', ...used.map((c) => `| ${LABELS[c]} | ${m.byCause[c]} | ${pct(m.byCause[c], passes)} |`), '');
+    out.push('### Par cause et par projet (passes)', '', `| Projet | ${used.map((c) => LABELS[c]).join(' | ')} | Total |`, `|---|${used.map(() => '---').join('|')}|---|`);
+    for (const p of projects)
+        out.push(`| ${p} | ${used.map((c) => m.byProjectCause[p]?.[c] ?? 0).join(' | ')} | ${m.byProject[p].passes} |`);
+    out.push('', '### Lots avec correction', '', '| Projet | Lots | ≥ 1 correction | ≥ 2 corrections | Passes |', '|---|---|---|---|---|', ...projects.map((p) => row(p, m.byProject[p])), row('**Total**', m.total), '');
+    out.push('### Lots visibles et non visibles', '', '| Lots | Lots | ≥ 1 correction | ≥ 2 corrections | Passes |', '|---|---|---|---|---|', row('visibles', m.byVisibility.visible), row('non visibles', m.byVisibility.hidden), '');
+    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.`, '');
+    return out.join('\n');
+}

package/dist/news.js

@@ -142,7 +142,21 @@ export function loadEntries(dir, added = () => addedTimes(dir)) {
         return b.file.localeCompare(a.file);
     });
 }
-export function newsIssues(lots, entries, dir) {
+/** Lignes `- Rn — …` de la section `## Hypothèses` du corps d'une entrée : null sans la section. */
+function hypothesisLines(body) {
+    const lines = body.split('\n');
+    const start = lines.findIndex((l) => /^##\s+Hypothèses\s*$/i.test(l));
+    if (start < 0)
+        return null;
+    const rest = lines.slice(start + 1);
+    const end = rest.findIndex((l) => /^#{1,6}\s/.test(l));
+    return (end < 0 ? rest : rest.slice(0, end)).filter((l) => /^\s*[-*]\s+R\d+(?!\d)/.test(l));
+}
+/**
+ * `hypotheses` : par lot, les règles `hypothese` de sa fiche (L174, `ficheHypotheses`). L'entrée d'un lot qui en a doit se terminer
+ * par une section `## Hypothèses` avec une ligne `- Rn — …` par règle.
+ */
+export function newsIssues(lots, entries, dir, hypotheses = new Map()) {
     const issues = [];
     const ids = new Set(lots.map((l) => l.id));
     const covered = new Set(entries.flatMap((e) => e.lots));
@@ -169,6 +183,18 @@ export function newsIssues(lots, entries, dir) {
             issues.push({ kind: 'visible-without-entry', message: `${l.id} est visible et terminé sans entrée Nouveautés — cadence news new ${l.id}` });
         }
     }
+    for (const [id, rules] of hypotheses) {
+        const mine = entries.filter((e) => e.lots.includes(id));
+        if (!rules.length || !mine.length)
+            continue;
+        const found = mine.map((e) => ({ e, lines: hypothesisLines(e.body) })).map(({ e, lines }) => ({ e, lines, missing: lines ? rules.filter((r) => !lines.some((l) => new RegExp(`^\\s*[-*]\\s+${r.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?!\\d)`).test(l))) : rules }));
+        if (found.some((f) => f.lines && f.missing.length === 0))
+            continue;
+        const withSection = found.filter((f) => f.lines).sort((a, b) => a.missing.length - b.missing.length)[0];
+        issues.push(withSection
+            ? { kind: 'missing-hypotheses', message: `${id} : la section « ## Hypothèses » de ${withSection.e.file} n'a pas de ligne pour ${withSection.missing.join(', ')}` }
+            : { kind: 'missing-hypotheses', message: `${id} : la fiche a des hypothèses (${rules.join(', ')}) mais l'entrée ${mine[0].file} n'a pas la section « ## Hypothèses »` });
+    }
     return issues;
 }
 export function slugify(title) {
@@ -242,19 +268,40 @@ function inline(text) {
     })
         .join('');
 }
-/** Markdown minimal : paragraphes, listes « - », **gras**, `code`, [liens](url). Tout le reste est du texte échappé. */
+/** Markdown minimal : titres « # » à « ###### », paragraphes, listes « - » (puce continuée sur une ligne indentée), **gras**, `code`, [liens](url). Tout le reste est du texte échappé. */
 export function renderMarkdown(md) {
     return md
         .replace(/\r\n/g, '\n')
         .split(/\n\s*\n/)
         .map((block) => block.trim())
         .filter(Boolean)
-        .map((block) => {
-        const lines = block.split('\n');
-        if (lines.every((l) => /^\s*[-*] /.test(l))) {
-            return `<ul>${lines.map((l) => `<li>${inline(l.replace(/^\s*[-*] /, ''))}</li>`).join('')}</ul>`;
+        .flatMap((block) => {
+        // un titre tient sur sa ligne : ce qui le suit (liste, paragraphe) est un bloc à part, même sans ligne vide
+        const parts = [];
+        for (const line of block.split('\n')) {
+            const prev = parts[parts.length - 1];
+            if (!prev || /^#{1,6} /.test(line) || /^#{1,6} /.test(prev[0]))
+                parts.push([line]);
+            else
+                prev.push(line);
         }
-        return `<p>${inline(block)}</p>`;
+        return parts.map((lines) => {
+            const heading = /^(#{1,6}) +(.+)$/.exec(lines[0]);
+            if (heading)
+                return `<h${Math.min(heading[1].length + 1, 6)}>${inline(heading[2].trim())}</h${Math.min(heading[1].length + 1, 6)}>`;
+            // une puce peut continuer sur la ligne suivante, indentée (format d'une hypothèse, spec §8)
+            if (/^\s*[-*] /.test(lines[0]) && lines.every((l) => /^\s*[-*] /.test(l) || /^\s+\S/.test(l))) {
+                const items = [];
+                for (const l of lines) {
+                    if (/^\s*[-*] /.test(l))
+                        items.push(l.replace(/^\s*[-*] /, ''));
+                    else
+                        items[items.length - 1] += `\n${l.trim()}`;
+                }
+                return `<ul>${items.map((i) => `<li>${inline(i)}</li>`).join('')}</ul>`;
+            }
+            return `<p>${inline(lines.join('\n'))}</p>`;
+        });
     })
         .join('\n');
 }