@sylad/cadence 1.0.0 → 1.2.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', 'fiche', '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', 'fiche', '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, fiche: true, precheckLocal: false, prodAccess: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', 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,60 @@ 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']) {
+    if (o.accept != null && Array.isArray(o.accept)) {
+        if (!o.accept.length || o.accept.some((x) => typeof x !== 'string' || !x.trim()))
+            throw bad('accept : commande non vide attendue (chaîne ou liste de commandes non vides)');
+        config.accept = o.accept.map((x) => x.trim());
+    }
+    for (const k of ['start', 'verdict', 'test', 'build', 'accept']) {
+        if (k === 'accept' && Array.isArray(o.accept))
+            continue;
         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.fiche != null) {
+        if (typeof o.fiche !== 'boolean')
+            throw bad('fiche : true ou false attendu');
+        config.fiche = o.fiche;
+    }
     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 +330,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, fiche, 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/lead.js

@@ -1,13 +1,58 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, join, relative, sep } from 'node:path';
 import { audit, nextUp, planCommits } from './audit.js';
 import { planLoader, readPlanConfig } from './config.js';
 import { diffDays } from './dates.js';
 import { gitRoot, repoStatus } from './git.js';
 import { linkCommits } from './link.js';
 import { lastActivity, lockStatus } from './session.js';
+import { parse } from 'yaml';
+import { RafError } from './plan.js';
 import { priorityRank, readPriority } from './orchestrate/continue.js';
 import { readNext, sharedStateDir, stateDir } from './state.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) {
+    const file = join(parent, 'cadence.yaml');
+    if (!existsSync(file))
+        return 'human';
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const l = raw?.lead;
+    if (l == null)
+        return 'human';
+    const ux = l.ux;
+    if (typeof l !== 'object' || Array.isArray(l))
+        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+    if (ux == null)
+        return 'human';
+    if (ux !== 'lead' && ux !== 'human')
+        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+    return ux;
+}
+/** 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');
+    if (!existsSync(file))
+        return 1;
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const d = raw?.depth;
+    if (d == null)
+        return 1;
+    if (typeof d !== 'number' || !Number.isInteger(d) || d < 1)
+        throw new RafError(`${file} : depth doit être un entier ≥ 1`);
+    return d;
+}
 export const NOTES_MAX = 120;
 export const TITLE_MAX = 60;
 /** Au-delà de ce nombre de jours sans activité, un lot en cours est dit silencieux. */
@@ -56,8 +101,8 @@ export function findProjects(parent, depth = 1) {
     return found.sort();
 }
 /** Les faits de `cadence session start` pour un projet, sous forme de données ; lecture seule. */
-export function tourRow(dir, today, idle = TOUR_IDLE) {
-    const row = empty(basename(dir));
+export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
+    const row = empty(name);
     try {
         const root = gitRoot(dir) ?? dir;
         const plan = planLoader(root)();
@@ -96,24 +141,32 @@ export function tourRow(dir, today, idle = TOUR_IDLE) {
 }
 /**
  * Les projets rangés par la clé `priority:` du cadence.yaml du dossier (L149) ; les autres après, par ordre alphabétique.
- * Une priorité illisible ou invalide ne vide pas le tableau : l'ordre alphabétique reste, et une première ligne `cadence.yaml` en erreur le dit.
+ * Une clé `depth:` invalide se signale de même. Une priorité illisible ou invalide ne vide pas le tableau : l'ordre alphabétique reste, et une première ligne `cadence.yaml` en erreur le dit.
  * Un dossier qui n'a aucun sous-projet mais est lui-même un projet donne la ligne de ce projet seul (la bande l'interroge depuis le dossier de la session).
  */
-export function leadTour(parent, today, idle = TOUR_IDLE) {
-    const dirs = findProjects(parent);
+export function leadTour(parent, today, idle = TOUR_IDLE, depth) {
+    const problems = [];
+    const attempt = (read, fallback) => {
+        try {
+            return read();
+        }
+        catch (e) {
+            const error = (e instanceof Error ? e.message : String(e)).split('\n')[0];
+            if (!problems.some((p) => p.error === error))
+                problems.push({ ...empty('cadence.yaml'), error }); // un yaml illisible l'est pour les deux clés : une seule ligne
+            return fallback;
+        }
+    };
+    // --depth l'emporte sur la clé `depth:` ; une clé invalide se signale et laisse un seul niveau
+    const levels = depth ?? attempt(() => readDepth(parent), 1);
+    const dirs = findProjects(parent, levels);
     if (dirs.length === 0 && isProject(parent))
-        return [tourRow(parent, today, idle)];
-    const rows = dirs.map((dir) => tourRow(dir, today, idle));
-    let priority = [];
-    let problem;
-    try {
-        priority = readPriority(parent);
-    }
-    catch (e) {
-        problem = { ...empty('cadence.yaml'), error: (e instanceof Error ? e.message : String(e)).split('\n')[0] };
-    }
-    const sorted = rows.map((r, i) => ({ r, i })).sort((a, b) => priorityRank(a.r.project, priority) - priorityRank(b.r.project, priority) || a.i - b.i).map((x) => x.r);
-    return problem ? [problem, ...sorted] : sorted;
+        return [...problems, tourRow(parent, today, idle)];
+    // un projet imbriqué est nommé par son chemin depuis le dossier : unique, et adressable par `orchestrate <projet>:<lot>` lancé d'ici ; la priorité et l'ordre alphabétique lisent le nom du dossier, comme orchestrate --continue
+    const rows = dirs.map((dir) => ({ dir, key: basename(dir), row: tourRow(dir, today, idle, relative(parent, dir).split(sep).join('/')) }));
+    const priority = attempt(() => readPriority(parent), []);
+    const sorted = rows.sort((a, b) => priorityRank(a.key, priority) - priorityRank(b.key, priority) || a.key.localeCompare(b.key) || a.row.project.localeCompare(b.row.project)).map((x) => x.row);
+    return [...problems, ...sorted];
 }
 const DRIFT_SHOWN = 2;
 /** Une ligne par projet : projet · en cours · dérive · notes · prochain lot prêt · dépôt. */

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');
 }