@sylad/cadence 1.40.0 → 1.42.1

package/dist/config.js

@@ -1,19 +1,18 @@
-import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { existsSync, realpathSync, statSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
-import { parse } from 'yaml';
 import { isDay } from './dates.js';
 import { readGate } from './gate-config.js';
 import { DEFAULT_TEST_PATTERNS } from './testgate.js';
+import { readExtras } from './plan-extras.js';
 import { gitRoot } from './git.js';
 import { planCommitProblem } from './plan-commit.js';
+import { parseStates } from './plan-states.js';
 import { checkTestReplay, readGateTest } from './orchestrate/gate-parts.js';
-import { booleanKey } from './yaml-keys.js';
-import { FIELDS, Plan, RafError, STATUSES } from './plan.js';
-const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit'];
+import { booleanKey, isObject, list, readYamlFile, readYamlKey } from './yaml-keys.js';
+import { FIELDS, Plan, RafError, readIdPattern, STATUSES } from './plan.js';
+const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit', 'states', 'transitions', 'doneState', 'blockedState', 'extras', 'idPattern'];
 const ON_WRITE_KEYS = ['command', 'files'];
 const FORMAT_KEYS = ['lots', 'fields', 'statuses', 'estimates'];
-const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-const list = (v) => (v == null ? [] : Array.isArray(v) ? v.map(String) : [String(v)]);
 /** Chemin réel (liens symboliques résolus) du plus proche ancêtre existant, le reste rattaché tel quel. */
 function realish(p) {
     try {
@@ -72,15 +71,9 @@ function readOnWrite(v, cwd, bad) {
  * Null quand le fichier ou la clé manque — le plan est alors .cadence/raf.yaml (ou docs/plan/raf.yaml hérité) au format de raf.
  */
 export function readPlanConfig(file, root) {
-    if (!existsSync(file))
+    const raw = readYamlFile(file);
+    if (raw === undefined)
         return null;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
     const doc = raw;
     const qa = readQa(doc?.qa, file, root);
     const p = doc?.plan;
@@ -112,6 +105,7 @@ export function readPlanConfig(file, root) {
         settings.onWrite = readOnWrite(p.onWrite, root ?? dirname(resolve(file)), bad);
     if (FORMAT_KEYS.some((k) => p[k] != null))
         settings.format = parseFormat(p, bad);
+    Object.assign(settings, parseStates(p, bad, settings.format !== undefined), readExtras(p.extras, !!settings.format, bad), readIdPattern(p.idPattern, bad));
     if (p.path != null && String(p.path).trim() === '')
         throw bad('path est vide');
     if (p.add != null && (typeof p.add !== 'string' || !p.add.includes('{title}')))
@@ -174,16 +168,7 @@ function parseFormat(p, bad) {
 }
 /** Clé `news:` de cadence.yaml. */
 export function readNewsConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const n = raw?.news;
+    const n = readYamlKey(file, 'news');
     if (n == null)
         return {};
     if (!isObject(n))
@@ -191,26 +176,16 @@ export function readNewsConfig(file) {
     for (const k of Object.keys(n))
         if (k !== 'publicTitleMax')
             throw new RafError(`${file} : news.${k} inconnu (attendu : publicTitleMax)`);
-    const max = n.publicTitleMax;
-    if (max == null)
+    if (n.publicTitleMax == null)
         return {};
-    if (typeof max !== 'number' || !Number.isInteger(max) || max < 1)
+    if (typeof n.publicTitleMax !== 'number' || !Number.isInteger(n.publicTitleMax) || n.publicTitleMax < 1)
         throw new RafError(`${file} : news.publicTitleMax : nombre entier de caractères (≥ 1) attendu`);
-    return { publicTitleMax: max };
+    return { publicTitleMax: n.publicTitleMax };
 }
 const AUTOSTART = ['warn', 'refuse', 'start'];
 /** Clé `hook:` de cadence.yaml. */
 export function readHookConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const h = raw?.hook;
+    const h = readYamlKey(file, 'hook');
     if (h == null)
         return {};
     if (!isObject(h))
@@ -229,16 +204,7 @@ const PRICED_MODELS = ['sonnet', 'opus', 'haiku'];
 const PRICE_KEYS = ['input', 'output', 'cacheRead'];
 /** Clé `perf.prices` de cadence.yaml : la grille de prix du coût par lot livré ; null sans grille (clé absente ou vide). */
 export function readPerfConfig(file) {
-    if (!existsSync(file))
-        return null;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const perf = raw?.perf;
+    const perf = readYamlKey(file, 'perf');
     if (perf == null)
         return null;
     if (!isObject(perf))
@@ -276,16 +242,7 @@ export function readPerfConfig(file) {
  * joués par cadence au lieu d'être remplacés.
  */
 export function readSessionConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const s = raw?.session;
+    const s = readYamlKey(file, 'session');
     if (s == null)
         return {};
     if (!isObject(s))
@@ -316,16 +273,7 @@ const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
 const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'probe', 'fix', 'review', 'ux'];
 /** Clé `verify:` de cadence.yaml. Absente : `{}`. */
 export function readVerifyConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const v = raw?.verify;
+    const v = readYamlKey(file, 'verify');
     if (v == null)
         return {};
     if (!isObject(v))
@@ -344,16 +292,7 @@ const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeD
 /** 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, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, worktrees: 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', probe: '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;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const o = raw?.orchestrate;
+    const o = readYamlKey(file, 'orchestrate');
     if (o == null)
         return config;
     const bad = (what) => new RafError(`${file} : orchestrate.${what}`);
@@ -583,15 +522,7 @@ const DOCS_KEYS = ['sync', 'since', 'articles'];
 /** Clé `docs:` de cadence.yaml : `docs.sync`, la documentation qui doit suivre le code. */
 export function readDocsConfig(file) {
     const none = { sync: [] };
-    if (!existsSync(file))
-        return none;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
+    const raw = readYamlFile(file);
     if (raw?.describedBy != null) {
         throw new RafError(`${file} : describedBy n'existe plus (L308) : les documents hors dépôt se déclarent dans docs.articles, { repo, file } relatif au projet`);
     }
@@ -650,16 +581,7 @@ export function readDocsConfig(file) {
 }
 /** Clé `references:` de cadence.yaml. */
 export function readReferencesConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const r = raw?.references;
+    const r = readYamlKey(file, 'references');
     if (r == null)
         return {};
     if (!isObject(r))
@@ -676,16 +598,7 @@ export function readReferencesConfig(file) {
 /** Clé `migrate:` de cadence.yaml (L284) : `migrate.keep`. */
 export function readMigrateConfig(file) {
     const none = { keep: [] };
-    if (!existsSync(file))
-        return none;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const m = raw?.migrate;
+    const m = readYamlKey(file, 'migrate');
     if (m == null)
         return none;
     if (!isObject(m))

package/dist/corrections.js

@@ -198,32 +198,37 @@ Règle de départ : si le code livré ne fait pas ce que le lot ou le commit ann
 - 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).`;
+/** Appel `/api/chat` d'Ollama (température 0, sortie contrainte par `format`) : le texte du message, null sur réponse refusée ou échec réseau. Commun au classeur et au sous-classeur. */
+async function ollamaChat(opts, format, system, user) {
+    const doFetch = opts.fetch ?? fetch;
+    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,
+                messages: [{ role: 'system', content: system }, { role: 'user', content: user }],
+            }),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return body.message?.content ?? '';
+    }
+    catch {
+        return null;
+    }
+}
 /** 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;
-        }
+        const text = await ollamaChat(opts, { type: 'object', properties: { cause: { type: 'string', enum: [...CAUSES] }, raison: { type: 'string' } }, required: ['cause', 'raison'] }, SYSTEM, user);
+        return text === null ? null : parseCause(text);
     };
 }
 /** Classe les passes absentes du cache, une à une ; un échec n'entre pas au cache (une relance le reprend). */
@@ -323,30 +328,11 @@ const SOUS_SYSTEM = `Tu sous-classes une passe de correction déjà classée «
 ${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;
-        }
+        const text = await ollamaChat(opts, { type: 'object', properties: { sous: { type: 'string', enum: [...SOUS_CAUSES] }, raison: { type: 'string' } }, required: ['sous', 'raison'] }, SOUS_SYSTEM, user);
+        return text === null ? null : parseSousCause(text);
     };
 }
 /** La cause retenue d'une passe à constats : la relecture à la main, sinon le modèle ; absente sans classement. */

package/dist/deliver-lots.js

@@ -0,0 +1,37 @@
+import { isPlanOnly } from './audit.js';
+import { isAncestor, readCommits } from './git.js';
+import { citedRefs } from './link.js';
+/**
+ * Ligne des lots cités depuis la livraison précédente, ou null (première livraison, rien de cité).
+ *
+ * Plan en lecture seule : seuls les lots EN COURS sont annoncés. Ses identifiants sont de forme libre, et
+ * un message cite volontiers un numéro qui en a la forme (réserve « R1 » d'une revue) ou un lot clos
+ * nommé pour le contexte — les annoncer « livrés » ferait fermer à tort. L'état est celui du départ de
+ * la livraison : le plan a été lu avant que le script du projet ne ferme lui-même les lots qu'il livre.
+ */
+/** Lots cités par les commits livrés depuis la livraison précédente ; vide quand elle est inconnue ou hors de l'historique. */
+export function deliveredIds(ctx, prev, sha) {
+    if (!ctx.plan || !prev || prev === sha || !isAncestor(ctx.root, prev, sha))
+        return [];
+    const lots = ctx.plan.lots();
+    const known = new Set((ctx.plan.readonly ? lots.filter((l) => l.status === 'doing') : lots).map((l) => l.id));
+    const ids = new Set();
+    for (const c of readCommits(ctx.root, { range: `${prev}..${sha}` })) {
+        if (isPlanOnly(c.sha, ctx.plan, ctx.root))
+            continue; // entretien du plan : ne livre rien, même s'il cite des lots
+        for (const r of citedRefs(c, ctx.plan.refs))
+            if (known.has(r.lot))
+                ids.add(r.lot);
+    }
+    return [...ids].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+}
+export function deliveredLots(ctx, ids, prev, sha) {
+    if (!ctx.plan || !prev || prev === sha)
+        return null;
+    if (!isAncestor(ctx.root, prev, sha)) {
+        return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
+    }
+    if (ids.length === 0)
+        return null;
+    return `livré : ${ids.join(', ')} — ${ctx.plan.readonly ? "à fermer avec l'outil du projet" : 'raf done'} si l'effet est celui attendu`;
+}

package/dist/deliver.js

@@ -4,11 +4,11 @@ import { constants } from 'node:os';
 import { join, relative } from 'node:path';
 import { parse } from 'yaml';
 import { onTermination, readProcs, SIGNAL_GRACE_MS, SIGNAL_PENDING_MS, TreeTracker } from './proc.js';
-import { deliveryLots, isPlanOnly } from './audit.js';
-import { commitPaths, dirtyPaths, headSha, isAncestor, onRemote, readCommits, repoStatus, resolveCommit } from './git.js';
+import { deliveryLots } from './audit.js';
+import { commitPaths, dirtyPaths, headSha, isAncestor, onRemote, repoStatus, resolveCommit } from './git.js';
 import { planOnlySince, pollGithubCi, stamped, stepJournal } from './deliver-ci.js';
 import { PLAN_ACTIONS, planCommitMessage } from './plan-commit.js';
-import { citedRefs } from './link.js';
+import { deliveredIds, deliveredLots } from './deliver-lots.js';
 import { describeArticle, openArticleLots } from './articles.js';
 import { RafError } from './plan.js';
 import { appendDelivery, appendFailedDelivery, lastDelivery, lockAlive, lockFault, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
@@ -422,8 +422,7 @@ export async function deliver(ctx, deps) {
                 how = 'moved';
             }
         }
-        const ids = deliveredIds(ctx, lastDelivery(ctx.state), final);
-        const delivered = deliveredLots(ctx, ids, lastDelivery(ctx.state), final);
+        const prev = lastDelivery(ctx.state);
         appendDelivery(ctx.state, ctx.today, final);
         const took = `en ${Math.round((deps.now() - startedAt) / 1000)} s`;
         if (how === 'declared')
@@ -432,9 +431,7 @@ export async function deliver(ctx, deps) {
             out(stamped(deps, `✓ livré : ${final.slice(0, 7)} (tête déplacée par le script depuis ${env.CADENCE_SHORT}) ${took}`));
         else
             out(stamped(deps, `✓ livré${config.verify.length ? ' et vérifié' : ''} : ${env.CADENCE_SHORT} ${took}`));
-        if (delivered)
-            out(delivered);
-        refreshArticles(ctx, ids, final);
+        announceDelivered(ctx, prev, final);
         return 0;
     }
     finally {
@@ -504,38 +501,17 @@ async function verifyAll(ctx, deps, sha, env, step) {
     return null;
 }
 /**
- * Ligne des lots cités depuis la livraison précédente, ou null (première livraison, rien de cité).
- *
- * Plan en lecture seule : seuls les lots EN COURS sont annoncés. Ses identifiants sont de forme libre, et
- * un message cite volontiers un numéro qui en a la forme (réserve « R1 » d'une revue) ou un lot clos
- * nommé pour le contexte — les annoncer « livrés » ferait fermer à tort. L'état est celui du départ de
- * la livraison : le plan a été lu avant que le script du projet ne ferme lui-même les lots qu'il livre.
+ * Ce qui suit la ligne verte du journal, depuis la livraison verte précédente `prev` (celle d'AVANT la ligne écrite) : les lots cités
+ * par les commits livrés sont annoncés (« livré : L… »), puis le lot de l'article à rafraîchir est ouvert (L144). Partagé par deliver
+ * et par `cadence verify` (L435) : la ligne que verify écrit est une livraison, la suivante partira d'elle, les lots d'entre-deux se
+ * disent donc ici ou jamais.
  */
-/** Lots cités par les commits livrés depuis la livraison précédente ; vide quand elle est inconnue ou hors de l'historique. */
-function deliveredIds(ctx, prev, sha) {
-    if (!ctx.plan || !prev || prev === sha || !isAncestor(ctx.root, prev, sha))
-        return [];
-    const lots = ctx.plan.lots();
-    const known = new Set((ctx.plan.readonly ? lots.filter((l) => l.status === 'doing') : lots).map((l) => l.id));
-    const ids = new Set();
-    for (const c of readCommits(ctx.root, { range: `${prev}..${sha}` })) {
-        if (isPlanOnly(c.sha, ctx.plan, ctx.root))
-            continue; // entretien du plan : ne livre rien, même s'il cite des lots
-        for (const r of citedRefs(c, ctx.plan.refs))
-            if (known.has(r.lot))
-                ids.add(r.lot);
-    }
-    return [...ids].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
-}
-function deliveredLots(ctx, ids, prev, sha) {
-    if (!ctx.plan || !prev || prev === sha)
-        return null;
-    if (!isAncestor(ctx.root, prev, sha)) {
-        return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
-    }
-    if (ids.length === 0)
-        return null;
-    return `livré : ${ids.join(', ')} — ${ctx.plan.readonly ? "à fermer avec l'outil du projet" : 'raf done'} si l'effet est celui attendu`;
+export function announceDelivered(ctx, prev, sha) {
+    const ids = deliveredIds(ctx, prev, sha);
+    const delivered = deliveredLots(ctx, ids, prev, sha);
+    if (delivered)
+        ctx.out(delivered);
+    refreshArticles(ctx, ids, sha);
 }
 /**
  * Livraison verte (L144) : les lots livrés dont le titre est public changent ce que les articles externes racontent, on ouvre

package/dist/docs-ok-file.js

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { parseDocument } from 'yaml';
+import { RafError } from './plan.js';
+/** Fichier d'acquittement docs-ok d'un plan en lecture seule, relatif à la racine du dépôt (L386). */
+export const DOCS_OK_FILE = '.cadence/docs-ok.yaml';
+/** Les acquittements du fichier : lot → { date, reason }. Une entrée sans raison n'acquitte rien ; un fichier illisible est une erreur qui le nomme. */
+export function readDocsOkFile(file) {
+    if (!file || !existsSync(file))
+        return {};
+    const doc = parseDocument(readFileSync(file, 'utf8'));
+    if (doc.errors.length > 0)
+        throw new RafError(`${file} : ${doc.errors[0].message}`);
+    const raw = doc.toJSON();
+    if (raw == null)
+        return {};
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        throw new RafError(`${file} : la racine doit être un objet (lot → { date, reason })`);
+    const out = {};
+    for (const [id, v] of Object.entries(raw)) {
+        const e = v;
+        if (e && typeof e === 'object' && typeof e.reason === 'string' && e.reason.trim() !== '')
+            out[id] = { date: String(e.date ?? ''), reason: e.reason.trim() };
+    }
+    return out;
+}

package/dist/docsync.js

@@ -1,5 +1,17 @@
 import { resolve } from 'node:path';
 import { changedFiles } from './git.js';
+/**
+ * Commits dont les fichiers comptent pour `docs.sync` (L537) : ceux de type `refactor` (`refactor(L1): …`) sont un nettoyage ou
+ * un découpage déclaré sans changement de commande, de clé ni de sortie, donc sans document à écrire. `refactor!` et un refactor
+ * dont le corps porte le pied `BREAKING CHANGE:` restent un changement.
+ */
+function docSyncCommits(commits) {
+    return commits.filter((c) => !/^refactor(\([^)]*\))?:/.test(c.subject) || /^BREAKING[ -]CHANGE:/m.test(c.body));
+}
+/** Les écarts d'un lot : les fichiers de `paths` viennent des commits qui comptent, mais un document écrit dans un refactor reste écrit. */
+export function lotDocSyncGaps(rules, root, commits) {
+    return docSyncGaps(rules, filesOf(root, docSyncCommits(commits)), filesOf(root, commits));
+}
 /** Motif de chemin : `*` reste dans un dossier, `**` le traverse, `?` un caractère, un `/` final prend tout le dossier ; sinon chemin exact. */
 export function docSyncMatcher(pattern) {
     const p = pattern.trim().replace(/\\/g, '/').replace(/^\.\//, '');
@@ -20,11 +32,11 @@ export function docSyncSet(patterns) {
 export function filesOf(root, commits, opts = {}) {
     return new Set(commits.flatMap((c) => changedFiles(root, c.sha, opts)));
 }
-/** Les règles que ces fichiers enfreignent : ils touchent `paths` sans qu'aucun `docs` ne soit parmi eux. */
-export function docSyncGaps(rules, files) {
+/** Les règles que ces fichiers enfreignent : ils touchent `paths` sans qu'aucun `docs` ne soit parmi les fichiers `written`. */
+function docSyncGaps(rules, files, written) {
     const gaps = [];
     for (const rule of rules) {
-        if ([...files].some(docSyncSet(rule.docs)))
+        if ([...written].some(docSyncSet(rule.docs)))
             continue;
         const inPaths = docSyncSet(rule.paths);
         const touched = [...files].filter(inPaths).sort();

package/dist/lead.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { basename, dirname, join, relative, sep } from 'node:path';
 import { audit, gateWaiting, nextUp, planCommits, workByLot } from './audit.js';
 import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readPlanConfig } from './config.js';
@@ -7,7 +7,7 @@ import { localRepoNotes } from './local-task.js';
 import { gitRoot, repoStatus } from './git.js';
 import { linkCommits } from './link.js';
 import { commitCount, lastActivity, lockStatus } from './session.js';
-import { parse } from 'yaml';
+import { isObject, readYamlFile, readYamlKey } from './yaml-keys.js';
 import { isOpen, RafError } from './plan.js';
 import { isRecurring } from './recurring.js';
 import { priorityRank, readPriority } from './orchestrate/continue.js';
@@ -20,16 +20,7 @@ import { KEPT_TITLE, keptLine, keptTrees } from './orchestrate/worktree.js';
 /** 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 undefined;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const l = raw?.lead;
+    const l = readYamlKey(file, 'lead');
     if (l == null)
         return undefined;
     if (typeof l !== 'object' || Array.isArray(l))
@@ -52,8 +43,8 @@ export function findLeadDir(start) {
         const file = join(dir, 'cadence.yaml');
         if (existsSync(file)) {
             try {
-                const raw = parse(readFileSync(file, 'utf8'));
-                if (raw && typeof raw === 'object' && ('lead' in raw || 'priority' in raw))
+                const raw = readYamlFile(file);
+                if (isObject(raw) && ('lead' in raw || 'priority' in raw))
                     return dir;
             }
             catch {
@@ -79,16 +70,7 @@ export function readLeadContextThreshold(parent) {
 /** 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;
+    const d = readYamlKey(file, 'depth');
     if (d == null)
         return 1;
     if (typeof d !== 'number' || !Number.isInteger(d) || d < 1)

package/dist/lot-lines.js

@@ -0,0 +1,51 @@
+import { gateProgress, gateText } from './audit.js';
+/** Les lignes de tête de `raf show` : titre, état détaillé (L463), objectif, dates, dépendances, drapeaux, champs d'extension (L464), acquittement docs et condition de tirage. Une ligne par fait posé, aucune pour un fait absent. */
+export function lotLines(plan, lot) {
+    const lines = [...headLines(lot), ...flagLines(lot)];
+    if (lot.docsOk)
+        lines.push(`docs-ok : ${lot.docsOk.date} — ${lot.docsOk.reason}`);
+    const gate = gateProgress(plan.lots(), lot);
+    if (lot.gate && gate)
+        lines.push(lot.gate.invalid ? `gate : ${gateText(gate)}` : `gate : ${gate.n} lots ${gate.label} faits`);
+    return lines;
+}
+function headLines(lot) {
+    const lines = [`${lot.id}  ${lot.status}  ${lot.title}`];
+    if (lot.state)
+        lines.push(`état : ${lot.state}`);
+    if (lot.goal)
+        lines.push(`goal : ${lot.goal}`);
+    const dates = [['créé', lot.created], ['démarré', lot.started], [lot.status === 'dropped' ? 'abandonné' : 'terminé', lot.finished]].filter(([, d]) => d);
+    if (dates.length)
+        lines.push(dates.map(([k, d]) => `${k} : ${d}`).join('  '));
+    if (lot.after.length)
+        lines.push(`after : ${lot.after.join(', ')}`);
+    if (lot.public)
+        lines.push(`public : ${lot.public}`);
+    return lines;
+}
+function flagLines(lot) {
+    const lines = [];
+    // L439 : le livreur lit ici si le lot est visible et s'il porte un verdict UX ; deux lignes stables, absentes d'un lot non visible.
+    if (lot.visible)
+        lines.push('visible : oui');
+    if (lot.screen)
+        lines.push(`screen : ${lot.screen}`);
+    if (lot.visible)
+        lines.push(lot.ux ? `ux : ${lot.ux.verdict}` : 'ux : absent');
+    if (lot.spec)
+        lines.push('spec : true');
+    if (lot.uses)
+        lines.push(`uses : ${lot.uses.join(', ')}`);
+    for (const [name, value] of Object.entries(lot.extras ?? {}))
+        lines.push(`${name} : ${value}`);
+    return lines;
+}
+/**
+ * Le lot tel que `raf list --json` l'exporte (L464) : les clés du fichier du plan (`docs_ok`, `state_before`, pas `docsOk` ni `stateBefore`), sans `problems` (diagnostic de `raf check`).
+ * Les noms exportés sont ceux que garantit docs/stabilite.md : renommer un champ du type interne `Lot` ne les change pas.
+ */
+export function lotJson(lot) {
+    const { docsOk, stateBefore, problems: _problems, ...rest } = lot;
+    return { ...rest, ...(docsOk ? { docs_ok: docsOk } : {}), ...(stateBefore ? { state_before: stateBefore } : {}) };
+}