@sylad/cadence 0.2.0 → 0.5.0

package/dist/git.js

@@ -1,7 +1,8 @@
 import { execFileSync } from 'node:child_process';
 import { basename, dirname, resolve } from 'node:path';
 function git(cwd, args) {
-    return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    // Le journal complet d'un gros dépôt dépasse le Mo par défaut : sans marge, il serait lu comme vide.
+    return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 1024 * 1024 * 1024 });
 }
 export function gitRoot(cwd) {
     try {
@@ -60,6 +61,10 @@ function tryGit(cwd, args) {
 export function headSha(cwd) {
     return tryGit(cwd, ['rev-parse', '--verify', '-q', 'HEAD']);
 }
+/** Sha complet du commit que désigne `rev` (sha abrégé, branche, tag), null s'il n'existe pas. */
+export function resolveCommit(cwd, rev) {
+    return tryGit(cwd, ['rev-parse', '--verify', '-q', `${rev}^{commit}`]);
+}
 export function repoStatus(cwd) {
     const lines = git(cwd, ['status', '--porcelain']).split('\n').filter(Boolean);
     const untracked = lines.filter((l) => l.startsWith('??')).length;
@@ -89,3 +94,31 @@ export function gitCommonDir(cwd) {
 export function isAncestor(cwd, a, b) {
     return tryGit(cwd, ['merge-base', '--is-ancestor', a, b]) !== null;
 }
+/**
+ * Instant (ms), date d'auteur (conservée par rebase, amend, cherry-pick), du commit qui a ajouté chaque fichier
+ * de `dir` SOUS CE NOM (--no-renames : un renommage compte comme un ajout, l'historique antérieur n'est pas suivi),
+ * clé = chemin relatif à `dir`.
+ * Vide hors d'un dépôt git ; un fichier jamais commité en est absent.
+ */
+export function addedTimes(dir) {
+    const times = new Map();
+    let out;
+    try {
+        // quotepath=off + -z : noms accentués tels quels, sans guillemets ni échappement octal.
+        out = git(dir, ['-c', 'core.quotepath=off', 'log', '-z', '--diff-filter=A', '--no-renames', '--relative', '--name-only', `--format=${RECORD}%aI`, '--', '.']);
+    }
+    catch {
+        return times;
+    }
+    // Enregistrement = RECORD date \0 \n nom \0 nom \0 … ; le plus ancien ajout l'emporte.
+    for (const record of out.split(RECORD).filter(Boolean)) {
+        const [stamp, ...files] = record.split('\0');
+        const t = Date.parse(stamp);
+        for (const [i, f] of files.entries()) {
+            const name = i === 0 ? f.replace(/^\n/, '') : f;
+            if (name)
+                times.set(name, Math.min(t, times.get(name) ?? Infinity));
+        }
+    }
+    return times;
+}

package/dist/link.js

@@ -1,15 +1,15 @@
-import { extractRefs } from './plan.js';
 export function isMerge(c) {
     return /^Merge\b/.test(c.subject);
 }
-export function linkCommits(lots, commits, prefix) {
+/** `refs` lit les références d'un message : `plan.refs`. */
+export function linkCommits(lots, commits, refsOf) {
     const ids = new Set(lots.map((l) => l.id));
     const tasks = new Set(lots.flatMap((l) => l.tasks.map((t) => `${l.id}/${t.id}`)));
     const byLot = new Map();
     const orphans = [];
     const unknown = [];
     for (const c of commits) {
-        const refs = extractRefs(`${c.subject}\n${c.body}`, prefix);
+        const refs = refsOf(`${c.subject}\n${c.body}`);
         if (refs.length === 0) {
             if (!isMerge(c))
                 orphans.push(c);

package/dist/news.js

@@ -1,10 +1,20 @@
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { parse, stringify } from 'yaml';
-import { isDay } from './dates.js';
+import { isDay, toStamp } from './dates.js';
+import { addedTimes } from './git.js';
 import { RafError } from './plan.js';
+const CREATED_EMPTY = 'created vide — cadence news stamp';
+const CREATED = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:Z|[+-]\d{2}:\d{2})?$/;
+const OFFSET = /(?:Z|[+-]\d{2}:\d{2})$/;
 const CAPTURE = /^[\w./-]+\.(?:png|jpe?g|webp|gif)$/i;
 const FRONT = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/** Bien formée ET réelle : Date.parse accepte le 30 février (et rend NaN pour 25:70). */
+function validStamp(s) {
+    const [y, mo, d, h, mi, sec = 0] = s.match(/\d+/g).slice(0, 6).map(Number);
+    const day = new Date(Date.UTC(y, mo - 1, d));
+    return (!Number.isNaN(Date.parse(s.replace(' ', 'T'))) && day.getUTCMonth() === mo - 1 && day.getUTCDate() === d && h < 24 && mi < 60 && sec < 60);
+}
 const list = (v) => (v == null ? [] : Array.isArray(v) ? v.map(String) : [String(v)]);
 export function parseEntry(file, text) {
     const entry = { file, slug: basename(file).replace(/\.md$/, ''), title: '', date: '', lots: [], captures: [], body: '', problems: [] };
@@ -23,6 +33,20 @@ export function parseEntry(file, text) {
     }
     entry.title = String(head.title ?? '').trim();
     entry.date = String(head.date ?? '');
+    if ('created' in head) {
+        const created = String(head.created ?? '').trim();
+        if (!created)
+            entry.problems.push(CREATED_EMPTY);
+        else if (!CREATED.test(created))
+            entry.problems.push(`created « ${created} » n'est pas une heure AAAA-MM-JJTHH:MM±hh:mm`);
+        // Sans fuseau, l'heure serait lue dans celui de la machine : l'ordre changerait entre le poste et la CI.
+        else if (!OFFSET.test(created))
+            entry.problems.push(`created « ${created} » sans fuseau : ajouter ±hh:mm ou Z`);
+        else if (!validStamp(created))
+            entry.problems.push(`created « ${created} » n'est pas une heure valide`);
+        else
+            entry.created = created.replace(' ', 'T');
+    }
     entry.lots = list(head.lots);
     entry.captures = list(head.captures);
     if (head.nocapture != null && String(head.nocapture).trim())
@@ -42,14 +66,29 @@ export function parseEntry(file, text) {
         entry.problems.push(`date « ${entry.date} » n'est pas une date AAAA-MM-JJ`);
     return entry;
 }
-/** Entrées du dossier, plus récentes d'abord (à date égale, par nom de fichier décroissant). */
-export function loadEntries(dir) {
+/**
+ * Entrées du dossier, plus récentes d'abord : par date, puis à date égale par instant de création
+ * (`created` de l'en-tête, sinon date d'auteur du commit qui a ajouté le fichier sous ce nom — un renommage
+ * compte comme un ajout — ; pas encore commité = le plus récent), puis par nom de fichier décroissant.
+ * `added` (historique git) n'est appelé que si une entrée n'a pas de `created`.
+ */
+export function loadEntries(dir, added = () => addedTimes(dir)) {
     if (!existsSync(dir))
         return [];
-    return readdirSync(dir, { withFileTypes: true })
+    const entries = readdirSync(dir, { withFileTypes: true })
         .filter((f) => f.isFile() && f.name.endsWith('.md') && f.name.toLowerCase() !== 'readme.md')
-        .map((f) => parseEntry(f.name, readFileSync(join(dir, f.name), 'utf8')))
-        .sort((a, b) => (a.date === b.date ? b.file.localeCompare(a.file) : b.date.localeCompare(a.date)));
+        .map((f) => parseEntry(f.name, readFileSync(join(dir, f.name), 'utf8')));
+    const history = entries.some((e) => !e.created) ? added() : new Map();
+    const created = (e) => (e.created ? Date.parse(e.created) : history.get(e.file) ?? Infinity);
+    return entries.sort((a, b) => {
+        if (a.date !== b.date)
+            return b.date.localeCompare(a.date);
+        const ta = created(a);
+        const tb = created(b);
+        if (ta !== tb)
+            return ta < tb ? 1 : -1;
+        return b.file.localeCompare(a.file);
+    });
 }
 export function newsIssues(lots, entries, dir) {
     const issues = [];
@@ -66,6 +105,9 @@ export function newsIssues(lots, entries, dir) {
             if (!existsSync(path) || !statSync(path).isFile())
                 issues.push({ kind: 'missing-capture', message: `${e.file} : capture absente ${c}` });
         }
+        if (e.problems.length === 0 && !e.created) {
+            issues.push({ kind: 'no-time', message: `${e.file} sans heure de création (created: AAAA-MM-JJTHH:MM±hh:mm) — cadence news stamp` });
+        }
         if (e.problems.length === 0 && e.captures.length === 0 && !e.nocapture) {
             issues.push({ kind: 'no-capture', message: `${e.file} sans capture (ou « nocapture: raison »)` });
         }
@@ -87,16 +129,47 @@ export function slugify(title) {
         .slice(0, 60)
         .replace(/-+$/, '') || 'entree');
 }
-/** Crée le squelette d'une entrée ; refuse d'écraser un fichier existant. */
-export function newEntry(dir, lots, rawTitle, today) {
+/** Crée le squelette d'une entrée, horodatée de `now` ; refuse d'écraser un fichier existant. */
+export function newEntry(dir, lots, rawTitle, today, now) {
     const title = rawTitle.replace(/\s+/g, ' ').trim(); // un saut de ligne casserait l'en-tête
     const path = join(dir, `${today}-${slugify(title)}.md`);
     if (existsSync(path))
         throw new RafError(`${path} existe déjà`);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(path, `---\ntitle: ${stringify(title).trimEnd()}\ndate: ${today}\nlots: [${lots.join(', ')}]\ncaptures: []\n# nocapture: raison, quand une capture n'a pas de sens\n---\nCe qui change pour l'utilisateur.\n`);
+    writeFileSync(path, `---\ntitle: ${stringify(title).trimEnd()}\ndate: ${today}\ncreated: ${toStamp(now)}\nlots: [${lots.join(', ')}]\ncaptures: []\n# nocapture: raison, quand une capture n'a pas de sens\n---\nCe qui change pour l'utilisateur.\n`);
     return path;
 }
+/**
+ * Migration : écrit `created:` dans les entrées lisibles qui n'en ont pas (ou l'ont vide), d'après la date
+ * d'auteur du commit qui a ajouté le fichier sous ce nom — un renommage n'est pas suivi — (`now` s'il n'est pas
+ * encore commité). Le reste du fichier est laissé tel quel.
+ */
+export function stampEntries(dir, now) {
+    let history;
+    const added = () => (history ??= addedTimes(dir)); // un seul git log, et seulement s'il sert
+    const done = [];
+    for (const e of loadEntries(dir, added)) {
+        // Seule une clé created vide est réparée ici ; une heure fausse reste à corriger à la main.
+        if (e.created || !e.problems.every((p) => p === CREATED_EMPTY))
+            continue;
+        const created = toStamp(new Date(added().get(e.file) ?? now.getTime()));
+        const path = join(dir, e.file);
+        const text = readFileSync(path, 'utf8');
+        const lines = text.split('\n');
+        const end = lines.findIndex((l, i) => i > 0 && l.trimEnd() === '---');
+        const key = (name) => lines.findIndex((l, i) => i > 0 && i < end && new RegExp(`^${name}\\s*:`).test(l));
+        const existing = key('created');
+        const dateLine = key('date');
+        const eol = lines[dateLine >= 0 ? dateLine : 0].endsWith('\r') ? '\r' : '';
+        if (existing >= 0)
+            lines[existing] = `created: ${created}${eol}`; // clé vide : remplacée, jamais dupliquée
+        else
+            lines.splice(dateLine >= 0 ? dateLine + 1 : end, 0, `created: ${created}${eol}`);
+        writeFileSync(path, lines.join('\n'));
+        done.push({ file: e.file, created });
+    }
+    return done;
+}
 function escapeText(s) {
     return s.replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[c]);
 }

package/dist/plan.js

@@ -5,6 +5,7 @@ import { isDay, toDay } from './dates.js';
 export const STATUSES = ['todo', 'doing', 'done', 'dropped'];
 export class RafError extends Error {
 }
+export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'after', 'created', 'started', 'finished', 'notes', 'parent'];
 export function isOpen(status) {
     return status === 'todo' || status === 'doing';
 }
@@ -33,12 +34,24 @@ export class Plan {
     path;
     doc;
     indentSeq;
+    settings;
     constructor(path, doc, 
     /** false quand le fichier écrit à la main met les « - » en colonne de la clé parente. */
-    indentSeq) {
+    indentSeq, settings = {}) {
         this.path = path;
         this.doc = doc;
         this.indentSeq = indentSeq;
+        this.settings = settings;
+    }
+    /** Un plan lu dans un autre format ne change pas : sa lecture et le motif de ses références sont gardés. */
+    foreign;
+    get readonly() {
+        return !!this.settings.format;
+    }
+    writable() {
+        if (this.readonly) {
+            throw new RafError(`plan en lecture seule : ${this.path} est tenu par un autre outil (cadence.yaml : plan) — le modifier avec l'outil du projet`);
+        }
     }
     static create(path, project, prefix = 'L', since) {
         if (existsSync(path))
@@ -49,7 +62,7 @@ export class Plan {
         writeFileSync(path, initialContent(project, prefix, since ?? toDay(new Date())));
         return Plan.load(path);
     }
-    static load(path) {
+    static load(path, settings = {}) {
         if (!existsSync(path))
             throw new RafError(`pas de plan à ${path} — lancer « raf init »`);
         const text = readFileSync(path, 'utf8');
@@ -58,27 +71,90 @@ export class Plan {
             throw new RafError(`${path} : ${doc.errors[0].message}`);
         if (!isMap(doc.contents))
             throw new RafError(`${path} : la racine doit être un objet`);
+        if (settings.format) {
+            const key = settings.format.lots;
+            if (!isSeq(doc.get(key)))
+                throw new RafError(`${path} : la clé « ${key} » doit porter la liste des lots (cadence.yaml : plan.lots)`);
+            return new Plan(path, doc, true, settings);
+        }
         const lots = doc.get('lots');
         if (!isSeq(lots))
             doc.set('lots', doc.createNode([]));
         else
             lots.flow = false; // « lots: [] » écrit par init : passer en style bloc
-        return new Plan(path, doc, !/^lots:[^\n]*\n(?:#[^\n]*\n)*- /m.test(text));
+        return new Plan(path, doc, !/^lots:[^\n]*\n(?:#[^\n]*\n)*- /m.test(text), settings);
     }
     save() {
+        this.writable();
         writeFileSync(this.path, this.doc.toString({ lineWidth: 0, indentSeq: this.indentSeq }));
     }
     get project() {
-        return String(this.doc.get('project') ?? '');
+        return String(this.doc.get('project') ?? this.settings.project ?? '');
     }
     get prefix() {
         return String(this.doc.get('prefix') ?? 'L');
     }
     /** Date d'adoption de raf : les commits plus anciens ne sont pas audités. */
     get since() {
-        const v = this.doc.get('since');
+        const v = this.doc.get('since') ?? this.settings.since;
         return v == null ? undefined : String(v);
     }
+    /** Motifs (expressions régulières sur le sujet) des commits automatiques à ne pas auditer. */
+    get ignore() {
+        const raw = this.doc.get('ignore');
+        const own = isSeq(raw) ? raw.toJSON().map(String) : raw == null ? [] : [String(raw)];
+        const list = [...own, ...(this.settings.ignore ?? [])];
+        const patterns = [];
+        const invalid = [];
+        for (const src of list) {
+            try {
+                patterns.push(new RegExp(src));
+            }
+            catch {
+                invalid.push(src);
+            }
+        }
+        return { patterns, invalid };
+    }
+    /** Fichiers tenus avec le plan, relatifs à la racine du dépôt. */
+    get files() {
+        return this.settings.files ?? [];
+    }
+    /**
+     * Références citées par un texte. Format de raf : préfixe et numéro (`L3`, `L3/t1`). Autre format :
+     * les identifiants du plan eux-mêmes, quelle que soit leur forme (`E-A2`, `NC2.4`, `B33/t1-fusion`).
+     */
+    refs = (text) => {
+        if (!this.settings.format)
+            return extractRefs(text, this.prefix);
+        const { refs, tasks, ids } = this.read();
+        if (!refs)
+            return [];
+        return [...text.matchAll(refs)].flatMap((m) => {
+            if (!m[2])
+                return [{ lot: m[1] }];
+            if (tasks.has(`${m[1]}/${m[2]}`))
+                return [{ lot: m[1], task: m[2] }];
+            // « B33/E-A2 » : deux lots séparés par une barre, pas une sous-tâche.
+            return ids.has(m[2]) ? [{ lot: m[1] }, { lot: m[2] }] : [{ lot: m[1] }];
+        });
+    };
+    read() {
+        if (!this.foreign) {
+            const raw = this.doc.get(this.settings.format.lots).toJSON();
+            const lots = foreignLots(raw, this.settings.format);
+            const ids = lots.map((l) => l.id).sort((a, b) => b.length - a.length);
+            this.foreign = {
+                lots,
+                ids: new Set(ids),
+                tasks: new Set(lots.flatMap((l) => l.tasks.map((t) => `${l.id}/${t.id}`))),
+                refs: ids.length
+                    ? new RegExp(`(?<![\\w/.-])(${ids.map(escapeRe).join('|')})(?:/([\\w-]+(?:\\.[\\w-]+)*))?(?![\\w-]|\\.\\w)`, 'g')
+                    : null,
+            };
+        }
+        return this.foreign;
+    }
     /** Date d'activation de la revue UX obligatoire des lots visibles ; absente = règle inactive. */
     get uxSince() {
         const v = this.doc.get('uxSince');
@@ -86,27 +162,53 @@ export class Plan {
     }
     /** Active la revue UX ; false si elle l'était déjà. */
     enableUx(today) {
-        if (this.uxSince)
+        return this.enableGate('uxSince', today);
+    }
+    recordUx(lotId, verdict, today) {
+        this.recordVerdict('ux', 'la revue UX', lotId, { date: today, verdict });
+    }
+    /** Date d'activation de la revue de code obligatoire des lots à commits ; absente = règle inactive. */
+    get reviewSince() {
+        const v = this.doc.get('reviewSince');
+        return v == null ? undefined : String(v);
+    }
+    /** Active la revue de code ; false si elle l'était déjà. */
+    enableReview(today) {
+        return this.enableGate('reviewSince', today);
+    }
+    /** `commit` : sha du dernier commit compté du lot (le plan ne lit pas git), null s'il n'en a aucun. */
+    recordReview(lotId, verdict, today, commit) {
+        this.recordVerdict('review', 'la revue de code', lotId, { date: today, verdict, commit });
+    }
+    enableGate(key, today) {
+        this.writable();
+        if (this[key])
             return false;
-        this.doc.set('uxSince', today);
+        this.doc.set(key, today);
         // Placer la clé avant « lots » pour garder les réglages groupés en tête.
         const map = this.doc.contents;
-        const idx = map.items.findIndex((p) => String(p.key?.value ?? p.key) === 'uxSince');
+        const idx = map.items.findIndex((p) => String(p.key?.value ?? p.key) === key);
         const lotsIdx = map.items.findIndex((p) => String(p.key?.value ?? p.key) === 'lots');
         if (idx > lotsIdx && lotsIdx >= 0)
             map.items.splice(lotsIdx, 0, ...map.items.splice(idx, 1));
         return true;
     }
-    recordUx(lotId, verdict, today) {
+    recordVerdict(key, label, lotId, entry) {
+        this.writable();
         if (lotId.includes('/'))
-            throw new RafError('la revue UX se note sur un lot, pas une sous-tâche');
-        const node = this.doc.createNode({ date: today, verdict });
+            throw new RafError(`${label} se note sur un lot, pas une sous-tâche`);
+        // Un verdict vide ouvrirait la porte sans rien dire de la revue.
+        if (entry.verdict.trim() === '')
+            throw new RafError(`verdict vide : ${label} attend son verdict — raf ${key} ${lotId} "verdict"`);
+        const node = this.doc.createNode(entry);
         node.flow = true;
-        this.lotNode(lotId).set('ux', node);
+        this.lotNode(lotId).set(key, node);
     }
     lots() {
+        if (this.settings.format)
+            return this.read().lots;
         const raw = this.doc.get('lots').toJSON();
-        return raw.map(normalizeLot);
+        return raw.map((r) => normalizeLot(r));
     }
     lot(id) {
         const found = this.lots().find((l) => l.id === id);
@@ -129,6 +231,7 @@ export class Plan {
         return node;
     }
     add(title, today, opts = {}) {
+        this.writable();
         const known = new Set(this.lots().map((l) => l.id));
         for (const dep of opts.after ?? [])
             if (!known.has(dep))
@@ -152,6 +255,7 @@ export class Plan {
         return id;
     }
     addTask(lotId, title) {
+        this.writable();
         const lot = this.lotNode(lotId);
         let tasks = lot.get('tasks');
         if (!isSeq(tasks)) {
@@ -166,8 +270,13 @@ export class Plan {
         seq.add(node);
         return `${lotId}/${id}`;
     }
-    /** `ref` is `L3` or `L3/t1`. */
+    /**
+     * `ref` is `L3` or `L3/t1`. `unreviewed` : nombre de commits du lot que sa revue de code ne couvre
+     * pas (le plan ne lit pas git) — tous sans verdict, ceux postérieurs au commit relu sinon ; sans lui,
+     * la revue de code n'est pas exigée.
+     */
     setStatus(ref, status, today, opts = {}) {
+        this.writable();
         const [lotId, taskId] = ref.split('/');
         if (taskId) {
             const task = this.taskNode(lotId, taskId);
@@ -191,6 +300,11 @@ export class Plan {
             if (this.uxSince && lot.visible && !lot.ux && !opts.force) {
                 throw new RafError(`${lotId} est visible : revue UX attendue avant done — raf ux ${lotId} "verdict" (--force pour passer outre)`);
             }
+            if (this.reviewSince && opts.unreviewed && !opts.force) {
+                throw new RafError(lot.review
+                    ? `${lotId} : la revue de code précède ${opts.unreviewed} commit(s) du lot, elle est à refaire — raf review ${lotId} "verdict" (--force pour passer outre)`
+                    : `${lotId} a ${opts.unreviewed} commit(s) : revue de code attendue avant done — raf review ${lotId} "verdict" (--force pour passer outre)`);
+            }
         }
         node.set('status', status);
         if (!lot.started && status !== 'dropped')
@@ -199,6 +313,7 @@ export class Plan {
             node.set('finished', today);
     }
     note(ref, text, today) {
+        this.writable();
         const [lotId, taskId] = ref.split('/');
         const lot = this.lotNode(lotId);
         if (taskId)
@@ -213,9 +328,69 @@ export class Plan {
         notes.add(entry);
     }
 }
-function normalizeLot(raw) {
+/** Lit une liste écrite dans un autre format : champs traduits, entrées à parent repliées en sous-tâches. */
+function foreignLots(raw, format) {
+    const entries = raw.map((r, i) => {
+        if (!r || typeof r !== 'object' || Array.isArray(r))
+            throw new RafError(`entrée n° ${i + 1} du plan : un objet est attendu`);
+        const pick = (field) => {
+            for (const key of format.fields[field] ?? [field])
+                if (r[key] != null)
+                    return r[key];
+            return undefined;
+        };
+        // Un horodatage vaut pour son jour.
+        const day = (field) => {
+            const v = pick(field);
+            return typeof v === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(v) ? v.slice(0, 10) : v;
+        };
+        const id = pick('id');
+        if ((typeof id !== 'string' && typeof id !== 'number') || String(id).trim() === '') {
+            throw new RafError(`entrée n° ${i + 1} du plan : identifiant absent`);
+        }
+        const problems = [];
+        const theirs = pick('status');
+        const mapped = Object.keys(format.statuses).length > 0;
+        if (mapped && theirs != null && !Object.hasOwn(format.statuses, String(theirs))) {
+            problems.push(`état « ${String(theirs)} » sans correspondance (cadence.yaml : plan.statuses)`);
+        }
+        const effort = pick('estimate');
+        if (typeof effort === 'string' && !(effort in format.estimates)) {
+            problems.push(`effort « ${effort} » sans correspondance (cadence.yaml : plan.estimates)`);
+        }
+        const notes = pick('notes');
+        const lot = normalizeLot({
+            id,
+            title: pick('title'),
+            status: mapped ? (Object.hasOwn(format.statuses, String(theirs)) ? format.statuses[String(theirs)] : undefined) : theirs,
+            estimate: typeof effort === 'string' ? format.estimates[effort] : effort,
+            quickwin: pick('quickwin'),
+            visible: pick('visible'),
+            after: pick('after'),
+            created: day('created'),
+            started: day('started'),
+            finished: day('finished'),
+            notes: typeof notes === 'string' ? [{ text: notes }] : notes,
+        }, problems);
+        const parent = pick('parent');
+        return { lot, parent: parent == null ? undefined : String(parent) };
+    });
+    const top = new Map(entries.filter((e) => !e.parent).map((e) => [e.lot.id, e.lot]));
+    const lots = [];
+    for (const { lot, parent } of entries) {
+        const into = parent ? top.get(parent) : undefined;
+        if (into && lot.id.startsWith(`${into.id}/`)) {
+            into.tasks.push({ id: lot.id.slice(into.id.length + 1), title: lot.title, status: lot.status });
+            into.problems.push(...lot.problems.map((p) => `${lot.id} : ${p}`));
+        }
+        else {
+            lots.push(lot);
+        }
+    }
+    return lots;
+}
+function normalizeLot(raw, problems = []) {
     const status = STATUSES.includes(raw.status) ? raw.status : 'todo';
-    const problems = [];
     const asDay = (field) => {
         const v = raw[field];
         if (v == null)
@@ -247,9 +422,18 @@ function normalizeLot(raw) {
                 status: STATUSES.includes(t.status) ? t.status : 'todo',
             }))
             : [],
-        ...(raw.ux && typeof raw.ux === 'object'
-            ? { ux: { date: String(raw.ux.date ?? ''), verdict: String(raw.ux.verdict ?? '') } }
-            : {}),
+        ...(asVerdict(raw.ux) ? { ux: asVerdict(raw.ux) } : {}),
+        ...(asVerdict(raw.review) ? { review: asVerdict(raw.review) } : {}),
         problems,
     };
 }
+function asVerdict(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const v = raw;
+    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();
+    return verdict;
+}

package/dist/session.js

@@ -1,13 +1,41 @@
-import { audit, exemptPlanOnly, nextUp } from './audit.js';
+import { spawnSync } from 'node:child_process';
+import { audit, exemptPlanOnly, nextUp, planCommits } from './audit.js';
 import { diffDays, maxDay } from './dates.js';
-import { readCommits, repoStatus } from './git.js';
+import { repoStatus } from './git.js';
 import { linkCommits } from './link.js';
 import { lockAlive, readLock, readNext } from './state.js';
+const FACTS_TIMEOUT = 120_000;
+/**
+ * Sortie de la commande du projet, ligne à ligne. Un échec se dit et ne bloque rien : ce sont des
+ * faits en plus, pas une condition de la session.
+ */
+function projectFacts(ctx, since) {
+    if (!ctx.facts)
+        return [];
+    const r = spawnSync('sh', ['-c', ctx.facts], {
+        cwd: ctx.root,
+        env: { ...process.env, CADENCE_SINCE: since, CADENCE_TODAY: ctx.today },
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: FACTS_TIMEOUT,
+        killSignal: 'SIGKILL',
+        maxBuffer: 4 * 1024 * 1024,
+    });
+    const lines = `${r.stdout ?? ''}${r.stderr ?? ''}`.replace(/\s+$/, '').split('\n').filter((l, i, all) => l !== '' || all.length > 1);
+    if (r.error || r.signal)
+        lines.push(`✗ commande interrompue (${r.signal ? `délai de ${FACTS_TIMEOUT / 1000} s dépassé` : r.error.message}) : ${ctx.facts}`);
+    else if (r.status !== 0)
+        lines.push(`✗ commande en échec (code ${r.status})`);
+    return lines;
+}
 const short = (c) => `${c.sha.slice(0, 7)} ${c.subject}`;
 /** Commits de la fenêtre reliés aux lots, sans compter comme « sans lot » ceux qui ne touchent que le plan. */
 function period(ctx, since) {
-    const commits = readCommits(ctx.root, { since });
-    return exemptPlanOnly(linkCommits(ctx.plan.lots(), commits, ctx.plan.prefix), ctx.plan, ctx.root);
+    const commits = planCommits(ctx.plan, ctx.root, { since });
+    const linked = exemptPlanOnly(linkCommits(ctx.plan.lots(), commits, ctx.plan.refs), ctx.plan, ctx.root);
+    // Comme raf check : un commit antérieur à l'adoption du plan n'avait pas à citer de lot.
+    const adopted = ctx.plan.since;
+    return adopted ? { ...linked, orphans: linked.orphans.filter((c) => c.day >= adopted) } : linked;
 }
 function byLotLines(linked) {
     return [...linked.byLot].map(([id, cs]) => {
@@ -54,7 +82,7 @@ function lastActivity(lot, commits) {
 export function sessionStart(ctx, opts) {
     const { plan, out, today } = ctx;
     const lots = plan.lots();
-    const all = linkCommits(lots, readCommits(ctx.root), plan.prefix);
+    const all = linkCommits(lots, planCommits(plan, ctx.root), plan.refs);
     out(`${plan.project} — reprise du ${today}`);
     const next = readNext(ctx.state);
     if (next)
@@ -79,6 +107,7 @@ export function sessionStart(ctx, opts) {
     section(out, `Fait depuis ${opts.since}`, done);
     section(out, 'Écarts (raf check)', audit(plan, ctx.root, ctx.newsDir, today).map((i) => `✗ ${i.message}`));
     section(out, 'Dépôt', [repoLine(ctx.root).line]);
+    section(out, 'Faits propres au projet', projectFacts(ctx, opts.since));
     const proposals = [
         ...doing.map((l) => ({ l, why: 'en cours' })),
         ...ready.map((l) => ({ l, why: l.quickwin ? 'gain rapide prêt' : 'prêt' })),
@@ -96,12 +125,13 @@ export function sessionClose(ctx, opts) {
     }
     section(out, 'Commits de la période', commits.length ? commits : ['(aucun)']);
     const quiet = plan.lots().filter((l) => l.status === 'doing' && !recent.byLot.has(l.id));
-    section(out, 'Lots en cours', quiet.map((l) => `${l.id}  ${l.title} — aucun commit sur la période : raf done ou raf note`));
+    section(out, 'Lots en cours', quiet.map((l) => `${l.id}  ${l.title} — aucun commit sur la période : ${plan.readonly ? "le fermer ou l'annoter avec l'outil du projet" : 'raf done ou raf note'}`));
     const issues = audit(plan, ctx.root, ctx.newsDir, today);
     section(out, 'Écarts (raf check)', issues.map((i) => `✗ ${i.message}`));
     const repo = repoLine(ctx.root);
     const lock = lockStatus(ctx.shared);
     section(out, 'Dépôt', [repo.line, ...(lock ? [lock.line] : [])]);
+    section(out, 'Faits propres au projet', projectFacts(ctx, opts.since));
     const open = issues.length + repo.open + (lock?.live ? 1 : 0);
     out(open === 0 ? '\n✓ prêt à fermer' : `\n✗ pas fermé : ${open} point(s)`);
     return open === 0 ? 0 : 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "description": "A small, repo-native working method: a versioned plan linked to your commits, a changelog with screenshots, session rituals and deliveries proven by their effect.",
   "license": "MIT",
   "author": "Sylvain Ladoire",
@@ -15,7 +15,8 @@
     "build": "tsc -p tsconfig.build.json",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
-    "prepare": "npm run build"
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm test"
   },
   "dependencies": {
     "yaml": "^2.5.0"