@sylad/cadence 1.40.0 → 1.42.1

package/dist/plan.js

@@ -3,8 +3,13 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync } from 'node
 import { dirname, join, relative, resolve } from 'node:path';
 import { dirtyContents } from './git.js';
 import { Document, isMap, isSeq, parseDocument } from 'yaml';
-import { isDay, toDay } from './dates.js';
-import { ARCHIVE_DIR, archiveFiles, archiveLots, archiveYear, mergeArchived, newArchiveDoc, readArchiveDoc, selectArchivable } from './archive.js';
+import { toDay } from './dates.js';
+import { normalizeLot } from './plan-read.js';
+import { currentState, defaultState, rebase, stateProblems, transitionProblem } from './plan-states.js';
+import { DOCS_OK_FILE, readDocsOkFile } from './docs-ok-file.js';
+import { checkedExtras, withExtras } from './plan-extras.js';
+import { DOTTED, escapeRe, extractRefs, idRefs, pickId } from './plan-ids.js';
+import { ARCHIVE_DIR, PLACE_KEY, archiveFiles, archiveLots, archiveYear, mergeArchived, newArchiveDoc, readArchiveDoc, reopenArchived, selectArchivable } from './archive.js';
 /** Délai de la commande `plan.onWrite` : une republication du plan, pas un build. */
 const ON_WRITE_TIMEOUT_MS = 120_000;
 /**
@@ -24,7 +29,6 @@ export function setPlanNotice(fn) {
     notice = fn;
 }
 export const STATUSES = ['todo', 'doing', 'done', 'dropped'];
-const GATE_INVALID = 'gate invalide : count: entier ≥ 1 et un critère spec: true ou screen: page attendus';
 export class RafError extends Error {
 }
 /** Un nom de ressource partagée (L251) : un mot de lettres minuscules, chiffres, « - » et « _ ». */
@@ -39,28 +43,13 @@ function cleanUses(names) {
     return [...new Set(names)];
 }
 const trueFlags = (flags) => Object.fromEntries(Object.entries(flags).filter(([, on]) => on).map(([k]) => [k, true])); // les drapeaux vrais, chacun à `true` : les absents et les faux ne s'écrivent pas
+export { escapeRe, extractRefs, readIdPattern } from './plan-ids.js';
 export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'screen', 'spec', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'repos', 'parent', 'gate', 'goal'];
 /** Nature de l'écran d'un lot visible : nouvelle page, nouveau composant, parcours modifié. */
 export const SCREENS = ['page', 'component', 'journey'];
 export function isOpen(status) {
     return status === 'todo' || status === 'doing';
 }
-export function escapeRe(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Ce qui ne peut pas suivre un identifiant cité : un point suivi d'un caractère de mot — « L1.4 » n'est
- * pas le lot L1, « NC2.4 » n'est pas NC2 — alors que le point qui finit une phrase (« voir L1. ») passe.
- * Même garde pour le format de raf et pour les identifiants d'un plan en lecture seule.
- */
-const DOTTED = '\\.\\w';
-/** Matches `L3` or `L3/t1` as whole words. Group 1 = lot id, group 2 = task id. */
-function refPattern(prefix) {
-    return new RegExp(`(?<![\\w/])(${escapeRe(prefix)}\\d+)(?:/(t\\d+))?(?!\\w|${DOTTED})`, 'g');
-}
-export function extractRefs(text, prefix) {
-    return [...text.matchAll(refPattern(prefix))].map((m) => ({ lot: m[1], task: m[2] }));
-}
 function initialContent(project, prefix, since) {
     return `# Plan « reste à faire » tenu par raf (https://github.com/Sylad/cadence).
 # Édité par le CLI, mais les modifications à la main et les commentaires sont préservés.
@@ -302,7 +291,7 @@ export class Plan {
      */
     refs = (text) => {
         if (!this.settings.format)
-            return extractRefs(text, this.prefix);
+            return this.settings.idPattern === undefined ? extractRefs(text, this.prefix) : idRefs(text, this.prefix, this.settings.idPattern);
         const { refs, tasks, ids } = this.read();
         if (!refs)
             return [];
@@ -391,7 +380,15 @@ export class Plan {
         }
         // L396 : l'archive est un détail de stockage — les lots archivés reprennent leur place parmi ceux du fichier actif, comme un seul plan.
         const archived = this.loadArchives().flatMap((a) => archiveLots(a.doc).toJSON());
-        return mergeArchived(archived.map((r) => normalizeLot(r)), this.activeRaw().map((r) => normalizeLot(r)));
+        const read = (r) => withExtras(normalizeLot(r), r, this.settings.extras);
+        const places = new Map(archived.flatMap((r) => (typeof r[PLACE_KEY] === 'string' || r[PLACE_KEY] === null ? [[String(r.id), r[PLACE_KEY] ?? '']] : [])));
+        const lots = mergeArchived(archived.map(read), this.activeRaw().map(read), places);
+        const model = this.settings.states;
+        return model ? lots.map((l) => ({ ...l, problems: [...l.problems, ...stateProblems(model, l)] })) : lots;
+    }
+    /** Les états détaillés déclarés (`plan.states`), ou undefined. */
+    get stateModel() {
+        return this.settings.states;
     }
     lot(id) {
         const found = this.lots().find((l) => l.id === id);
@@ -462,20 +459,11 @@ export class Plan {
     }
     /**
      * Un lot archivé qui n'est plus clos (`raf todo` sur un lot done archivé) revient à la fin du fichier du plan à l'écriture :
-     * l'archive ne porte que des lots done ou dropped, et le plan actif reste le seul fichier à porter du travail ouvert.
+     * l'archive ne porte que des lots done ou dropped, et le plan actif reste le seul fichier à porter du travail ouvert. Seul lui bouge :
+     * les lots archivés dont le `place:` le nommait (L536) sont re-pointés sur le lot qui le précédait, et gardent leur place dans le plan présenté.
      */
     reopened() {
-        const active = this.doc.get('lots');
-        for (const a of this.archives ?? []) {
-            const seq = archiveLots(a.doc);
-            const back = seq.items.filter((n) => isMap(n) && !['done', 'dropped'].includes(String(n.get('status'))));
-            if (back.length === 0)
-                continue;
-            seq.items = seq.items.filter((n) => !back.includes(n));
-            for (const n of back)
-                active.add(n);
-            a.dirty = true;
-        }
+        reopenArchived(this.archives ?? [], this.doc.get('lots'), () => this.lots().map((l) => l.id));
     }
     /**
      * `raf archive` : déplace les lots done et dropped du fichier du plan (terminés avant `before` s'il est donné) vers le fichier de leur année
@@ -496,8 +484,13 @@ export class Plan {
         // De quoi revenir en arrière en mémoire : les items du plan, ceux de chaque archive déjà chargée, et le nombre d'archives (les nouvelles s'ajoutent à la fin).
         const archives = this.loadArchives();
         const snapshot = { items: [...seq.items], archives: archives.map((a) => ({ a, items: [...archiveLots(a.doc).items], dirty: a.dirty })) };
+        // Sous plan.idPattern, le nombre final d'un id ne dit rien de l'ordre : chaque lot archivé garde le lot qui le précède dans le plan
+        // PRÉSENTÉ (archivés compris, ordre d'avant ce passage), pas dans le fichier seul — deux passages successifs gardent ainsi l'ordre du plan.
+        const merged = this.settings.idPattern === undefined ? [] : this.lots().map((l) => l.id);
         for (const n of nodes) {
             const lot = move.find((l) => l.id === String(n.get('id')));
+            if (this.settings.idPattern !== undefined)
+                n.set(PLACE_KEY, merged[merged.indexOf(lot.id) - 1] ?? '');
             const target = this.archiveFor(archiveYear(lot, today));
             archiveLots(target.doc).add(n);
             target.dirty = true;
@@ -553,14 +546,18 @@ export class Plan {
         for (const dep of opts.after ?? [])
             if (!known.has(dep))
                 throw new RafError(`dépendance inconnue : ${dep}`);
-        const re = new RegExp(`^${escapeRe(this.prefix)}(\\d+)$`);
-        const max = Math.max(0, ...[...known].map((id) => Number(re.exec(id)?.[1] ?? 0)));
-        const id = `${this.prefix}${max + 1}`;
+        const picked = pickId(this.prefix, opts.id, opts.under, this.settings.idPattern, known);
+        if ('problem' in picked)
+            throw new RafError(picked.problem);
+        const { id } = picked;
         const pub = opts.public === undefined ? undefined : cleanPublic(opts.public);
         if (opts.every !== undefined && !(Number.isInteger(opts.every) && opts.every > 0)) {
             throw new RafError(`périodicité invalide : ${opts.every} (un nombre entier de jours, 1 au moins)`);
         }
+        const extras = checkedExtras(this.settings.extras, opts.extras);
         const entry = { id, title };
+        if (opts.under !== undefined)
+            entry.parent = opts.under;
         if (pub !== undefined)
             entry.public = pub;
         Object.assign(entry, { status: 'todo', estimate: opts.estimate ?? 1 }, trueFlags({ quickwin: opts.quickwin, visible: opts.visible }));
@@ -573,6 +570,7 @@ export class Plan {
             entry.after = opts.after;
         if (opts.uses?.length)
             entry.uses = cleanUses(opts.uses);
+        Object.assign(entry, extras);
         entry.created = today;
         const node = this.doc.createNode(entry);
         for (const key of ['after', 'uses']) {
@@ -583,6 +581,15 @@ export class Plan {
         this.doc.get('lots').add(node);
         return id;
     }
+    /** Remplace l'estimation (en jours) d'un lot de tout statut, archivé compris ; jamais sur une sous-tâche. */
+    setEstimate(ref, days) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`l'estimation se pose sur un lot, pas une sous-tâche : ${ref}`);
+        if (!(Number.isFinite(days) && days > 0))
+            throw new RafError(`estimation invalide : ${days} (un nombre de jours > 0)`);
+        this.lotNode(ref).set('estimate', days);
+    }
     /** Déclare les dépôts voisins d'un lot (clé `repos:`) : un chemin seul, ou `{ path, cite }` quand le voisin est partagé. */
     setRepos(lotId, repos) {
         this.writable();
@@ -720,6 +727,11 @@ export class Plan {
         if (!isOpen(lot.status)) {
             throw new RafError(`${lotId} est ${lot.status} ; le rouvrir si c'est voulu : raf todo ${lotId}`);
         }
+        const model = this.settings.states;
+        const target = model ? defaultState(model, status) : undefined;
+        const refused = model && target !== undefined && !opts.force ? transitionProblem(model, currentState(model, lot), target) : null;
+        if (refused)
+            throw new RafError(`${lotId} : ${refused} — raf status ${lotId} <état> (--force pour passer outre)`);
         if (status === 'done') {
             const open = lot.tasks.filter((t) => isOpen(t.status)).map((t) => `${lotId}/${t.id}`);
             if (open.length > 0 && !opts.force) {
@@ -738,6 +750,7 @@ export class Plan {
             }
         }
         node.set('status', status);
+        this.syncState(node, status);
         if (!lot.started && status !== 'dropped')
             node.set('started', today);
         if (status === 'done' || status === 'dropped')
@@ -760,6 +773,7 @@ export class Plan {
         if (lot.status === 'done' || lot.status === 'dropped') {
             const node = this.lotNode(ref);
             node.set('status', 'todo');
+            this.syncState(node, 'todo');
             node.delete('finished');
             this.note(ref, reason.trim() ? `rouvert (était ${lot.status}) : ${reason.trim()}` : `rouvert (était ${lot.status})`, today);
             return;
@@ -769,9 +783,78 @@ export class Plan {
             throw new RafError(`${ref} a ${n} commit(s) qui le citent : le remettre en attente perdrait leur lien — raf drop ou le laisser doing`);
         const node = this.lotNode(ref);
         node.set('status', 'todo');
+        this.syncState(node, 'todo');
         node.delete('started');
         this.note(ref, reason.trim() ? `remis en attente : ${reason.trim()}` : 'remis en attente', today);
     }
+    /**
+     * Pose le `state:` d'un lot (`raf status`, L463) sous la garde de `plan.transitions`, et note le message daté. Le statut de base en est
+     * dérivé : seuls todo → doing (le lot démarre) et doing → todo (`started:` retiré ; refusé dès qu'un commit cite le lot, la porte de
+     * `raf todo`) se font ici, pour que l'état bloqué se quitte vers l'état d'avant quel que soit son statut de base ; les autres changements
+     * de base gardent leur commande et leurs portes (`raf done`, `drop`, `todo`). Entrer dans l'état bloqué mémorise l'état d'avant
+     * (`state_before:`), `back` y revient sans garde de transition. `commits` compte les commits qui citent le lot (lu seulement pour doing → todo).
+     */
+    setState(ref, target, today, opts = {}, commits = () => 0) {
+        this.writable();
+        const model = this.settings.states;
+        if (!model)
+            throw new RafError('aucun état déclaré : cadence.yaml plan.states');
+        if (ref.includes('/'))
+            throw new RafError(`raf status se pose sur un lot, pas une sous-tâche : ${ref}`);
+        const lot = this.lot(ref);
+        const from = currentState(model, lot);
+        let to = target ?? '';
+        if (opts.back) {
+            if (!model.blocked)
+                throw new RafError('aucun état bloqué déclaré : cadence.yaml plan.blockedState');
+            if (from !== model.blocked)
+                throw new RafError(`${ref} n'est pas bloqué (état ${from})`);
+            if (!lot.stateBefore)
+                throw new RafError(`${ref} : état d'avant introuvable (state_before: absent) — raf status ${ref} <état>`);
+            if (!Object.hasOwn(model.states, lot.stateBefore))
+                throw new RafError(`${ref} : l'état d'avant « ${lot.stateBefore} » n'est plus déclaré — raf status ${ref} <état>`);
+            to = lot.stateBefore;
+        }
+        else {
+            if (!Object.hasOwn(model.states, to))
+                throw new RafError(`état inconnu : ${to} (déclarés : ${Object.keys(model.states).join(', ')})`);
+            if (to === from)
+                throw new RafError(`${ref} est déjà ${to}`);
+            const refused = transitionProblem(model, from, to);
+            if (refused)
+                throw new RafError(`${ref} : ${refused}`);
+        }
+        const node = this.lotNode(ref);
+        const base = model.states[to];
+        if (base !== lot.status) {
+            const refused = rebase(node, lot, { ref, to, base }, today, commits);
+            if (refused)
+                throw new RafError(refused);
+        }
+        this.writeState(node, to, to === model.blocked ? from : undefined);
+        const message = opts.message?.trim();
+        if (message)
+            this.note(ref, `état ${to} : ${message}`, today);
+        return to;
+    }
+    /** Met l'état d'un lot au diapason de son nouveau statut de base (`start`, `done`, `drop`, `todo`) ; sans `plan.states`, ne touche à rien. */
+    syncState(node, status) {
+        if (this.settings.states)
+            this.writeState(node, defaultState(this.settings.states, status));
+    }
+    /** Écrit `state:` (et `state_before:`) juste après `status:` ; `undefined` retire la clé. */
+    writeState(node, state, before) {
+        for (const [key, value] of [['state', state], ['state_before', before]]) {
+            if (value === undefined)
+                node.delete(key);
+            else if (node.has(key))
+                node.set(key, value);
+            else {
+                const keys = node.items.map((p) => String(p.key?.value ?? p.key));
+                node.items.splice(Math.max(keys.indexOf('status'), keys.indexOf('state')) + 1, 0, this.doc.createPair(key, value));
+            }
+        }
+    }
     /** Remplace le titre d'un lot, de tout statut, et note l'ancien titre ; refuse un titre vide ou identique. */
     setTitle(ref, text, today) {
         this.writable();
@@ -902,28 +985,6 @@ export class Plan {
     }
 }
 /** Lit une liste écrite dans un autre format : champs traduits, entrées à parent repliées en sous-tâches. */
-/** Fichier d'acquittement docs-ok d'un plan en lecture seule, relatif à la racine du dépôt (L386). */
-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. */
-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;
-}
 function foreignLots(raw, format) {
     const entries = raw.map((r, i) => {
         if (!r || typeof r !== 'object' || Array.isArray(r))
@@ -993,25 +1054,6 @@ function foreignLots(raw, format) {
     }
     return lots;
 }
-/** Lit `gate: { count: N, spec: true }` ou `{ count: N, screen: page }` ; toute autre forme est un problème du lot et une condition jamais remplie. */
-function readGate(raw, problems) {
-    if (raw == null)
-        return undefined;
-    const invalid = () => {
-        problems.push(GATE_INVALID);
-        return { invalid: true };
-    };
-    if (typeof raw !== 'object' || Array.isArray(raw))
-        return invalid();
-    const g = raw;
-    if (!Number.isInteger(g.count) || g.count < 1)
-        return invalid();
-    const criteria = [...(g.spec === true ? ['spec'] : []), ...(g.screen === 'page' ? ['screen'] : [])];
-    const others = Object.keys(g).filter((k) => k !== 'count' && k !== 'spec' && k !== 'screen');
-    if (criteria.length !== 1 || others.length || ('spec' in g && g.spec !== true) || ('screen' in g && g.screen !== 'page'))
-        return invalid();
-    return { count: g.count, criterion: criteria[0] };
-}
 /** Un titre public vide ne dirait rien au public : refusé plutôt qu'écrit. */
 function cleanPublic(text) {
     const t = text.trim();
@@ -1019,116 +1061,3 @@ function cleanPublic(text) {
         throw new RafError('titre public vide — raf public <id> "titre" (ou --clear pour l\'effacer)');
     return t;
 }
-function normalizeLot(raw, problems = []) {
-    const status = STATUSES.includes(raw.status) ? raw.status : 'todo';
-    const asDay = (field) => {
-        const v = raw[field];
-        if (v == null)
-            return undefined;
-        if (isDay(v))
-            return v;
-        problems.push(`${field} « ${String(v)} » n'est pas une date AAAA-MM-JJ`);
-        return undefined;
-    };
-    const after = raw.after == null ? [] : Array.isArray(raw.after) ? raw.after.map(String) : [String(raw.after)];
-    const last = asDay('last');
-    let uses;
-    if (raw.uses != null) {
-        if (Array.isArray(raw.uses) && raw.uses.every((n) => typeof n === 'string' && RESOURCE_NAME.test(n)))
-            uses = [...new Set(raw.uses)];
-        else
-            problems.push(`uses ${RESOURCES_BAD_LIST}`);
-    }
-    let screen;
-    if (raw.screen != null) {
-        if (SCREENS.includes(raw.screen))
-            screen = raw.screen;
-        else
-            problems.push(`screen « ${String(raw.screen)} » inconnu (${SCREENS.join(', ')})`);
-        if (screen && raw.visible !== true)
-            problems.push(`screen « ${screen} » sans visible : un écran est un changement visible`);
-    }
-    let spec;
-    if (raw.spec != null) {
-        if (raw.spec === true)
-            spec = true;
-        else if (raw.spec !== false)
-            problems.push(`spec : true ou false attendu (reçu « ${String(raw.spec)} »)`);
-    }
-    const gate = readGate(raw.gate, problems);
-    const okRaw = raw.docs_ok;
-    const docsOk = okRaw && typeof okRaw === 'object' && typeof okRaw.reason === 'string' && okRaw.reason.trim() !== '' ? { date: String(okRaw.date ?? ''), reason: okRaw.reason.trim() } : undefined;
-    return {
-        id: String(raw.id),
-        title: String(raw.title ?? ''),
-        status,
-        estimate: typeof raw.estimate === 'number' && raw.estimate > 0 ? raw.estimate : 1,
-        quickwin: raw.quickwin === true,
-        visible: raw.visible === true,
-        ...(screen ? { screen } : {}),
-        ...(spec ? { spec } : {}), ...(raw.local === true ? { local: true } : {}),
-        ...(gate ? { gate } : {}),
-        ...(typeof raw.public === 'string' && raw.public.trim() !== '' ? { public: raw.public.trim() } : {}),
-        ...(typeof raw.goal === 'string' && raw.goal.trim() !== '' ? { goal: raw.goal.trim() } : {}),
-        ...(Number.isInteger(raw.every) && raw.every > 0 ? { every: raw.every } : {}),
-        ...(last ? { last } : {}),
-        after,
-        ...(uses?.length ? { uses } : {}),
-        created: asDay('created'),
-        started: asDay('started'),
-        finished: asDay('finished'),
-        notes: Array.isArray(raw.notes)
-            ? raw.notes.map((n) => ({ date: String(n.date ?? ''), text: String(n.text ?? '') }))
-            : [],
-        tasks: Array.isArray(raw.tasks)
-            ? raw.tasks.map((t) => ({
-                id: String(t.id),
-                title: String(t.title ?? ''),
-                status: STATUSES.includes(t.status) ? t.status : 'todo',
-            }))
-            : [],
-        ...(repoList(raw.repos).length ? { repos: repoList(raw.repos) } : {}),
-        ...(asVerdict(raw.ux) ? { ux: asVerdict(raw.ux) } : {}),
-        ...(asVerdict(raw.review) ? { review: asVerdict(raw.review) } : {}),
-        ...(docsOk ? { docsOk } : {}),
-        problems,
-    };
-}
-/**
- * Dépôts voisins déclarés : une chaîne (le chemin) ou un objet `{ path, cite }`, seuls ou en liste (une valeur seule vaut une
- * liste d'un dépôt). Une entrée sans chemin textuel est écartée ; un `cite` vide ou non textuel vaut pas de `cite`.
- */
-function repoList(raw) {
-    const items = Array.isArray(raw) ? raw : raw == null ? [] : [raw];
-    const out = [];
-    for (const item of items) {
-        const path = typeof item === 'string' ? item : item && typeof item === 'object' && typeof item.path === 'string' ? item.path : '';
-        if (path.trim() === '')
-            continue;
-        const cite = item && typeof item === 'object' ? item.cite : undefined;
-        out.push({ path: path.trim(), ...(typeof cite === 'string' && cite.trim() !== '' ? { cite: cite.trim() } : {}) });
-    }
-    return out;
-}
-function asVerdict(raw) {
-    if (!raw || typeof raw !== 'object')
-        return undefined;
-    const v = raw;
-    // Écrit à la main sans verdict (clé absente, vide ou blanche) : rien n'a été dit de la revue, la porte
-    // reste fermée — comme `raf ux` et `raf review` refusent d'enregistrer un verdict vide.
-    if (String(v.verdict ?? '').trim() === '')
-        return undefined;
-    const verdict = { date: String(v.date ?? ''), verdict: String(v.verdict) };
-    // Champ présent mais vide : relu « jusqu'à rien », comme un verdict noté sans commit.
-    if ('commit' in v)
-        verdict.commit = v.commit == null || String(v.commit).trim() === '' ? null : String(v.commit).trim();
-    if (v.repos && typeof v.repos === 'object' && !Array.isArray(v.repos)) {
-        const repos = Object.entries(v.repos).map(([k, sha]) => [k, sha == null || String(sha).trim() === '' ? null : String(sha).trim()]);
-        if (repos.length)
-            verdict.repos = Object.fromEntries(repos);
-    }
-    const r = v.reporte;
-    if (r && typeof r === 'object' && !Array.isArray(r) && r.de != null && r.vers != null)
-        verdict.reporte = { de: String(r.de), vers: String(r.vers), patchId: String(r.patchId ?? '') };
-    return verdict;
-}

package/dist/raf-close-checks.js

@@ -0,0 +1,25 @@
+import { readOrchestrateConfig } from './config.js';
+import { gitRoot } from './git.js';
+import { redAcceptations } from './orchestrate/accept.js';
+import { RafError } from './plan.js';
+/**
+ * Un lot clos avec une acceptation à vert: false bloque les vagues suivantes du dépôt (verrou des tests d'acceptation, L366) :
+ * `raf done` le refuse, ou avec `--force` n'en fait qu'un avertissement sur `warn`.
+ */
+export function refuseRedAcceptation(root, configPath, lotId, force, warn) {
+    const repo = gitRoot(root) ?? root;
+    let dir = null;
+    try {
+        dir = readOrchestrateConfig(configPath).spec.dir;
+    }
+    catch {
+        // un cadence.yaml illisible ne doit pas empêcher de clore un lot : `cadence check` en parle
+    }
+    const red = dir === null ? undefined : redAcceptations(repo, dir).find((a) => a.lot === lotId);
+    if (!red)
+        return;
+    const text = `${lotId} : ${red.path} est à vert: false — clos ainsi, le lot bloquerait les vagues suivantes du dépôt (verrou des tests d'acceptation) ; cadence spec green ${lotId} lance la commande d'acceptation et pose vert: true`;
+    if (!force)
+        throw new RafError(`${text} (--force pour passer outre)`);
+    warn(`avertissement : ${text}`);
+}

package/dist/raf-status.js

@@ -0,0 +1,28 @@
+import { RafError } from './plan.js';
+import { currentState } from './plan-states.js';
+/** Une ligne par état déclaré : son statut de base, le nombre de lots qui y sont et, si `plan.transitions` est déclaré, les états permis ensuite. */
+function listStates(plan, out) {
+    const model = plan.stateModel;
+    if (!model)
+        throw new RafError('aucun état déclaré : cadence.yaml plan.states');
+    const lots = plan.lots();
+    for (const [name, base] of Object.entries(model.states)) {
+        const next = model.transitions ? `  → ${model.transitions[name]?.join(', ') || '(terminal)'}` : '';
+        out(`${name}  ${base}  ${lots.filter((l) => currentState(model, l) === name).length} lot(s)${next}`);
+    }
+}
+/** `raf status` (L463) : sans argument la liste des états ; `<id> <état> ["message"]` ou `<id> --back ["message"]` pose l'état d'un lot. */
+export function statusCommand(plan, rest, ctx) {
+    const { back, today, out } = ctx;
+    if (rest.length === 0 && !back) {
+        listStates(plan, out);
+        return 0;
+    }
+    const first = back ? 1 : 2;
+    if (rest.length < first)
+        throw new RafError('usage : raf status <id> <état> ["message"] | raf status <id> --back ["message"]');
+    const state = plan.setState(rest[0], back ? null : rest[1], today, { back, message: rest.slice(first).join(' ') }, () => ctx.commits(plan, rest[0]));
+    plan.save();
+    out(`${rest[0]} → ${state}`);
+    return 0;
+}

package/dist/ref/command.js

@@ -1,10 +1,9 @@
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { RafError } from '../plan.js';
 import { AGENTS_DIR } from '../skills.js';
-import { realClaude, readAgents } from '../orchestrate/launch.js';
+import { claudeConfigDir, realClaude, readAgents } from '../orchestrate/launch.js';
 import { add } from './add.js';
 import { analyse } from './analyse.js';
 import { checkInventaire, readInventaire, summaryInventaire } from './check.js';
@@ -33,7 +32,7 @@ export function refCommand(rest, values, root, io) {
     }
     if (verb === 'analyse' && args.length === 1) {
         const claude = realClaude(io.env.CADENCE_CLAUDE_BIN || 'claude', io.env);
-        return analyse({ document: args[0], slug: values.slug, sections: values.sections, model: values.model, modelB: values['model-b'], double: values.double === true, seuil: values.seuil, env: io.env, cwd: io.cwd, refsDir, configPath, claudeHome: io.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), now: io.now(), out: io.out, err: io.err, claude, agents: readAgents(AGENTS_DIR) });
+        return analyse({ document: args[0], slug: values.slug, sections: values.sections, model: values.model, modelB: values['model-b'], double: values.double === true, seuil: values.seuil, env: io.env, cwd: io.cwd, refsDir, configPath, claudeHome: claudeConfigDir(io.env), now: io.now(), out: io.out, err: io.err, claude, agents: readAgents(AGENTS_DIR) });
     }
     if (verb === 'measure' && args.length === 3) {
         measure({ slug: args[0], page: args[1], zone: args[2], quoi: values.quoi, largeur: values.largeur, env: io.env, refsDir, json: values.json === true, out: io.out });

package/dist/resources.js

@@ -1,6 +1,6 @@
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { parse } from 'yaml';
+import { readYamlFile } from './yaml-keys.js';
 import { isOpen, RafError, RESOURCE_NAME, RESOURCES_BAD_LIST } from './plan.js';
 /**
  * Clé `resources:` du cadence.yaml le plus proche en remontant depuis le dossier parent de `root` : le premier fichier qui porte la clé
@@ -12,13 +12,7 @@ export function readResources(root) {
     for (let dir = dirname(root);; dir = dirname(dir)) {
         const file = join(dir, 'cadence.yaml');
         if (existsSync(file) && statSync(file).isFile()) {
-            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 != null && typeof raw === 'object' && Object.hasOwn(raw, 'resources')) {
                 const list = raw.resources ?? [];
                 if (!Array.isArray(list) || !list.every((n) => typeof n === 'string' && RESOURCE_NAME.test(n)))

package/dist/state.js

@@ -52,7 +52,11 @@ export function writeSessionMark(dir, mark) {
 export function lockPath(dir) {
     return join(dir, 'deliver.lock');
 }
-function readLockFile(file) {
+/**
+ * Lit un fichier de verrou : null s'il est absent ou illisible du système de fichiers ; sinon son contenu mis en forme par `fromRaw` et l'âge du fichier,
+ * ou `broken` (marqué `unreadable`) quand ce n'est pas du JSON. Commun au verrou de livraison et à celui de l'orchestration.
+ */
+export function readLockJson(file, fromRaw, broken) {
     let text;
     let ageMs;
     try {
@@ -63,13 +67,13 @@ function readLockFile(file) {
         return null;
     }
     try {
-        const raw = JSON.parse(text);
-        return { pid: Number(raw.pid), sha: String(raw.sha), started: String(raw.started), ageMs };
+        return { ...fromRaw(JSON.parse(text)), ageMs };
     }
     catch {
-        return { pid: 0, sha: '?', started: '?', unreadable: true, ageMs };
+        return { ...broken, unreadable: true, ageMs };
     }
 }
+const readLockFile = (file) => readLockJson(file, (raw) => ({ pid: Number(raw.pid), sha: String(raw.sha), started: String(raw.started) }), { pid: 0, sha: '?', started: '?' });
 export function readLock(dir) {
     return readLockFile(lockPath(dir));
 }
@@ -203,6 +207,29 @@ export function appendFailedDelivery(dir, day, sha, reason, cls, tail = []) {
     const head = `${day} ${sha} ${cls ? `[${cls}] ` : ''}${clean(reason.split('\n')[0], REASON_MAX)}`;
     appendFileSync(join(dir, 'deliveries-failed.log'), `${[head, ...kept].join(TAIL_SEP)}\n`);
 }
+/**
+ * `cadence verify` vert au sha de la DERNIÈRE livraison rouge (L435) : l'effet est bien là, la livraison est donc
+ * faite — une ligne « jour sha » rejoint `deliveries.log`, ce qui efface la ligne rouge du panneau (le journal vert
+ * modifié après le rouge la remplace) sans relivrer. Rien n'est écrit quand la dernière livraison rouge est celle
+ * d'un autre sha (elle resterait cachée), quand elle n'est pas de classe « vérification » (une CI rouge, un refus ou
+ * un déploiement raté ne se lavent pas : les vérifications ne lisent pas toujours le sha), quand il n'y en a pas, ou quand le journal vert est déjà postérieur au
+ * rouge (les dates de modification des fichiers décident, comme au panneau). Retourne si une ligne a été écrite.
+ */
+export function recordVerifiedDelivery(dir, day, sha) {
+    const last = readFailedEntries(dir).at(-1);
+    if (!last || last.sha !== sha || last.cls !== 'verification')
+        return false;
+    try {
+        const green = join(dir, 'deliveries.log');
+        if (existsSync(green) && statSync(green).mtimeMs > statSync(join(dir, 'deliveries-failed.log')).mtimeMs)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    appendDelivery(dir, day, sha);
+    return true;
+}
 export function lastDelivery(dir) {
     const file = join(dir, 'deliveries.log');
     if (!existsSync(file))
@@ -259,7 +286,3 @@ export function readFailedEntries(dir) {
         return [];
     }
 }
-/** Les jours de `deliveries-failed.log` (une ligne par livraison rouge), dans l'ordre du fichier. */
-export function readFailedDeliveries(dir) {
-    return readFailedEntries(dir).map((e) => e.day);
-}