@sylad/cadence 0.10.1 → 0.12.0

package/dist/audit.js

@@ -1,9 +1,11 @@
+import { existsSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { check } from './check.js';
 import { parse } from 'yaml';
 import { changedFiles, fileAt, readCommits } from './git.js';
 import { linkCommits } from './link.js';
-import { loadEntries, newsIssues } from './news.js';
+import { readNewsConfig } from './config.js';
+import { loadEntries, newsIssues, PUBLIC_TITLE_DEFAULT, publicTitleTooLong, reusedNewsTitle } from './news.js';
 import { isRecurring } from './recurring.js';
 import { isOpen } from './plan.js';
 /** Chemin de la configuration lue, relatif à la racine : celui de --config, sinon cadence.yaml. */
@@ -49,14 +51,20 @@ export function isPlanOnly(sha, plan, root) {
     const files = changedFiles(root, sha);
     return files.length > 0 && files.every((f) => own.has(f) && (f !== config || onlyPlanKeyChanged(root, sha, f)));
 }
+/** Le commit a été acquitté par « raf ignore » : par son sha, ou par son sujet exact. */
+export function isAcknowledged(plan, c) {
+    return plan.acknowledged.some((a) => (a.sha !== undefined && a.sha === c.sha) || (a.sha === undefined && a.subject === c.subject));
+}
 /**
- * N'ont pas besoin de citer un lot : un commit d'entretien du plan (cf. isPlanOnly) et un commit
- * automatique dont le sujet correspond à un motif `ignore:` du plan.
+ * N'ont pas besoin de citer un lot : un commit d'entretien du plan (cf. isPlanOnly), un commit
+ * automatique dont le sujet correspond à un motif `ignore:` du plan et un commit acquitté (`raf ignore`) ;
+ * un commit acquitté n'est pas non plus signalé pour un identifiant cité inconnu.
  */
 export function exemptPlanOnly(linked, plan, root) {
     const { patterns } = plan.ignore;
-    const orphans = linked.orphans.filter((c) => !patterns.some((re) => re.test(c.subject)) && !isPlanOnly(c.sha, plan, root));
-    return { ...linked, orphans };
+    const acked = (c) => isAcknowledged(plan, c);
+    const orphans = linked.orphans.filter((c) => !patterns.some((re) => re.test(c.subject)) && !acked(c) && !isPlanOnly(c.sha, plan, root));
+    return { ...linked, orphans, unknown: linked.unknown.filter((u) => !acked(u.commit)) };
 }
 /** Fenêtre de l'audit : --since, sinon la date d'adoption du plan, sinon 30 jours. */
 export function auditSince(plan, explicit) {
@@ -65,6 +73,15 @@ export function auditSince(plan, explicit) {
     // Une date seule vaudrait « ce jour-là à l'heure actuelle » pour git : minuit explicite.
     return plan.since ? `${plan.since} 00:00` : '30 days ago';
 }
+/**
+ * Avertissements : un lot visible (hors abandonné) sans titre public — le site retombe sur le titre technique du plan,
+ * sauf pour un lot terminé qu'une Nouveauté cite : le site en reprend le titre (cf. reusedNewsTitle).
+ */
+export function missingPublicTitles(lots, entries) {
+    return lots
+        .filter((l) => l.visible && l.status !== 'dropped' && !l.public && reusedNewsTitle(l, entries) === null)
+        .map((l) => ({ message: `${l.id} : lot visible sans titre public — raf public ${l.id} "…"`, warning: true }));
+}
 /** Écarts entre le plan, l'historique et les Nouveautés — ce que `raf check` affiche. */
 export function audit(plan, root, newsDir, today, opts = {}) {
     const lots = plan.lots();
@@ -82,10 +99,20 @@ export function audit(plan, root, newsDir, today, opts = {}) {
     // Un plan en lecture seule ne reçoit aucun verdict de raf : les deux portes n'y valent pas, même si
     // uxSince ou reviewSince y sont écrits à la main — l'écart ne pourrait jamais être levé.
     const gates = plan.readonly ? [] : [...uxIssues(plan), ...reviewIssues(plan, root, all.byLot)];
-    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, loadEntries(newsDir), newsDir), ...gates,
+    // Un titre public trop long fait échouer le build du site : signalé dès ici, avec 80 caractères sans clé déclarée
+    // — mais seulement si le projet publie des Nouveautés ; sans site, aucune limite ne s'applique.
+    const max = readNewsConfig(plan.configFile ?? join(root, 'cadence.yaml')).publicTitleMax ?? (existsSync(newsDir) ? PUBLIC_TITLE_DEFAULT : Infinity);
+    // Sans public:, le site reprend le titre de la Nouveauté la plus récente du lot terminé (cas ccc L32).
+    const entries = loadEntries(newsDir);
+    const titles = lots.flatMap((l) => {
+        const reused = reusedNewsTitle(l, entries);
+        const m = l.public ? publicTitleTooLong(l.public, max) : reused ? publicTitleTooLong(reused, max) : null;
+        return m ? [{ message: `${l.id} : ${reused && !l.public ? m.replace('titre public', 'titre public repris de la Nouveauté') : m}` }] : [];
+    });
+    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, entries, newsDir), ...titles, ...gates, ...missingPublicTitles(lots, entries),
         ...plan.ignore.invalid.map((src) => ({ message: `ignore : motif invalide « ${src} »` }))];
     // Un plan en lecture seule se corrige avec l'outil du projet : ne pas conseiller une commande raf qui refuserait.
-    return plan.readonly ? issues.map((i) => ({ ...i, message: i.message.replace(/ — raf start .*$/, '') })) : issues;
+    return plan.readonly ? issues.map((i) => ({ ...i, message: i.message.replace(/ — raf (start|public) .*$/, '') })) : issues;
 }
 /** Commits qui portent du travail sur un lot : ni antérieurs à l'adoption du plan, ni réduits au plan. */
 function workCommits(plan, root, commits) {

package/dist/cli.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
-import { readPlanConfig, readSessionConfig } from './config.js';
+import { readNewsConfig, readPlanConfig, readSessionConfig } from './config.js';
 import { audit, exemptPlanOnly, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
@@ -11,7 +11,7 @@ import { ganttData, renderGantt } from './gantt.js';
 import { gitRoot, readCommits, resolveCommit } from './git.js';
 import { installHook } from './hook.js';
 import { citedRefs, linkCommits } from './link.js';
-import { buildNews, loadEntries, newEntry, newsData, newsIssues, stampEntries } from './news.js';
+import { buildNews, loadEntries, newEntry, newsData, newsIssues, publicTitleTooLong, stampEntries } from './news.js';
 import { Plan, RafError, STATUSES } from './plan.js';
 import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
@@ -32,10 +32,12 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf ux <id> "verdict" enregistre la revue d'ergonomie du lot (agent ux-reviewer)
   raf review enable     revue de code obligatoire avant « done » pour les lots qui ont des commits
   raf review <id> "verdict" enregistre la revue de code du lot (agent code-reviewer)
+  raf show <id> [--notes]   le lot : statut, dates, after, titre public, notes datées, commits comptés ; --notes : les notes seules
   raf commits <id>      les commits du lot que compte la porte de revue de code, du plus ancien au plus récent
   raf now               ce qui est en cours, la suite, les derniers terminés
   raf list [--status todo|doing|done|dropped]
   raf check [--since date] [--idle 7]   (défaut : date « since » du plan) code 1 s'il y a des écarts
+  raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot (ou citant un id inconnu) sans réécrire l'historique ; raf check --ignored les liste
   raf gantt [-o docs/plan/gantt.html]
   raf hook install
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom]   une session claude neuve par étape ; --status [vague] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"]
@@ -53,6 +55,16 @@ Un texte qui commence par « - » se passe après « -- » : raf note L1 -- "-5
 Le plan est docs/plan/raf.yaml, ou celui que nomme « plan: » dans cadence.yaml ; un plan tenu par un
 autre outil se lit sans migration (correspondance des champs, voir le README) et reste en lecture seule.
 Options communes : --file chemin (ou RAF_FILE), RAF_TODAY=AAAA-MM-JJ pour figer la date.`;
+/** Ajoute `line` au .gitignore de `root` s'il n'y est pas déjà (avec ou sans `/` initial ou final). Rend vrai si écrit. */
+export function ensureGitignore(root, line) {
+    const file = join(root, '.gitignore');
+    const text = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    const norm = (l) => l.trim().replace(/^\//, '').replace(/\/$/, '');
+    if (text.split('\n').some((l) => norm(l) === norm(line)))
+        return false;
+    writeFileSync(file, `${text}${text === '' || text.endsWith('\n') ? '' : '\n'}${line}\n`);
+    return true;
+}
 export function run(argv, io) {
     try {
         // orchestrate a ses propres options (--status et --resume prennent une valeur facultative, --answer en prend deux).
@@ -106,6 +118,8 @@ function dispatch(argv, io) {
             sha: { type: 'string' },
             retry: { type: 'string' },
             clear: { type: 'boolean' },
+            ignored: { type: 'boolean' },
+            notes: { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
         },
     });
@@ -122,10 +136,17 @@ function dispatch(argv, io) {
     const configPath = resolve(io.cwd, values.config ?? join(root, 'cadence.yaml'));
     // Installer les skills ou le hook ne lit pas le plan : un cadence.yaml fautif ne doit pas l'empêcher.
     const installing = command === 'skills' || (command === 'hook' && rest[0] === 'install');
-    const planConfig = installing ? null : readPlanConfig(configPath);
+    const planConfig = installing ? null : readPlanConfig(configPath, root);
     const planPath = resolve(io.cwd, values.file ?? io.env.RAF_FILE ?? resolve(root, planConfig?.path ?? 'docs/plan/raf.yaml'));
     const loadPlan = () => Plan.load(planPath, { ...planConfig?.settings, config: configPath });
     const newsDir = resolve(io.cwd, values.dir ?? join(root, 'docs/nouveautes'));
+    // Limite DÉCLARÉE (news.publicTitleMax) : sans clé, seul « raf check » avertit ; avec, la pose d'un titre public est refusée.
+    const refuseLongTitle = (text, hint = '') => {
+        const max = readNewsConfig(configPath).publicTitleMax;
+        const m = max === undefined ? null : publicTitleTooLong(text, max);
+        if (m)
+            throw new RafError(m + hint);
+    };
     // Une session d'orchestration ne ferme pas un lot, n'enregistre pas de verdict à la place du lead et ne livre pas.
     if (io.env.CADENCE_ORCHESTRATED && (command === 'done' || command === 'ux' || command === 'review' || command === 'deliver')) {
         throw new RafError(`${command} refusé pendant une vague orchestrée (${io.env.CADENCE_ORCHESTRATED}) : c'est le travail du lead`);
@@ -140,6 +161,8 @@ function dispatch(argv, io) {
                 throw new RafError(`plan en lecture seule : ${configPath} décrit un plan tenu par un autre outil`);
             const plan = Plan.create(planPath, values.project ?? basename(root), values.prefix ?? 'L', today);
             io.out(`plan créé : ${plan.path}`);
+            if (ensureGitignore(root, '.playwright-mcp/'))
+                io.out('.gitignore : .playwright-mcp/');
             if (!values['no-hook'] && gitRoot(io.cwd))
                 io.out(`hook : ${installHook(io.cwd).path}`);
             return 0;
@@ -163,6 +186,8 @@ function dispatch(argv, io) {
                 const every = values.every === undefined ? undefined : Number(values.every);
                 if (every !== undefined && !(Number.isInteger(every) && every > 0))
                     throw new RafError(`périodicité invalide : ${values.every} (un nombre entier de jours)`);
+                if (values.public !== undefined)
+                    refuseLongTitle(values.public);
                 id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, public: values.public, every, after });
             }
             plan.save();
@@ -175,6 +200,14 @@ function dispatch(argv, io) {
             need(1, `${command} <id>`);
             const plan = loadPlan();
             const status = command === 'start' ? 'doing' : command === 'done' ? 'done' : 'dropped';
+            // Le titre public part au site : un titre au-delà de la limite déclarée y ferait échouer le build.
+            if (status === 'done' && !rest[0].includes('/')) {
+                const lot = plan.lots().find((l) => l.id === rest[0]);
+                // Sans public: d'un lot visible, le site reprend le titre de sa Nouveauté la plus récente.
+                const pub = lot?.public ?? (lot?.visible ? loadEntries(newsDir).find((e) => e.lots.includes(lot.id))?.title : undefined);
+                if (pub)
+                    refuseLongTitle(pub, lot?.public ? '' : ' — titre de la Nouveauté reprise par le site : corriger l\'entrée ou poser raf public');
+            }
             // Le plan ne lit pas git : lui dire combien de commits du lot sa revue ne couvre pas quand elle est exigée.
             const unreviewed = status === 'done' && plan.reviewSince && !plan.readonly && !values.force ? unreviewedWork(plan, root, rest[0]) : 0;
             plan.setStatus(rest[0], status, today, { force: values.force, unreviewed });
@@ -210,6 +243,8 @@ function dispatch(argv, io) {
             if (values.clear && rest.length > 1)
                 throw new RafError('--clear n\'attend pas de titre');
             const plan = loadPlan();
+            if (!values.clear)
+                refuseLongTitle(rest.slice(1).join(' '));
             plan.setPublic(rest[0], values.clear ? null : rest.slice(1).join(' '));
             plan.save();
             return 0;
@@ -221,14 +256,42 @@ function dispatch(argv, io) {
             need(1, 'commits <lot>');
             const plan = loadPlan();
             const id = rest[0];
-            if (!plan.lots().some((l) => l.id === id)) {
-                throw new RafError(id.includes('/') ? `les commits se listent par lot, pas par sous-tâche : ${id}` : `lot inconnu : ${id}`);
-            }
+            knownLot(plan, id, 'les commits se listent par lot, pas par sous-tâche');
             // Une lecture : le même ensemble que « raf done » et « raf check », plan en lecture seule compris.
             for (const c of lotWork(plan, root, id).reverse())
                 io.out(short(c));
             return 0;
         }
+        case 'show': {
+            need(1, 'show <lot> [--notes]');
+            const plan = loadPlan();
+            const lot = knownLot(plan, rest[0], 'show se lit par lot, pas par sous-tâche');
+            const notes = lot.notes.map((n) => `${n.date}  ${n.text}`);
+            if (values.notes) {
+                for (const n of notes)
+                    io.out(n);
+                return 0;
+            }
+            io.out(`${lot.id}  ${lot.status}  ${lot.title}`);
+            const dates = [['créé', lot.created], ['démarré', lot.started], [lot.status === 'dropped' ? 'abandonné' : 'terminé', lot.finished]].filter(([, d]) => d);
+            if (dates.length)
+                io.out(dates.map(([k, d]) => `${k} : ${d}`).join('  '));
+            if (lot.after.length)
+                io.out(`after : ${lot.after.join(', ')}`);
+            if (lot.public)
+                io.out(`public : ${lot.public}`);
+            if (notes.length) {
+                io.out('notes :');
+                // Les lignes suivantes d'une note multiligne s'alignent sous son texte, pas en colonne 0.
+                for (const n of lot.notes)
+                    io.out(`  ${n.date}  ${n.text.replace(/\n/g, `\n${' '.repeat(n.date.length + 4)}`)}`);
+            }
+            const commits = lotWork(plan, root, lot.id).reverse();
+            io.out(`commits (${commits.length}) :`);
+            for (const c of commits)
+                io.out(`  ${short(c)}`);
+            return 0;
+        }
         case 'list': {
             const plan = loadPlan();
             if (values.status && !STATUSES.includes(values.status))
@@ -240,15 +303,43 @@ function dispatch(argv, io) {
         }
         case 'now':
             return now(loadPlan(), root, newsDir, today, io);
+        case 'ignore': {
+            need(1, 'ignore <sha> | "<sujet exact>" [--reason texte]');
+            const plan = loadPlan();
+            const arg = rest.join(' ');
+            const commits = planCommits(plan, root);
+            // Un sujet exact l'emporte sur un nom de ref homonyme (`other` à la fois sujet et branche).
+            const sha = rest.length === 1 && !commits.some((c) => c.subject === arg) ? resolveCommit(root, rest[0]) : null;
+            const found = rest.length === 1 && sha ? commits.find((c) => c.sha === sha) : commits.find((c) => c.subject === arg);
+            if (!found)
+                throw new RafError(`aucun commit ne correspond à « ${arg} » (sha ou sujet exact)`);
+            // Un sha est exact ; un sujet vaut pour tous les commits qui le portent.
+            const bySha = rest.length === 1 && sha !== null;
+            plan.acknowledge({ ...(bySha ? { sha: found.sha, subject: found.subject } : { subject: found.subject }), date: today, ...(values.reason ? { reason: values.reason } : {}) });
+            plan.save();
+            io.out(`${bySha ? short(found) : found.subject} acquitté`);
+            return 0;
+        }
         case 'check': {
+            if (values.ignored) {
+                const list = loadPlan().acknowledged;
+                if (list.length === 0)
+                    io.out('aucun commit acquitté');
+                for (const a of list)
+                    io.out(`${a.sha ? a.sha.slice(0, 7) : 'sujet  '} ${a.subject ?? ''}  (${a.date}${a.reason ? ` — ${a.reason}` : ''})`);
+                return 0;
+            }
             const idle = values.idle === undefined ? 7 : Number(values.idle);
             if (!Number.isInteger(idle) || idle < 0)
                 throw new RafError(`--idle invalide : ${values.idle}`);
             const issues = audit(loadPlan(), root, newsDir, today, { since: values.since, idle });
             for (const i of issues)
-                io.out(`✗ ${i.message}`);
-            io.out(issues.length === 0 ? '✓ plan et historique cohérents' : `${issues.length} écart(s)`);
-            return issues.length === 0 ? 0 : 1;
+                io.out(`${i.warning ? '⚠' : '✗'} ${i.message}`);
+            // Un avertissement s'affiche mais ne fait pas échouer : seuls les écarts comptent pour le code de sortie.
+            const errors = issues.filter((i) => !i.warning).length;
+            const warnings = issues.length - errors;
+            io.out(errors === 0 ? `✓ plan et historique cohérents${warnings ? ` (${warnings} avertissement(s))` : ''}` : `${errors} écart(s)${warnings ? `, ${warnings} avertissement(s)` : ''}`);
+            return errors === 0 ? 0 : 1;
         }
         case 'gantt': {
             const plan = loadPlan();
@@ -335,7 +426,7 @@ function dispatch(argv, io) {
             return 0;
         }
         case 'news':
-            return news(rest, loadPlan(), newsDir, today, values, io);
+            return news(rest, loadPlan(), newsDir, today, values, io, refuseLongTitle);
         default:
             throw new RafError(`commande inconnue : ${command} (raf --help)`);
     }
@@ -367,6 +458,12 @@ function gate(kind, rest, loadPlan, root, today, io) {
     plan.save();
     return 0;
 }
+function knownLot(plan, id, subtask) {
+    const lot = plan.lots().find((l) => l.id === id);
+    if (!lot)
+        throw new RafError(id.includes('/') ? `${subtask} : ${id}` : `lot inconnu : ${id}`);
+    return lot;
+}
 function describe(l, commits) {
     const bits = [`${l.estimate} j`];
     if (commits)
@@ -410,7 +507,7 @@ function now(plan, root, newsDir, today, io) {
         for (const l of done)
             io.out(`  ${l.id}  ${l.title}  (${l.finished})`);
     }
-    const issues = audit(plan, root, newsDir, today);
+    const issues = audit(plan, root, newsDir, today).filter((i) => !i.warning);
     if (issues.length)
         io.out(`\n${issues.length} écart(s) entre le plan et l'historique — raf check`);
     return 0;
@@ -455,7 +552,7 @@ function postCommit(load, newsDir, root, today, io) {
     }
     return 0;
 }
-function news([sub, ...args], plan, dir, today, values, io) {
+function news([sub, ...args], plan, dir, today, values, io, refuseLongTitle) {
     const lots = plan.lots();
     switch (sub) {
         case 'new': {
@@ -463,7 +560,10 @@ function news([sub, ...args], plan, dir, today, values, io) {
                 throw new RafError('usage : cadence news new <lot…> [--title t]');
             for (const id of args)
                 plan.lot(id);
-            io.out(newEntry(dir, args, values.title ?? plan.lot(args[0]).title, today, io.now()));
+            // Mesuré comme newEntry l'écrit : espaces fusionnés.
+            const title = (values.title ?? plan.lot(args[0]).public ?? plan.lot(args[0]).title).replace(/\s+/g, ' ').trim();
+            refuseLongTitle(title, values.title === undefined ? ' — donner un titre court : cadence news new <lot> --title "…"' : '');
+            io.out(newEntry(dir, args, title, today, io.now()));
             return 0;
         }
         case 'stamp': {

package/dist/config.js

@@ -1,17 +1,28 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, isAbsolute, posix, relative } from 'node:path';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
 import { parse } from 'yaml';
 import { isDay } from './dates.js';
+import { gitRoot } from './git.js';
 import { FIELDS, RafError, STATUSES } from './plan.js';
 const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates'];
 const FORMAT_KEYS = ['lots', 'fields', 'statuses', 'estimates'];
 const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const list = (v) => (v == null ? [] : Array.isArray(v) ? v.map(String) : [String(v)]);
+/** Chemin réel (liens symboliques résolus) du plus proche ancêtre existant, le reste rattaché tel quel. */
+function realish(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        const up = dirname(p);
+        return up === p ? p : join(realish(up), basename(p));
+    }
+}
 /**
  * Clé `qa:` : le fichier d'attendus QA, ramené à la forme que git rapporte (relatif à la racine du dépôt,
- * séparateurs posix, sans `./`). Une valeur vide vaut absente ; un type faux ou un chemin hors du dépôt est refusé.
+ * séparateurs posix, sans `./`). Un chemin absolu est lu depuis la racine du dépôt de travail que donne le CLI, à défaut la racine git du dossier du fichier (hors dépôt git, ce dossier). Une valeur vide vaut absente ; un type faux ou un chemin hors du dépôt est refusé.
  */
-function readQa(qa, file) {
+function readQa(qa, file, workRoot) {
     if (qa == null)
         return undefined;
     if (!isObject(qa))
@@ -24,17 +35,18 @@ function readQa(qa, file) {
     const raw = v.trim().replace(/\\/g, '/');
     if (raw === '')
         return undefined;
-    const root = dirname(file);
-    const rel = posix.normalize(isAbsolute(raw) ? relative(root, raw).replace(/\\/g, '/') : raw);
+    const root = workRoot ?? gitRoot(dirname(resolve(file))) ?? dirname(resolve(file));
+    const rel = posix.normalize(isAbsolute(raw) ? relative(realish(root), realish(raw)).replace(/\\/g, '/') : raw);
     if (rel === '.' || rel === '..' || rel.startsWith('../') || isAbsolute(rel))
         throw new RafError(`${file} : qa.expectations « ${v.trim()} » est hors du dépôt`);
     return rel;
 }
 /**
  * Clé `plan:` de cadence.yaml : où est le plan et, s'il est tenu par un autre outil, comment le lire.
+ * `root` : la racine du dépôt de travail (celle du CLI), d'où se résout un chemin absolu de `qa.expectations`.
  * Null quand le fichier ou la clé manque — le plan est alors docs/plan/raf.yaml au format de raf.
  */
-export function readPlanConfig(file) {
+export function readPlanConfig(file, root) {
     if (!existsSync(file))
         return null;
     let raw;
@@ -45,7 +57,7 @@ export function readPlanConfig(file) {
         throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
     }
     const doc = raw;
-    const qa = readQa(doc?.qa, file);
+    const qa = readQa(doc?.qa, file, root);
     const p = doc?.plan;
     if (p == null)
         return qa ? { settings: { qaExpectations: qa } } : null;
@@ -103,6 +115,32 @@ function parseFormat(p, bad) {
     }
     return format;
 }
+/** Clé `news:` de cadence.yaml. */
+export function readNewsConfig(file) {
+    if (!existsSync(file))
+        return {};
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const n = raw?.news;
+    if (n == null)
+        return {};
+    if (!isObject(n))
+        throw new RafError(`${file} : news doit être un objet { publicTitleMax }`);
+    for (const k of Object.keys(n))
+        if (k !== 'publicTitleMax')
+            throw new RafError(`${file} : news.${k} inconnu (attendu : publicTitleMax)`);
+    const max = n.publicTitleMax;
+    if (max == null)
+        return {};
+    if (typeof max !== 'number' || !Number.isInteger(max) || max < 1)
+        throw new RafError(`${file} : news.publicTitleMax : nombre entier de caractères (≥ 1) attendu`);
+    return { publicTitleMax: max };
+}
 /**
  * Clé `session:` de cadence.yaml : les faits propres au projet (son script de reprise, de clôture),
  * joués par cadence au lieu d'être remplacés.
@@ -144,10 +182,12 @@ export function readSessionConfig(file) {
     }
     return config;
 }
-const ORCH_KEYS = ['start', 'verdict', 'test', 'ux', 'permissionMode', 'addDirs', 'timeouts'];
+const MODELS = ['haiku', 'sonnet', 'opus'];
+const REVIEW_KEYS = ['threshold', 'light', 'full'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'ux', 'precheck', 'review', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
-    const config = { permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
+    const config = { precheck: true, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
     if (!existsSync(file))
         return config;
     let raw;
@@ -161,29 +201,78 @@ export function readOrchestrateConfig(file) {
     if (o == null)
         return config;
     const bad = (what) => new RafError(`${file} : orchestrate.${what}`);
+    const checkUxUrl = (url) => {
+        try {
+            new URL(url);
+        }
+        catch {
+            throw bad(`ux.url : URL invalide (reçu « ${url} »)`);
+        }
+    };
     if (!isObject(o))
         throw new RafError(`${file} : orchestrate doit être un objet`);
     for (const k of Object.keys(o))
         if (!ORCH_KEYS.includes(k))
             throw bad(`${k} inconnu (attendu : ${ORCH_KEYS.join(', ')})`);
-    for (const k of ['start', 'verdict', 'test']) {
+    for (const k of ['start', 'verdict', 'test', 'build']) {
         if (o[k] == null)
             continue;
         if (typeof o[k] !== 'string' || !o[k].trim())
             throw bad(`${k} : commande non vide attendue`);
         config[k] = o[k].trim();
     }
+    if (o.precheck != null) {
+        if (typeof o.precheck !== 'boolean')
+            throw bad('precheck : true ou false attendu');
+        config.precheck = o.precheck;
+    }
+    if (o.review != null) {
+        if (!isObject(o.review))
+            throw bad('review doit être un objet { threshold, light, full }');
+        for (const k of Object.keys(o.review))
+            if (!REVIEW_KEYS.includes(k))
+                throw bad(`review.${k} inconnu (attendu : ${REVIEW_KEYS.join(', ')})`);
+        const t = o.review.threshold;
+        if (t != null) {
+            if (typeof t !== 'number' || !(t >= 0))
+                throw bad('review.threshold : nombre de jours positif ou nul attendu');
+            config.review.threshold = t;
+        }
+        for (const k of ['light', 'full']) {
+            const m = o.review[k];
+            if (m == null)
+                continue;
+            if (!MODELS.includes(m))
+                throw bad(`review.${k} : ${MODELS.join(', ')} attendu`);
+            config.review[k] = m;
+        }
+    }
     if (o.ux != null) {
-        if (typeof o.ux === 'string' && o.ux.trim())
-            config.ux = /^https?:\/\//.test(o.ux.trim()) ? { url: o.ux.trim() } : { command: o.ux.trim() };
+        if (typeof o.ux === 'string' && o.ux.trim()) {
+            const u = o.ux.trim();
+            if (/^https?:\/\//.test(u))
+                checkUxUrl(u);
+            config.ux = /^https?:\/\//.test(u) ? { url: u } : { command: u };
+        }
         else if (isObject(o.ux) && (o.ux.url != null || o.ux.command != null)) {
             for (const k of Object.keys(o.ux))
-                if (k !== 'url' && k !== 'command')
-                    throw bad(`ux.${k} inconnu (attendu : url, command)`);
+                if (k !== 'url' && k !== 'command' && k !== 'timeout')
+                    throw bad(`ux.${k} inconnu (attendu : url, command, timeout)`);
             config.ux = {};
             for (const k of ['url', 'command'])
                 if (o.ux[k] != null)
                     config.ux[k] = String(o.ux[k]);
+            if (config.ux.url != null && !/^https?:\/\//.test(config.ux.url))
+                throw bad(`ux.url : une URL http(s) attendue (reçu « ${config.ux.url} »)`);
+            if (config.ux.url != null)
+                checkUxUrl(config.ux.url);
+            if (o.ux.timeout != null) {
+                if (config.ux.url == null || config.ux.command == null)
+                    throw bad('ux.timeout : réservé à la forme { command ET url } (le programme n\'attend la réponse que quand il lance l\'application)');
+                if (typeof o.ux.timeout !== 'number' || !(o.ux.timeout > 0))
+                    throw bad('ux.timeout : nombre de secondes positif attendu');
+                config.ux.timeout = o.ux.timeout;
+            }
         }
         else
             throw bad('ux : une URL, une commande, ou { url, command }');

package/dist/deliver.js

@@ -6,7 +6,7 @@ import { isPlanOnly } from './audit.js';
 import { headSha, isAncestor, onRemote, readCommits, repoStatus, resolveCommit } from './git.js';
 import { citedRefs } from './link.js';
 import { RafError } from './plan.js';
-import { appendDelivery, lastDelivery, lockAlive, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
+import { appendDelivery, lastDelivery, lockAlive, lockFault, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
 const POLL_CI = 15_000;
 const CI_APPEAR = 300_000;
 /** Intervalle de réessai d'une vérification : celui de deliver ET de `cadence verify --retry`. */
@@ -244,9 +244,16 @@ export async function deliver(ctx, deps) {
     if (lock && removeStaleLock(ctx.state, lock)) {
         err(`deliver : verrou périmé retiré (pid ${lock.pid} mort, ${lock.sha.slice(0, 7)})`);
     }
-    if (!writeLock(ctx.state, { pid: process.pid, sha, started: new Date(deps.now()).toISOString() })) {
-        return refuse('une autre livraison vient de démarrer');
+    let taken;
+    try {
+        taken = writeLock(ctx.state, { pid: process.pid, sha, started: new Date(deps.now()).toISOString() });
     }
+    catch (e) {
+        // Pas de liens physiques ici (EPERM, EMLINK…) : refus avec la cause, pas une exception qui sort de la commande.
+        return refuse(lockFault(lockPath(ctx.state), e));
+    }
+    if (!taken)
+        return refuse('une autre livraison vient de démarrer');
     try {
         const fail = (msg) => {
             err(`deliver : ${msg}`);

package/dist/news.js

@@ -4,6 +4,22 @@ import { parse, stringify } from 'yaml';
 import { isDay, toStamp } from './dates.js';
 import { addedTimes } from './git.js';
 import { RafError } from './plan.js';
+/** Limite avertie par `raf check` quand cadence.yaml n'en déclare pas (news.publicTitleMax). */
+export const PUBLIC_TITLE_DEFAULT = 80;
+/** Message quand un titre public dépasse `max` caractères, sinon null. */
+export function publicTitleTooLong(text, max) {
+    const n = text.trim().length;
+    return n > max ? `titre public de ${n} caractères, au-delà de la limite de ${max} (news.publicTitleMax) que la page Plan applique au build : « ${text.trim()} »` : null;
+}
+/**
+ * Titre que le site reprend de la Nouveauté la plus récente (`entries`, plus récentes d'abord) pour un lot visible
+ * terminé sans `public:` ; null si le lot n'est pas dans ce cas ou qu'aucune entrée ne le cite.
+ */
+export function reusedNewsTitle(lot, entries) {
+    if (!lot.visible || lot.status !== 'done' || lot.public)
+        return null;
+    return entries.find((e) => e.lots.includes(lot.id))?.title ?? null;
+}
 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})$/;
@@ -172,7 +188,7 @@ export function newEntry(dir, lots, rawTitle, today, now) {
     if (existsSync(path))
         throw new RafError(`${path} existe déjà`);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(path, `---\ntitle: ${stringify(title).trimEnd()}\ndate: ${today}\ncreated: ${toStamp(now)}\nlots: [${lots.join(', ')}]\ncaptures: []\n# une capture peut dire ce qu'elle montre : captures: [${CAPTURE_SHAPE.replace('chemin', 'captures/x.png')}]\n# nocapture: raison, quand une capture n'a pas de sens\n---\nCe qui change pour l'utilisateur.\n`);
+    writeFileSync(path, `---\ntitle: ${stringify(title, { lineWidth: 0 }).trimEnd()}\ndate: ${today}\ncreated: ${toStamp(now)}\nlots: [${lots.join(', ')}]\ncaptures: []\n# une capture peut dire ce qu'elle montre : captures: [${CAPTURE_SHAPE.replace('chemin', 'captures/x.png')}]\n# nocapture: raison, quand une capture n'a pas de sens\n---\nCe qui change pour l'utilisateur.\n`);
     return path;
 }
 /**