@sylad/cadence 1.12.1 → 1.14.1

package/dist/ref/coverage.js

@@ -0,0 +1,136 @@
+import { resolve } from 'node:path';
+import { RafError } from '../plan.js';
+import { isProgramNote } from '../orchestrate/decisions.js';
+import { fichesDuDossier } from '../spec.js';
+import { checkInventaire, readInventaire, TYPES } from './check.js';
+/** Un id d'élément d'inventaire (`<slug>#<type>-<n>`, R9 de `ref check`) tel qu'un lot le cite dans son titre, son objectif ou ses notes. */
+const ID_SOURCE = `[a-z0-9]+(?:-[a-z0-9]+)*#(?:${TYPES.join('|')})-[1-9]\\d*`;
+const ID_PATTERN = new RegExp(ID_SOURCE, 'g');
+/** Une ligne de `perimetre.hors_perimetre` d'une fiche qui justifie un élément non pris : `<id> : <raison>`. */
+const JUSTIFICATION = new RegExp(`^\\s*(${ID_SOURCE})\\s*:\\s*(\\S.*)$`);
+/** Les ids d'éléments d'inventaire cités dans un texte, sans doublon, dans l'ordre. */
+export function idsInText(text) {
+    return [...new Set(text.match(ID_PATTERN) ?? [])];
+}
+/**
+ * Les ids qu'un lot cite : son titre, son objectif (`goal:`) et les notes que le lead a écrites sur le lot. Les notes que le programme pose (titre remplacé,
+ * mineur de revue, hypothèses…) et celles des sous-tâches ne comptent pas : elles citent ce que le lot ne couvre plus ou ne couvre pas, et c'est le lot qui est fait ou non.
+ */
+export function lotIds(lot) {
+    return idsInText([lot.title, lot.goal ?? '', ...lot.notes.map((n) => n.text).filter((t) => !isProgramNote(t))].join('\n'));
+}
+/** Les éléments que la fiche d'un lot justifie comme non pris (`<id> : <raison>` dans `sujet.perimetre.hors_perimetre`), par id. */
+export function nonPris(repo, specDir, lotId) {
+    const out = new Map();
+    const doc = fichesDuDossier(repo, specDir).find(({ doc }) => doc.sujet?.lot === lotId)?.doc;
+    const sujet = doc?.sujet;
+    const lignes = sujet?.perimetre?.hors_perimetre;
+    for (const l of Array.isArray(lignes) ? lignes : []) {
+        const m = typeof l === 'string' ? JUSTIFICATION.exec(l) : null;
+        if (m)
+            out.set(m[1], m[2].trim());
+    }
+    return out;
+}
+/** Consigne des briefs d'un lot qui cite des éléments d'un document de référence : le spec-writer les prend ou justifie, le ux-reviewer les vérifie sur l'écran fini. */
+export function referenceIdsText(role, ids) {
+    if (!ids.length)
+        return '';
+    const list = ids.map((id) => `- \`${id}\``).join('\n');
+    if (role === 'spec') {
+        return [
+            'The lot covers these elements of a reference document (ids of its `inventaire.json`, `<slug>#<type>-<n>`):',
+            list,
+            'Take each one into the sheet: the field, rule or state that shows it quotes its id in its `source` (e.g. `source: "exemple#texte-3"`). An element you do not take is justified, one line `<id> : <reason>` — in the report under "choix", and in `perimetre.hors_perimetre` when the sheet has a back part. An id you leave out without a reason is a gap the review reads as a finding. `cadence ref coverage` reads the `hors_perimetre` lines: an element so justified is not covered by your lot, it stays a gap until the lead writes its exclusion or another lot takes it.',
+        ].join('\n');
+    }
+    return [
+        'The lot covers these elements of a reference document (ids of its `inventaire.json`):',
+        list,
+        'On the finished screen, verify each one: it is visible (or reachable) in the state where the sheet puts it, its text, role and place are those of the element, and it is in the captures you take. An element missing or different on the running screen is a finding naming its id; an element the sheet justified as not taken is not one.',
+    ].join('\n');
+}
+/** Ce qui désigne un élément à l'œil : son libellé, sa question, son nom… (rien pour un jeton ou une table sans nom). */
+function label(e) {
+    const text = [e.libelle, e.question, e.nom, e.contenu, e.figure, e.valeur].find((v) => typeof v === 'string' || typeof v === 'number');
+    return text === undefined ? '' : ` « ${String(text).slice(0, 60)} »`;
+}
+function where(e) {
+    const source = e.source;
+    const zone = source.zone ? ` zone ${source.zone.x},${source.zone.y},${source.zone.l},${source.zone.h}` : '';
+    return `p.${source.page}${zone}`;
+}
+/**
+ * Calcule la couverture d'un inventaire valide par les lots du plan (fait, abandonné compté pour rien) et par ses exclusions écrites. Un lot fait dont la fiche
+ * justifie un élément comme non pris (`justifies`) ne le couvre pas : l'élément reste un écart tant que le lead ne l'a pas exclu par écrit ou fait par un autre lot.
+ */
+export function computeCoverage(inventaire, lots, justifies = () => new Map()) {
+    const elements = inventaire.elements;
+    const known = new Set(elements.map((e) => e.id));
+    const byId = new Map();
+    for (const lot of lots)
+        for (const id of lotIds(lot))
+            if (known.has(id))
+                byId.set(id, [...(byId.get(id) ?? []), { id: lot.id, status: lot.status }]);
+    const problems = [];
+    const excluded = new Set();
+    const raw = inventaire.exclusions;
+    if (raw !== undefined && !Array.isArray(raw))
+        problems.push('exclusions : un tableau [{ id, raison }] est attendu');
+    else
+        raw?.forEach((x, i) => {
+            const o = typeof x === 'object' && x !== null ? x : {};
+            if (typeof o.id !== 'string' || !known.has(o.id))
+                problems.push(`exclusions[${i}].id : ${String(o.id)} ne désigne aucun élément de l'inventaire`);
+            else if (typeof o.raison !== 'string' || o.raison.trim() === '')
+                problems.push(`exclusions[${i}].raison : la raison de l'exclusion de ${o.id} est obligatoire`);
+            else
+                excluded.add(o.id);
+        });
+    const gaps = [];
+    let done = 0;
+    for (const e of elements) {
+        const id = e.id;
+        const mine = (byId.get(id) ?? []).filter((l) => l.status !== 'dropped');
+        const faits = mine.filter((l) => l.status === 'done');
+        const pris = faits.filter((l) => !justifies(l.id).has(id));
+        if (pris.length > 0)
+            done++;
+        else if (!excluded.has(id)) {
+            const reason = faits.length
+                ? `justifié non pris par la fiche de ${faits.map((l) => `${l.id} : ${justifies(l.id).get(id)}`).join(' ; ')}, sans exclusion écrite`
+                : mine.length ? `lot non fait (${mine.map((l) => `${l.id} ${l.status}`).join(', ')})` : 'aucun lot, aucune exclusion écrite';
+            gaps.push({ id, text: `${id} (${e.type} ${where(e)}${label(e)}) : ${reason}` });
+        }
+    }
+    return { gaps, problems, total: elements.length, done, excluded: elements.length - done - gaps.length };
+}
+const USAGE = 'usage : cadence ref coverage <inventaire.json>';
+/** `cadence ref coverage <inventaire.json>` : l'inventaire de `--double` ou la lecture de `lectures/a.json` (le défaut de `ref analyse`) ; 0 si tout élément a un lot fait ou une exclusion écrite, 1 sinon, 2 pour un appel mal formé ou un fichier qui n'est pas un inventaire ou une lecture valide. Sans modèle, sans outil système. */
+export function coverageCommand(args, loadPlan, io, fiches) {
+    if (args.length !== 1)
+        throw new RafError(USAGE);
+    const path = resolve(io.cwd, args[0]);
+    const inventaire = readInventaire(path);
+    const invalid = checkInventaire(inventaire);
+    if (invalid.length > 0)
+        throw new RafError(`ref coverage : ${path} n'est ni un inventaire ni une lecture valide (${invalid.length} écart(s), voir cadence ref check) : ${invalid[0]}`);
+    const cache = new Map();
+    const justifies = (lotId) => {
+        if (!cache.has(lotId))
+            cache.set(lotId, nonPris(fiches.repo, fiches.specDir, lotId));
+        return cache.get(lotId);
+    };
+    const c = computeCoverage(inventaire, loadPlan().lots(), justifies);
+    for (const p of c.problems)
+        io.out(`✗ ${p}`);
+    for (const g of c.gaps)
+        io.out(`✗ ${g.text}`);
+    const left = c.gaps.length + c.problems.length;
+    if (left > 0) {
+        io.out(`${c.gaps.length} élément(s) sans lot fait ni exclusion écrite${c.problems.length ? `, ${c.problems.length} exclusion(s) refusée(s)` : ''} sur ${c.total}`);
+        return 1;
+    }
+    io.out(`couverture complète : ${c.total} éléments (${c.done} par un lot fait, ${c.excluded} exclus avec leur raison)`);
+    return 0;
+}

package/dist/ref/diff.js

@@ -1,4 +1,4 @@
-import { writeFileSync } from 'node:fs';
+import { existsSync, writeFileSync } from 'node:fs';
 import { RafError } from '../plan.js';
 import { TYPES, checkInventaire, readInventaire } from './check.js';
 import { affirmation, identite } from './evaluate.js';
@@ -116,13 +116,16 @@ function confianceConcordant(ea, eb) {
     return { confiance: ea.confiance === 'mesure' || eb.confiance === 'mesure' ? 'mesure' : 'lu' };
 }
 /**
- * L'inventaire réconcilié (genre « inventaire »), ids renumérotés `<slug>#<type>-<n>` et renvois suivis. Un divergent est `incertain` avec les deux
+ * L'inventaire réconcilié (genre « inventaire »), ids `<slug>#<type>-<n>` (renumérotés, sauf pour un élément de `precedent`) et renvois suivis. Un divergent est `incertain` avec les deux
  * versions ; un seul écarté par le troisième regard disparaît (avec ce qui ne tient plus sans lui), un seul confirmé garde sa confiance (un doute
  * reste un doute), un seul sans décision reste `incertain` : `regard` dit si le troisième regard a eu lieu (sa cause le dit).
  * Un élément apparié tient tant que l'une de ses deux versions renvoie à des éléments gardés (la lecture A d'abord) : quand l'autre version renvoyait à un
  * élément écarté, il est gardé, rattaché d'après la version qui tient, et `incertain` avec la cause du rattachement ; il disparaît quand aucune ne tient.
+ * `precedent` : l'inventaire que ce passage remplace, du même document. Un élément relu (même type, même page, même identité, zone qui recouvre le plus)
+ * y garde son id ; un élément neuf prend un numéro au-dessus du plus grand de son type, jamais celui d'un élément disparu : un lot qui cite un id
+ * continue de viser le même élément, et les `exclusions` écrites passent dans le nouvel inventaire.
  */
-export function assembler(a, b, rec, regard = false) {
+export function assembler(a, b, rec, regard = false, precedent) {
     const entrees = rec.items.map((item) => ({ item, supprimee: item.statut === 'seul' && item.decision?.verdict === 'ecarte' }));
     const proprietaire = new Map();
     for (const en of entrees) {
@@ -162,16 +165,7 @@ export function assembler(a, b, rec, regard = false) {
                 en.version = v;
         }
     }
-    const compteur = new Map();
-    const nouvelId = new Map();
-    for (const en of entrees) {
-        if (en.supprimee)
-            continue;
-        const type = en.item.element.type;
-        const n = (compteur.get(type) ?? 0) + 1;
-        compteur.set(type, n);
-        nouvelId.set(en, `${a.document.slug}#${type}-${n}`);
-    }
+    const nouvelId = idsStables(entrees, a, b, precedent);
     const elements = entrees.filter((en) => !en.supprimee).map((en) => {
         const { item } = en;
         const v = en.version;
@@ -213,7 +207,43 @@ export function assembler(a, b, rec, regard = false) {
         }
         return e;
     });
-    return { version: 1, genre: 'inventaire', document: { slug: a.document.slug, sha256: a.document.sha256 }, elements };
+    const exclusions = memeDocument(precedent, a) ? precedent.exclusions : undefined;
+    return { version: 1, genre: 'inventaire', document: { slug: a.document.slug, sha256: a.document.sha256 }, elements, ...(exclusions !== undefined ? { exclusions } : {}) };
+}
+const memeDocument = (precedent, a) => (precedent?.genre === 'inventaire' || precedent?.genre === 'lecture') && precedent.document?.slug === a.document.slug && Array.isArray(precedent.elements);
+/** Les ids du nouvel inventaire : ceux de `precedent` pour les éléments relus, des numéros neufs pour les autres (ordre de l'inventaire, numérotation par type). */
+function idsStables(entrees, a, b, precedent) {
+    const slug = a.document.slug;
+    const anciens = memeDocument(precedent, a) ? precedent.elements : [];
+    const parAncien = new Map(anciens.map((e) => [e.id, e]));
+    const parA = new Map(a.elements.map((e) => [e.id, e]));
+    const parB = new Map(b.elements.map((e) => [e.id, e]));
+    const reprise = new Set();
+    const nouvelId = new Map();
+    for (const en of entrees.filter((x) => !x.supprimee)) {
+        const e = en.item.element;
+        const par = en.item.a ? parA : parB;
+        const libres = anciens.filter((p) => !reprise.has(p) && p.type === e.type && p.source?.page === e.source?.page && identite(p, parAncien) === identite(e, par));
+        const ancien = libres.reduce((best, c) => (best === undefined || recouvrement(e, c) > recouvrement(e, best) ? c : best), undefined);
+        if (ancien) {
+            reprise.add(ancien);
+            nouvelId.set(en, ancien.id);
+        }
+    }
+    const compteur = new Map();
+    for (const e of anciens) {
+        const n = Number(String(e.id).slice(String(e.id).lastIndexOf('-') + 1));
+        compteur.set(e.type, Math.max(compteur.get(e.type) ?? 0, Number.isInteger(n) ? n : 0));
+    }
+    for (const en of entrees) {
+        if (en.supprimee || nouvelId.has(en))
+            continue;
+        const type = en.item.element.type;
+        const n = (compteur.get(type) ?? 0) + 1;
+        compteur.set(type, n);
+        nouvelId.set(en, `${slug}#${type}-${n}`);
+    }
+    return nouvelId;
 }
 function lireLecture(path) {
     const doc = readInventaire(path);
@@ -232,6 +262,60 @@ export function parseSeuil(text, commande) {
         throw new RafError(`${commande} : --seuil invalide : « ${text} » (une part en pour cent, de 0 à 100)`);
     return Number(text) / 100;
 }
+/**
+ * Ce qu'un passage de `ref analyse` remplace et dont il reprend les ids : l'inventaire du dossier du document, sinon sa lecture `lectures/a.json`
+ * (une lecture unique ou la lecture A d'une double), du moment qu'elle est valide ; sinon rien.
+ */
+export function precedentDe(inventaire, lecture) {
+    const inv = inventairePrecedent(inventaire);
+    if (inv)
+        return inv;
+    if (!existsSync(lecture))
+        return undefined;
+    try {
+        const doc = readInventaire(lecture);
+        return doc.genre === 'lecture' && checkInventaire(doc).length === 0 ? doc : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Une lecture seule (`ref analyse` sans `--double`) numérote ses éléments par son propre ordre : ceux qui relisent un élément de `precedent` (même règle
+ * que `assembler`) reprennent son id, les renvois suivent, et les `exclusions` écrites passent dans la lecture. Sans `precedent` du même document, rien ne change.
+ */
+export function reprendreIds(lecture, precedent) {
+    if (!memeDocument(precedent, lecture))
+        return;
+    const elements = lecture.elements;
+    const entrees = elements.map((e) => ({ item: { statut: 'concordant', element: e, a: e }, supprimee: false }));
+    const nouvelId = idsStables(entrees, lecture, lecture, precedent);
+    const ancienVersNeuf = new Map(entrees.map((en) => [en.item.element.id, nouvelId.get(en)]));
+    for (const e of elements) {
+        if (e.type === 'composant')
+            e.ecran = ancienVersNeuf.get(e.ecran) ?? e.ecran;
+        if (e.type === 'etat')
+            e.cible = ancienVersNeuf.get(e.cible) ?? e.cible;
+        if (e.type === 'statut')
+            e.couvre = e.couvre.map((id) => ancienVersNeuf.get(id) ?? id);
+    }
+    for (const e of elements)
+        e.id = ancienVersNeuf.get(e.id);
+    if (precedent.exclusions !== undefined)
+        lecture.exclusions = precedent.exclusions;
+}
+/** L'inventaire que `--out` va remplacer, s'il en est un de valide ; sinon rien (un fichier illisible ou d'une autre forme n'est pas un inventaire précédent). */
+export function inventairePrecedent(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const doc = readInventaire(path);
+        return doc.genre === 'inventaire' && checkInventaire(doc).length === 0 ? doc : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** `ref diff <a> <b> [--out inventaire.json] [--seuil 30]` : 0 réconcilié, 1 trop d'éléments non appariés (rien d'écrit), 2 fichier ou appel refusé. */
 export function diffLectures(o) {
     const seuil = parseSeuil(o.seuil, 'ref diff');
@@ -257,6 +341,6 @@ export function diffLectures(o) {
         return 1;
     }
     if (o.out !== undefined)
-        writeFileSync(o.out, `${JSON.stringify(assembler(a, b, rec), null, 2)}\n`);
+        writeFileSync(o.out, `${JSON.stringify(assembler(a, b, rec, false, inventairePrecedent(o.out)), null, 2)}\n`);
     return 0;
 }

package/dist/release.js

@@ -0,0 +1,249 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { currentBranch, hasTrackedChanges, tagExists } from './git.js';
+import { RafError } from './plan.js';
+export const BUMPS = ['patch', 'minor', 'major'];
+const PACKAGE = 'package.json';
+const LOCK = 'package-lock.json';
+const PLUGIN = '.claude-plugin/plugin.json';
+const MARKETPLACE = '.claude-plugin/marketplace.json';
+const CHANGELOG = 'CHANGELOG.md';
+const WHATS_NEW = 'docs/whats-new.md';
+/** Longueur maximale (en caractères) de la ligne d'une version dans la liste courte de docs/whats-new.md. */
+export const SHORT_LINE_MAX = 240;
+export function nextVersion(current, bump) {
+    const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(current);
+    if (!m)
+        throw new RafError(`release : la version de ${PACKAGE} (${current}) n'est pas de la forme x.y.z, elle ne se calcule pas`);
+    const [major, minor, patch] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    if (bump === 'major')
+        return `${major + 1}.0.0`;
+    if (bump === 'minor')
+        return `${major}.${minor + 1}.0`;
+    return `${major}.${minor}.${patch + 1}`;
+}
+function readJson(root, file) {
+    try {
+        return JSON.parse(readFileSync(join(root, file), 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`release : ${file} illisible (${e.message})`);
+    }
+}
+/** Remplace la première capture d'un motif `(préfixe)(ancienne)(suffixe)` ; null si le motif est absent. */
+function swap(text, pattern, version) {
+    return pattern.test(text) ? text.replace(pattern, `$1${version}$3`) : null;
+}
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Écart entre les dépendances de package.json et celles de la racine du lock : ce qu'un `npm install` ferait bouger. */
+function lockDrift(pkg, lock) {
+    const root = lock.packages?.[''] ?? {};
+    const out = [];
+    for (const field of ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']) {
+        const want = pkg[field] ?? {};
+        const have = root[field] ?? {};
+        for (const name of new Set([...Object.keys(want), ...Object.keys(have)])) {
+            if (want[name] !== have[name])
+                out.push(`${field}.${name} : ${PACKAGE} ${want[name] ?? '(absent)'}, ${LOCK} ${have[name] ?? '(absent)'}`);
+        }
+    }
+    return out;
+}
+/** Les sections d'un CHANGELOG « Keep a Changelog » : le corps de [Unreleased] et le texte à partir de la section suivante. */
+function splitUnreleased(text) {
+    const head = /^## \[Unreleased\][^\n]*\n/m.exec(text);
+    if (!head)
+        throw new RafError(`release : ${CHANGELOG} n'a pas de section « ## [Unreleased] » à renommer`);
+    const start = head.index + head[0].length;
+    const next = /^## /m.exec(text.slice(start));
+    const end = next ? start + next.index : text.length;
+    return { before: text.slice(0, head.index), body: text.slice(start, end), after: text.slice(end) };
+}
+/** Une section est vide quand elle n'a que des titres de sous-section (« ### Added ») et des lignes blanches. */
+function hasEntries(body) {
+    return body.split('\n').some((l) => l.trim() !== '' && !/^#{3,}\s/.test(l));
+}
+/** Un échec de git (hors dépôt, dépôt sans commit) est un refus, pas une trace de pile. */
+const inGit = (what, f) => {
+    try {
+        return f();
+    }
+    catch (e) {
+        throw new RafError(`release : ${what} impossible (${(e.message.split('\n').find((l) => /^fatal|^error/i.test(l)) ?? e.message).trim()}) — la commande se lance dans un dépôt git qui a au moins un commit`);
+    }
+};
+/** Calcule tous les fichiers de la release SANS rien écrire : un refus laisse l'arbre intact. */
+function plan(root, bump, today) {
+    if (!existsSync(join(root, PACKAGE)))
+        throw new RafError(`release : ${PACKAGE} introuvable dans ${root}`);
+    const pkg = readJson(root, PACKAGE);
+    const current = String(pkg.version ?? '');
+    const version = nextVersion(current, bump);
+    if (inGit('la lecture de l\'état git', () => hasTrackedChanges(root, [WHATS_NEW])))
+        throw new RafError(`release : l'arbre de travail a des fichiers suivis modifiés (hors ${WHATS_NEW}, que le commit de version embarque) — le commit de version ne tient que les fichiers de version ; les commiter ou les remiser d'abord`);
+    if (inGit('la lecture des tags', () => tagExists(root, `v${version}`)))
+        throw new RafError(`release : la version ${version} est déjà taguée (v${version}) — rien à préparer`);
+    const writes = new Map();
+    const files = [];
+    const put = (file, text) => {
+        writes.set(file, text);
+        files.push(file);
+    };
+    const edit = (file, edits) => {
+        let text = readFileSync(join(root, file), 'utf8');
+        for (const [spec, label] of edits) {
+            const next = swap(text, typeof spec === 'function' ? spec(text) : spec, version);
+            if (next === null)
+                throw new RafError(`release : ${file} n'a pas ${label} à mettre à jour`);
+            text = next;
+        }
+        return text;
+    };
+    // Le champ de tête du fichier, à l'indentation du fichier (deux espaces, quatre, tabulation) : celle de sa première clé.
+    const topVersion = (text) => new RegExp(`^(${escape(/^\{[ \t]*\r?\n([ \t]+)"/.exec(text)?.[1] ?? '  ')}"version":\\s*")([^"]*)(")`, 'm');
+    put(PACKAGE, edit(PACKAGE, [[topVersion, 'de champ "version"']]));
+    if (existsSync(join(root, LOCK))) {
+        const lock = readJson(root, LOCK);
+        if (lock.version !== current || (lock.packages?.['']?.version ?? current) !== current) {
+            throw new RafError(`release : ${LOCK} (version ${lock.version}) n'est pas à la version de ${PACKAGE} (${current}) — un \`npm install\` le recale, à commiter à part`);
+        }
+        const drift = lockDrift(pkg, lock);
+        if (drift.length > 0)
+            throw new RafError(`release : ${LOCK} n'est pas à jour des dépendances de ${PACKAGE}, un \`npm install\` les ferait bouger — à commiter à part avant la release :\n  ${drift.join('\n  ')}`);
+        const edits = [[topVersion, 'de champ "version"']];
+        if (lock.packages?.[''])
+            edits.push([/("packages":\s*\{\s*"":\s*\{[^{}]*?"version":\s*")([^"]*)(")/, 'de version pour la racine de packages']);
+        put(LOCK, edit(LOCK, edits));
+    }
+    let pluginName = null;
+    let marketplaceName = null;
+    if (existsSync(join(root, PLUGIN))) {
+        pluginName = String(readJson(root, PLUGIN).name ?? '');
+        put(PLUGIN, edit(PLUGIN, [[topVersion, 'de champ "version"']]));
+    }
+    if (existsSync(join(root, MARKETPLACE))) {
+        const market = readJson(root, MARKETPLACE);
+        marketplaceName = typeof market.name === 'string' ? market.name : null;
+        // Le plugin du dépôt : celui qui porte le nom de plugin.json, sinon celui qui était à la version du paquet ; les autres plugins du marketplace gardent la leur.
+        const entries = Array.isArray(market.plugins) ? market.plugins : [];
+        const own = entries.find((p) => pluginName !== null && p?.name === pluginName) ?? entries.find((p) => p?.version === current);
+        if (!own)
+            throw new RafError(`release : ${MARKETPLACE} n'a pas de plugin ${pluginName ? `« ${pluginName} »` : `à la version ${current}`} à mettre à jour`);
+        put(MARKETPLACE, edit(MARKETPLACE, [[new RegExp(`("name":\\s*"${escape(String(own.name))}"(?:[^{}]|\\{[^{}]*\\})*?"version":\\s*")([^"]*)(")`), `de version pour le plugin « ${own.name} »`]]));
+    }
+    if (!existsSync(join(root, CHANGELOG)))
+        throw new RafError(`release : ${CHANGELOG} n'existe pas — la release renomme sa section [Unreleased], il faut donc un ${CHANGELOG} qui en porte une`);
+    const changelog = readFileSync(join(root, CHANGELOG), 'utf8');
+    const { before, body, after } = splitUnreleased(changelog);
+    if (!hasEntries(body))
+        throw new RafError(`release : la section [Unreleased] est vide dans ${CHANGELOG} — rien à publier ; y écrire ce qui change pour l'utilisateur (lots cités)`);
+    // Une section [Unreleased] vide reste au-dessus : sans elle, la fusion de CHANGELOG du mode worktree d'orchestrate ne trouve plus où poser les entrées des lots suivants.
+    put(CHANGELOG, `${before}## [Unreleased]\n\n## [${version}] - ${today}\n${body}${after}`);
+    // Chaque fichier écrit doit se relire avec la version attendue : un motif qui aurait touché un autre champ est un refus, pas une release fausse.
+    for (const [file, text] of writes) {
+        if (!file.endsWith('.json'))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new RafError(`release : ${file} ne se relirait plus après la mise à jour de la version`);
+        }
+        const seen = file === MARKETPLACE ? parsed.plugins.some((p) => p.version === version) : parsed.version === version;
+        if (!seen)
+            throw new RafError(`release : ${file} ne porte pas ${version} après la mise à jour`);
+    }
+    return {
+        version,
+        current,
+        writes,
+        files,
+        pluginName,
+        marketplaceName,
+        packageName: String(pkg.name ?? ''),
+        isPrivate: pkg.private === true,
+        hasEvalScript: typeof pkg.scripts?.['eval:plugin'] === 'string',
+    };
+}
+/**
+ * docs/whats-new.md porte la version sous deux formes, écrites à la main ou par une session (jamais par la commande) :
+ * une ligne de la liste « In two lines » (≤ 240 caractères, en tête) et un paragraphe long (en tête de « Version by version »).
+ * Rend les écarts, une ligne chacun ; vide quand les deux sont là, à leur place.
+ */
+export function whatsNewIssues(text, version) {
+    const lines = text.split('\n');
+    const issues = [];
+    // « Version by version » coupe le fichier : la liste courte est avant, les paragraphes longs sont après (sauf l'introduction, premier paragraphe de la section).
+    const heading = lines.findIndex((l) => /^##\s+Version by version\s*$/.test(l));
+    const split = heading < 0 ? lines.length : heading;
+    const intro = heading < 0 ? -1 : lines.findIndex((l, i) => i > heading && l.trim() !== '');
+    const check = (form, absent, misplaced, pattern, from, to, where, max) => {
+        const hits = lines.map((l, i) => ({ l, i, v: i >= from && i < to ? pattern.exec(l)?.[1] : undefined })).filter((x) => x.v !== undefined && x.i !== intro);
+        const at = hits.findIndex((h) => h.v === version);
+        if (at < 0) {
+            issues.push(`${WHATS_NEW} : ${form} ${absent} — l'écrire ${where}`);
+            return;
+        }
+        if (at > 0)
+            issues.push(`${WHATS_NEW} : ${form} ${misplaced} (après la version ${hits[at - 1].v} ; la plus récente va en premier) — la déplacer ${where}`);
+        if (max !== undefined && hits[at].l.length > max)
+            issues.push(`${WHATS_NEW} : ${form} trop longue (${hits[at].l.length} caractères, ${max} au plus)`);
+    };
+    check('ligne de « In two lines »', 'manquante', 'mal placée', /^- \*\*(\d+\.\d+\.\d+)\*\*:/, 0, split, 'en tête de la liste', SHORT_LINE_MAX);
+    check('paragraphe long', 'manquant', 'mal placé', /^\*\*(\d+\.\d+\.\d+)\*\*:/, split, lines.length, 'juste après l’introduction de « Version by version »');
+    return issues;
+}
+/** Les étapes que le lead joue, dans l'ordre : la commande n'en fait aucune. */
+function steps(p, files, branch) {
+    const tag = `v${p.version}`;
+    const out = [
+        `git add ${files.join(' ')} && git commit -m "release: ${p.version}"`,
+        ...(p.hasEvalScript ? ['npm run eval:plugin -- --trust-plugin    (facturé ; un cas sous le seuil arrête la release)'] : []),
+        `git tag ${tag}`,
+        `git push origin ${branch} ${tag}    (le tag lance le workflow de publication)`,
+        'gh run watch    (jusqu\'à la fin du run de publication)',
+        ...(p.isPrivate || p.packageName === '' ? [] : [`npm view ${p.packageName} version    (doit répondre ${p.version})`]),
+        ...(p.pluginName ? [
+            ...(p.marketplaceName ? [`claude plugin marketplace update ${p.marketplaceName}    (sans elle, le plugin installé reste à l'ancienne version)`] : []),
+            `claude plugin update ${p.pluginName}${p.marketplaceName ? `@${p.marketplaceName}` : ''}    (le plugin se lit depuis le dépôt poussé)`,
+            '/reload-plugins    (dans la session Claude Code ouverte, pour charger la nouvelle version)',
+        ] : []),
+    ];
+    return out.map((s, i) => `  ${i + 1}. ${s}`);
+}
+/** `cadence release patch|minor|major [--dry-run]` : prépare le commit de version, sans rien publier. Rend le code de sortie. */
+export function release(rest, dryRun, root, today, out) {
+    const bump = rest[0];
+    if (rest.length !== 1 || !bump || !BUMPS.includes(bump))
+        throw new RafError('usage : cadence release patch|minor|major [--dry-run]');
+    const p = plan(root, bump, today);
+    const whatsNewPath = join(root, WHATS_NEW);
+    const hasWhatsNew = existsSync(whatsNewPath);
+    const files = hasWhatsNew ? [...p.files, WHATS_NEW] : p.files;
+    const branch = inGit('la lecture de la branche', () => currentBranch(root)) ?? 'main';
+    out(`${dryRun ? 'release (--dry-run, rien n\'est écrit)' : 'release'} : ${p.current} → ${p.version}`);
+    for (const f of p.files)
+        out(`  ${dryRun ? 'écrirait' : 'écrit'} : ${f}${f === 'CHANGELOG.md' ? ` ([Unreleased] → [${p.version}] - ${today}, une section [Unreleased] vide au-dessus)` : ' (version)'}`);
+    if (!dryRun)
+        for (const [file, text] of p.writes)
+            writeFileSync(join(root, file), text);
+    let ready = true;
+    if (hasWhatsNew) {
+        const issues = whatsNewIssues(readFileSync(whatsNewPath, 'utf8'), p.version);
+        if (issues.length === 0)
+            out(`  ${WHATS_NEW} : les deux formes de ${p.version} sont là`);
+        else {
+            ready = false;
+            for (const i of issues)
+                out(`  ${i}`);
+            out(dryRun
+                ? '  le commit de version ne serait pas prêt : écrire ou déplacer ces formes (à la main ou par une session) avant de lancer la commande'
+                : '  le commit de version n\'est pas prêt : écrire ces formes (à la main ou par une session), puis suivre les étapes ci-dessous sans relancer la commande (elle changerait encore la version)');
+        }
+    }
+    out('étapes du lead, dans l\'ordre (la commande n\'en joue aucune) :');
+    for (const s of steps(p, files, branch))
+        out(s);
+    return ready ? 0 : 1;
+}

package/dist/session.js

@@ -5,6 +5,7 @@ import { audit, exemptPlanOnly, gateWaiting, nextUp, planCommits } from './audit
 import { diffDays, maxDay } from './dates.js';
 import { repoStatus } from './git.js';
 import { linkCommits } from './link.js';
+import { staleNoteLines, staleNotes, staleText } from './stale-notes.js';
 import { lockAlive, readLock, readNext, readSessionMark, writeSessionMark } from './state.js';
 const FACTS_TIMEOUT = 120_000;
 /**
@@ -107,7 +108,7 @@ export function sessionStart(ctx, opts) {
     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}`));
+        section(out, `Notes de la dernière clôture (${next.date})`, staleNoteLines(next.lines, lots).map((l) => `- ${l}`));
     const lock = lockStatus(ctx.shared);
     if (lock)
         out(`\n${lock.line}`);
@@ -152,6 +153,11 @@ export function sessionClose(ctx, opts) {
         commits.push(`${recent.orphans.length} commit(s) sans lot :`, ...recent.orphans.map((c) => `  ${short(c)}`));
     }
     section(out, `Commits de la période (${window.label})`, commits.length ? commits : ['(aucun)']);
+    const next = readNext(ctx.state);
+    if (next) {
+        const stale = staleNotes(next.lines, plan.lots()).filter((n) => n.stale.length);
+        section(out, `Notes de la dernière clôture à réécrire (${next.date})`, stale.map((n) => `${n.line} ${staleText(n.stale)} — cadence session next les remplace`));
+    }
     const quiet = plan.lots().filter((l) => l.status === 'doing' && !isRecurring(l) && !recent.byLot.has(l.id));
     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);

package/dist/stale-notes.js

@@ -0,0 +1,22 @@
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** « 2026-10-24 » → « 24-10 » : la note est récente, l'année ne se lit pas. */
+const dayMonth = (d) => `${d.slice(8, 10)}-${d.slice(5, 7)}`;
+/**
+ * Pour chaque ligne de note, les lots `done` ou `dropped` qu'elle cite, dans l'ordre de la ligne. Un identifiant se
+ * lit entier : `L2` n'est pas cité par `L217`, ni `B28` par `B28.8`, mais un point final (`reprendre L2.`) ne le prolonge pas.
+ */
+export function staleNotes(lines, lots) {
+    const finished = lots.filter((l) => l.status === 'done' || l.status === 'dropped');
+    return lines.map((line) => {
+        const hits = finished
+            .map((l) => ({ l, at: line.search(new RegExp(`(?<![\\w./-])${escape(l.id)}(?![\\w/-]|\\.\\w)`)) }))
+            .filter((h) => h.at >= 0)
+            .sort((a, b) => a.at - b.at);
+        return { line, stale: hits.map(({ l }) => `${l.id} ${l.status}${l.finished ? ` le ${dayMonth(l.finished)}` : ''}`) };
+    });
+}
+export const staleText = (stale) => `⚠ note périmée : ${stale.join(', ')}`;
+/** Les notes telles quelles, celles qui citent un lot fini suivies de « ⚠ note périmée : … ». */
+export function staleNoteLines(lines, lots) {
+    return staleNotes(lines, lots).map((n) => (n.stale.length ? `${n.line} ${staleText(n.stale)}` : n.line));
+}