@sylad/cadence 0.2.0

package/dist/news.js

@@ -0,0 +1,200 @@
+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 { RafError } from './plan.js';
+const CAPTURE = /^[\w./-]+\.(?:png|jpe?g|webp|gif)$/i;
+const FRONT = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+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: [] };
+    const m = FRONT.exec(text.replace(/^\uFEFF/, '')); // BOM des éditeurs Windows
+    if (!m) {
+        entry.problems.push('en-tête YAML absent (--- … ---)');
+        return entry;
+    }
+    let head;
+    try {
+        head = (parse(m[1]) ?? {});
+    }
+    catch (e) {
+        entry.problems.push(`en-tête YAML illisible : ${e.message.split('\n')[0]}`);
+        return entry;
+    }
+    entry.title = String(head.title ?? '').trim();
+    entry.date = String(head.date ?? '');
+    entry.lots = list(head.lots);
+    entry.captures = list(head.captures);
+    if (head.nocapture != null && String(head.nocapture).trim())
+        entry.nocapture = String(head.nocapture).trim();
+    entry.body = m[2].trim();
+    for (const c of entry.captures) {
+        // Copiées telles quelles sous le dossier de build : un chemin qui sort du dossier écrirait ailleurs.
+        if (isAbsolute(c) || c.split(/[\\/]/).includes('..'))
+            entry.problems.push(`capture hors du dossier des Nouveautés : ${c}`);
+        // Noms sages : utilisables tels quels dans une URL, et seulement des images.
+        else if (!CAPTURE.test(c))
+            entry.problems.push(`capture ${c} : image .png, .jpg, .webp ou .gif, nom en lettres, chiffres, « . _ - / »`);
+    }
+    if (!entry.title)
+        entry.problems.push('title vide');
+    if (!isDay(entry.date))
+        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) {
+    if (!existsSync(dir))
+        return [];
+    return 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)));
+}
+export function newsIssues(lots, entries, dir) {
+    const issues = [];
+    const ids = new Set(lots.map((l) => l.id));
+    const covered = new Set(entries.flatMap((e) => e.lots));
+    for (const e of entries) {
+        for (const p of e.problems)
+            issues.push({ kind: 'bad-entry', message: `${e.file} : ${p}` });
+        for (const id of e.lots)
+            if (!ids.has(id))
+                issues.push({ kind: 'unknown-lot', message: `${e.file} cite ${id}, absent du plan` });
+        for (const c of e.captures) {
+            const path = resolve(dir, c);
+            if (!existsSync(path) || !statSync(path).isFile())
+                issues.push({ kind: 'missing-capture', message: `${e.file} : capture absente ${c}` });
+        }
+        if (e.problems.length === 0 && e.captures.length === 0 && !e.nocapture) {
+            issues.push({ kind: 'no-capture', message: `${e.file} sans capture (ou « nocapture: raison »)` });
+        }
+    }
+    for (const l of lots) {
+        if (l.visible && l.status === 'done' && !covered.has(l.id)) {
+            issues.push({ kind: 'visible-without-entry', message: `${l.id} est visible et terminé sans entrée Nouveautés — cadence news new ${l.id}` });
+        }
+    }
+    return issues;
+}
+export function slugify(title) {
+    return (title
+        .normalize('NFD')
+        .replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .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) {
+    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`);
+    return path;
+}
+function escapeText(s) {
+    return s.replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[c]);
+}
+/** Liens http(s), mailto ou relatifs ; tout autre schéma (javascript:, data:…) reste du texte. */
+// Les navigateurs retirent les caractères de contrôle en tête d'URL (« \x01javascript: ») : refusés d'office.
+const safeUrl = (url) => !/[\x00-\x20\x7f]/.test(url) && (/^(?:https?:\/\/|mailto:)/i.test(url) || !/^[a-z][\w+.-]*:/i.test(url));
+function inline(text) {
+    // Segments impairs = code : ni gras ni lien à l'intérieur.
+    return text
+        .split('`')
+        .map((seg, i, all) => {
+        if (i % 2 === 1 && i < all.length - 1)
+            return `<code>${escapeText(seg)}</code>`;
+        const raw = i % 2 === 1 ? `\`${seg}` : seg;
+        return escapeText(raw)
+            .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+            .replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (all, label, url) => safeUrl(url) ? `<a href="${url}">${label}</a>` : all);
+    })
+        .join('');
+}
+/** Markdown minimal : paragraphes, listes « - », **gras**, `code`, [liens](url). Tout le reste est du texte échappé. */
+export function renderMarkdown(md) {
+    return md
+        .replace(/\r\n/g, '\n')
+        .split(/\n\s*\n/)
+        .map((block) => block.trim())
+        .filter(Boolean)
+        .map((block) => {
+        const lines = block.split('\n');
+        if (lines.every((l) => /^\s*[-*] /.test(l))) {
+            return `<ul>${lines.map((l) => `<li>${inline(l.replace(/^\s*[-*] /, ''))}</li>`).join('')}</ul>`;
+        }
+        return `<p>${inline(block)}</p>`;
+    })
+        .join('\n');
+}
+export function newsData(project, entries, generated) {
+    return {
+        project,
+        generated,
+        entries: entries.map((e) => ({ slug: e.slug, title: e.title, date: e.date, lots: e.lots, captures: e.captures, html: renderMarkdown(e.body) })),
+    };
+}
+/** Écrit nouveautes.json, index.html et copie les captures sous `out`. */
+export function buildNews(data, dir, out) {
+    mkdirSync(out, { recursive: true });
+    const written = [];
+    for (const c of new Set(data.entries.flatMap((e) => e.captures))) {
+        const dest = resolve(out, c);
+        mkdirSync(dirname(dest), { recursive: true });
+        copyFileSync(resolve(dir, c), dest);
+    }
+    const json = join(out, 'nouveautes.json');
+    writeFileSync(json, `${JSON.stringify(data, null, 2)}\n`);
+    written.push(json);
+    const html = join(out, 'index.html');
+    writeFileSync(html, renderNewsPage(data));
+    written.push(html);
+    return written;
+}
+function renderNewsPage(data) {
+    const title = escapeText(`${data.project} — nouveautés`);
+    const entries = data.entries
+        .map((e) => `<article id="${escapeText(e.slug)}">
+  <h2>${escapeText(e.title)}</h2>
+  <p class="meta"><time datetime="${e.date}">${e.date}</time> · ${e.lots.map(escapeText).join(', ')}</p>
+  ${e.html}
+  ${e.captures.map((c) => `<a href="${escapeText(c)}"><img src="${escapeText(c)}" alt="Capture : ${escapeText(e.title)}" loading="lazy"></a>`).join('\n  ')}
+</article>`)
+        .join('\n');
+    return `<!doctype html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>${STYLE}</style>
+</head>
+<body>
+<header><h1>${title}</h1><p class="meta">Généré le ${escapeText(data.generated)} par cadence</p></header>
+<main>
+${entries || '<p class="meta">Aucune entrée pour l\'instant.</p>'}
+</main>
+</body>
+</html>
+`;
+}
+const STYLE = `
+:root { --bg:#fff; --fg:#1b1f24; --muted:#636c76; --grid:#e3e6ea; --link:#0969da; }
+@media (prefers-color-scheme: dark) { :root { --bg:#0d1117; --fg:#e6edf3; --muted:#8d96a0; --grid:#262c36; --link:#4493f8; } }
+* { box-sizing: border-box; }
+body { margin:0; font:15px/1.55 system-ui, sans-serif; background:var(--bg); color:var(--fg); }
+header, main { max-width: 820px; margin: 0 auto; padding: 16px 24px; }
+h1 { margin:0 0 4px; font-size:22px; }
+h2 { margin:0 0 2px; font-size:18px; }
+.meta { margin:0 0 8px; color:var(--muted); font-size:13px; }
+article { padding: 18px 0; border-bottom: 1px solid var(--grid); }
+a { color: var(--link); }
+img { display:block; max-width:100%; margin-top:10px; border:1px solid var(--grid); border-radius:6px; }
+code { font-size: 13px; padding: 1px 4px; border-radius: 4px; background: var(--grid); }
+`;

package/dist/plan.js

@@ -0,0 +1,255 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { isMap, isSeq, parseDocument } from 'yaml';
+import { isDay, toDay } from './dates.js';
+export const STATUSES = ['todo', 'doing', 'done', 'dropped'];
+export class RafError extends Error {
+}
+export function isOpen(status) {
+    return status === 'todo' || status === 'doing';
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Matches `L3` or `L3/t1` as whole words. Group 1 = lot id, group 2 = task id. */
+export function refPattern(prefix) {
+    return new RegExp(`(?<![\\w/])(${escapeRe(prefix)}\\d+)(?:/(t\\d+))?(?![\\w])`, '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.
+# Un commit appartient à un lot quand son message cite l'identifiant (${prefix}3, ${prefix}3/t1).
+version: 1
+project: ${JSON.stringify(project)}
+prefix: ${prefix}
+since: ${since}       # raf check ignore les commits antérieurs à l'adoption
+lots: []
+`;
+}
+export class Plan {
+    path;
+    doc;
+    indentSeq;
+    constructor(path, doc, 
+    /** false quand le fichier écrit à la main met les « - » en colonne de la clé parente. */
+    indentSeq) {
+        this.path = path;
+        this.doc = doc;
+        this.indentSeq = indentSeq;
+    }
+    static create(path, project, prefix = 'L', since) {
+        if (existsSync(path))
+            throw new RafError(`${path} existe déjà`);
+        if (!/^[A-Za-z][A-Za-z_-]*$/.test(prefix))
+            throw new RafError(`préfixe invalide : ${prefix} (lettres uniquement)`);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, initialContent(project, prefix, since ?? toDay(new Date())));
+        return Plan.load(path);
+    }
+    static load(path) {
+        if (!existsSync(path))
+            throw new RafError(`pas de plan à ${path} — lancer « raf init »`);
+        const text = readFileSync(path, 'utf8');
+        const doc = parseDocument(text);
+        if (doc.errors.length > 0)
+            throw new RafError(`${path} : ${doc.errors[0].message}`);
+        if (!isMap(doc.contents))
+            throw new RafError(`${path} : la racine doit être un objet`);
+        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));
+    }
+    save() {
+        writeFileSync(this.path, this.doc.toString({ lineWidth: 0, indentSeq: this.indentSeq }));
+    }
+    get project() {
+        return String(this.doc.get('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');
+        return v == null ? undefined : String(v);
+    }
+    /** Date d'activation de la revue UX obligatoire des lots visibles ; absente = règle inactive. */
+    get uxSince() {
+        const v = this.doc.get('uxSince');
+        return v == null ? undefined : String(v);
+    }
+    /** Active la revue UX ; false si elle l'était déjà. */
+    enableUx(today) {
+        if (this.uxSince)
+            return false;
+        this.doc.set('uxSince', 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 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) {
+        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 });
+        node.flow = true;
+        this.lotNode(lotId).set('ux', node);
+    }
+    lots() {
+        const raw = this.doc.get('lots').toJSON();
+        return raw.map(normalizeLot);
+    }
+    lot(id) {
+        const found = this.lots().find((l) => l.id === id);
+        if (!found)
+            throw new RafError(`lot inconnu : ${id}`);
+        return found;
+    }
+    lotNode(id) {
+        const seq = this.doc.get('lots');
+        const node = seq.items.find((n) => isMap(n) && String(n.get('id')) === id);
+        if (!node)
+            throw new RafError(`lot inconnu : ${id}`);
+        return node;
+    }
+    taskNode(lotId, taskId) {
+        const tasks = this.lotNode(lotId).get('tasks');
+        const node = isSeq(tasks) ? tasks.items.find((n) => isMap(n) && String(n.get('id')) === taskId) : undefined;
+        if (!node)
+            throw new RafError(`sous-tâche inconnue : ${lotId}/${taskId}`);
+        return node;
+    }
+    add(title, today, opts = {}) {
+        const known = new Set(this.lots().map((l) => l.id));
+        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 entry = { id, title, status: 'todo', estimate: opts.estimate ?? 1 };
+        if (opts.quickwin)
+            entry.quickwin = true;
+        if (opts.visible)
+            entry.visible = true;
+        if (opts.after?.length)
+            entry.after = opts.after;
+        entry.created = today;
+        const node = this.doc.createNode(entry);
+        const after = node.get('after');
+        if (isSeq(after))
+            after.flow = true;
+        this.doc.get('lots').add(node);
+        return id;
+    }
+    addTask(lotId, title) {
+        const lot = this.lotNode(lotId);
+        let tasks = lot.get('tasks');
+        if (!isSeq(tasks)) {
+            tasks = this.doc.createNode([]);
+            lot.set('tasks', tasks);
+        }
+        const seq = tasks;
+        const max = Math.max(0, ...seq.items.map((n) => Number(/^t(\d+)$/.exec(String(n.get('id')))?.[1] ?? 0)));
+        const id = `t${max + 1}`;
+        const node = this.doc.createNode({ id, title, status: 'todo' });
+        node.flow = true;
+        seq.add(node);
+        return `${lotId}/${id}`;
+    }
+    /** `ref` is `L3` or `L3/t1`. */
+    setStatus(ref, status, today, opts = {}) {
+        const [lotId, taskId] = ref.split('/');
+        if (taskId) {
+            const task = this.taskNode(lotId, taskId);
+            if (String(task.get('status')) === status)
+                throw new RafError(`${ref} est déjà ${status}`);
+            task.set('status', status);
+            return;
+        }
+        const lot = this.lot(lotId);
+        const node = this.lotNode(lotId);
+        if (lot.status === status)
+            throw new RafError(`${lotId} est déjà ${status}`);
+        if (!isOpen(lot.status)) {
+            throw new RafError(`${lotId} est ${lot.status} ; le rouvrir à la main dans le YAML si c'est voulu`);
+        }
+        if (status === 'done') {
+            const open = lot.tasks.filter((t) => isOpen(t.status)).map((t) => `${lotId}/${t.id}`);
+            if (open.length > 0 && !opts.force) {
+                throw new RafError(`sous-tâches encore ouvertes : ${open.join(', ')} (--force pour passer outre)`);
+            }
+            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)`);
+            }
+        }
+        node.set('status', status);
+        if (!lot.started && status !== 'dropped')
+            node.set('started', today);
+        if (status === 'done' || status === 'dropped')
+            node.set('finished', today);
+    }
+    note(ref, text, today) {
+        const [lotId, taskId] = ref.split('/');
+        const lot = this.lotNode(lotId);
+        if (taskId)
+            this.taskNode(lotId, taskId);
+        let notes = lot.get('notes');
+        if (!isSeq(notes)) {
+            notes = this.doc.createNode([]);
+            lot.set('notes', notes);
+        }
+        const entry = this.doc.createNode({ date: today, text: ref === lotId ? text : `[${ref}] ${text}` });
+        entry.flow = true;
+        notes.add(entry);
+    }
+}
+function normalizeLot(raw) {
+    const status = STATUSES.includes(raw.status) ? raw.status : 'todo';
+    const problems = [];
+    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)];
+    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,
+        after,
+        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',
+            }))
+            : [],
+        ...(raw.ux && typeof raw.ux === 'object'
+            ? { ux: { date: String(raw.ux.date ?? ''), verdict: String(raw.ux.verdict ?? '') } }
+            : {}),
+        problems,
+    };
+}

package/dist/schedule.js

@@ -0,0 +1,55 @@
+import { endAfterWorkdays, maxDay, workdayAt, workdaysThrough } from './dates.js';
+/**
+ * One lane of work: finished lots use their real dates, lots in progress run to
+ * max(estimate, today), lots to do follow in file order after their dependencies.
+ */
+export function schedule(lots, commitsByLot, today) {
+    const bars = new Map();
+    const firstCommit = (id) => commitsByLot.get(id)?.at(-1)?.day;
+    const lastCommit = (id) => commitsByLot.get(id)?.[0]?.day;
+    const count = (id) => commitsByLot.get(id)?.length ?? 0;
+    for (const lot of lots) {
+        if (lot.status === 'done' || lot.status === 'dropped') {
+            const start = lot.started ?? firstCommit(lot.id) ?? lot.finished ?? lastCommit(lot.id);
+            if (!start)
+                continue;
+            const end = maxDay(start, lot.finished ?? lastCommit(lot.id) ?? start);
+            bars.set(lot.id, { lot, start, end, projected: false, commits: count(lot.id) });
+        }
+        else if (lot.status === 'doing') {
+            const start = lot.started ?? firstCommit(lot.id) ?? today;
+            const end = maxDay(endAfterWorkdays(start, lot.estimate), today);
+            bars.set(lot.id, { lot, start, end, projected: true, commits: count(lot.id) });
+        }
+    }
+    // Les lots à faire se placent en jours ouvrés fractionnaires : deux lots d'une
+    // demi-journée partagent la même journée. Position 0 = premier jour ouvré à partir d'aujourd'hui.
+    const endPos = new Map();
+    // Une seule file : la suite commence après les lots en cours.
+    let cursor = Math.max(0, ...[...bars.values()].filter((b) => b.lot.status === 'doing').map((b) => workdaysThrough(today, b.end)));
+    let pending = lots.filter((l) => l.status === 'todo');
+    while (pending.length > 0) {
+        const ready = (l) => l.after.every((d) => bars.has(d) || !lots.some((x) => x.id === d && x.status === 'todo'));
+        // Premier lot prêt dans l'ordre du fichier ; en cas de cycle, le premier tout court.
+        const lot = pending.find(ready) ?? pending[0];
+        pending = pending.filter((l) => l !== lot);
+        let startPos = cursor;
+        for (const d of lot.after) {
+            const dep = bars.get(d);
+            if (!dep || dep.lot.status === 'dropped')
+                continue;
+            startPos = Math.max(startPos, endPos.get(d) ?? workdaysThrough(today, dep.end));
+        }
+        const end = startPos + lot.estimate;
+        endPos.set(lot.id, end);
+        bars.set(lot.id, {
+            lot,
+            start: workdayAt(today, Math.floor(startPos)),
+            end: workdayAt(today, Math.max(Math.floor(startPos), Math.ceil(end) - 1)),
+            projected: true,
+            commits: count(lot.id),
+        });
+        cursor = end;
+    }
+    return lots.flatMap((l) => bars.get(l.id) ?? []);
+}

package/dist/session.js

@@ -0,0 +1,108 @@
+import { audit, exemptPlanOnly, nextUp } from './audit.js';
+import { diffDays, maxDay } from './dates.js';
+import { readCommits, repoStatus } from './git.js';
+import { linkCommits } from './link.js';
+import { lockAlive, readLock, readNext } from './state.js';
+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);
+}
+function byLotLines(linked) {
+    return [...linked.byLot].map(([id, cs]) => {
+        const subjects = cs.slice(0, 3).map((c) => c.subject).join(' ; ');
+        return `${id} — ${cs.length} commit(s) : ${subjects}${cs.length > 3 ? ' ; …' : ''}`;
+    });
+}
+/** Ligne de livraison en cours ; `live` faux quand le verrou appartient à un processus mort. */
+function lockStatus(state) {
+    const lock = readLock(state);
+    if (!lock)
+        return null;
+    if (lockAlive(lock))
+        return { line: `Livraison en cours : ${lock.sha.slice(0, 7)} (pid ${lock.pid}, depuis ${lock.started})`, live: true };
+    return { line: `Verrou de livraison périmé (pid ${lock.pid} mort, sha ${lock.sha.slice(0, 7)}) : cadence deliver le retirera`, live: false };
+}
+function repoLine(root) {
+    const s = repoStatus(root);
+    const bits = [s.branch ? `branche ${s.branch}` : 'HEAD détachée'];
+    if (s.dirty)
+        bits.push(`${s.dirty} fichier(s) modifié(s)`);
+    if (s.untracked)
+        bits.push(`${s.untracked} non suivi(s)`);
+    if (!s.upstream)
+        bits.push('pas de branche amont');
+    else if (s.ahead)
+        bits.push(`${s.ahead} commit(s) non poussé(s) vers ${s.upstream}`);
+    else
+        bits.push(`à jour avec ${s.upstream}`);
+    return { line: bits.join(', '), open: (s.dirty ? 1 : 0) + (s.ahead ? 1 : 0) };
+}
+function section(out, title, lines) {
+    if (lines.length === 0)
+        return;
+    out(`\n${title}`);
+    for (const l of lines)
+        out(`  ${l}`);
+}
+/** Dernière activité d'un lot : dernier commit, dernière note ou démarrage. */
+function lastActivity(lot, commits) {
+    const days = [commits[0]?.day, lot.started, ...lot.notes.map((n) => n.date)].filter((d) => !!d);
+    return days.length ? days.reduce(maxDay) : undefined;
+}
+export function sessionStart(ctx, opts) {
+    const { plan, out, today } = ctx;
+    const lots = plan.lots();
+    const all = linkCommits(lots, readCommits(ctx.root), plan.prefix);
+    out(`${plan.project} — reprise du ${today}`);
+    const next = readNext(ctx.state);
+    if (next)
+        section(out, `Notes de la dernière clôture (${next.date})`, next.lines.map((l) => `- ${l}`));
+    const lock = lockStatus(ctx.shared);
+    if (lock)
+        out(`\n${lock.line}`);
+    const { doing, ready } = nextUp(lots);
+    out('\nEn cours');
+    if (doing.length === 0)
+        out('  (rien)');
+    for (const l of doing) {
+        const last = lastActivity(l, all.byLot.get(l.id) ?? []);
+        const idle = last ? diffDays(last, today) : 0;
+        const state = last ? `dernière activité ${last}${idle > opts.idle ? `, silencieux depuis ${idle} j` : ''}` : 'aucune activité';
+        out(`  ${l.id}  ${l.title}  (${state})`);
+    }
+    const recent = period(ctx, opts.since);
+    const done = byLotLines(recent);
+    if (recent.orphans.length)
+        done.push(`${recent.orphans.length} commit(s) sans lot`);
+    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]);
+    const proposals = [
+        ...doing.map((l) => ({ l, why: 'en cours' })),
+        ...ready.map((l) => ({ l, why: l.quickwin ? 'gain rapide prêt' : 'prêt' })),
+    ].slice(0, 3);
+    section(out, 'Propositions', proposals.map(({ l, why }, i) => `${i + 1}. ${l.quickwin ? '⚡ ' : ''}${l.id}  ${l.title} — ${why}`));
+    return 0;
+}
+export function sessionClose(ctx, opts) {
+    const { plan, out, today } = ctx;
+    out(`${plan.project} — clôture du ${today}`);
+    const recent = period(ctx, opts.since);
+    const commits = byLotLines(recent);
+    if (recent.orphans.length) {
+        commits.push(`${recent.orphans.length} commit(s) sans lot :`, ...recent.orphans.map((c) => `  ${short(c)}`));
+    }
+    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`));
+    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] : [])]);
+    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/dist/skills.js

@@ -0,0 +1,61 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { RafError } from './plan.js';
+/** Skills livrés avec le paquet (à la racine, à côté de dist/ et src/). */
+export const SKILLS_DIR = fileURLToPath(new URL('../skills', import.meta.url));
+/** Agents livrés avec le paquet. */
+export const AGENTS_DIR = fileURLToPath(new URL('../agents', import.meta.url));
+/** Installe chaque skill sous « cadence-<nom> » ; refuse d'écraser une copie modifiée sans force. */
+export function installSkills(src, dest, force, dryRun = false) {
+    const skills = readdirSync(src, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && existsSync(join(src, d.name, 'SKILL.md')))
+        .map((d) => {
+        const name = `cadence-${d.name}`;
+        const text = readFileSync(join(src, d.name, 'SKILL.md'), 'utf8').replace(/^name: .*$/m, `name: ${name}`);
+        const target = join(dest, name, 'SKILL.md');
+        // Un dossier présent sans SKILL.md compte comme une copie différente : ne pas le fusionner.
+        const current = existsSync(target) ? readFileSync(target, 'utf8') : existsSync(join(dest, name)) ? '' : null;
+        return { from: join(src, d.name), name, text, target, current };
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const conflicts = skills.filter((s) => s.current !== null && s.current !== s.text);
+    if (conflicts.length && !force) {
+        throw new RafError(`${conflicts.map((s) => s.name).join(', ')} modifié(s) localement : --force pour écraser`);
+    }
+    if (dryRun)
+        return [];
+    return skills.map((s) => {
+        if (s.current === s.text)
+            return { name: s.name, status: 'unchanged' };
+        cpSync(s.from, join(dest, s.name), { recursive: true });
+        writeFileSync(s.target, s.text);
+        return { name: s.name, status: s.current === null ? 'installed' : 'updated' };
+    });
+}
+/** Installe chaque agent `<nom>.md` sous « cadence-<nom>.md » ; mêmes règles que les skills. */
+export function installAgents(src, dest, force, dryRun = false) {
+    const agents = readdirSync(src)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => {
+        const name = `cadence-${f.slice(0, -3)}`;
+        const text = readFileSync(join(src, f), 'utf8').replace(/^name: .*$/m, `name: ${name}`);
+        const target = join(dest, `${name}.md`);
+        const current = existsSync(target) ? readFileSync(target, 'utf8') : null;
+        return { name, text, target, current };
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const conflicts = agents.filter((a) => a.current !== null && a.current !== a.text);
+    if (conflicts.length && !force) {
+        throw new RafError(`${conflicts.map((a) => a.name).join(', ')} modifié(s) localement : --force pour écraser`);
+    }
+    if (dryRun)
+        return [];
+    return agents.map((a) => {
+        if (a.current === a.text)
+            return { name: a.name, status: 'unchanged' };
+        mkdirSync(dest, { recursive: true });
+        writeFileSync(a.target, a.text);
+        return { name: a.name, status: a.current === null ? 'installed' : 'updated' };
+    });
+}