@sylad/cadence 1.13.0 → 1.15.0

package/dist/config.js

@@ -1,11 +1,14 @@
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
 import { parse } from 'yaml';
 import { isDay } from './dates.js';
 import { DEFAULT_TEST_PATTERNS } from './testgate.js';
 import { gitRoot } from './git.js';
+import { planCommitProblem } from './plan-commit.js';
+import { isComposedGate } from './orchestrate/workers.js';
 import { FIELDS, Plan, RafError, STATUSES } from './plan.js';
-const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add'];
+const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit'];
+const ON_WRITE_KEYS = ['command', 'files'];
 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)]);
@@ -42,6 +45,25 @@ function readQa(qa, file, workRoot) {
         throw new RafError(`${file} : qa.expectations « ${v.trim()} » est hors du dépôt`);
     return rel;
 }
+/** Clé `plan.onWrite` (L346) : la commande qui republie le plan après chaque écriture, lancée dans `cwd` (la racine du dépôt), et les fichiers qu'elle produit (relatifs au dépôt, jamais hors de lui). */
+function readOnWrite(v, cwd, bad) {
+    if (!isObject(v))
+        throw bad('onWrite doit être un objet { command, files }');
+    for (const k of Object.keys(v))
+        if (!ON_WRITE_KEYS.includes(k))
+            throw bad(`onWrite.${k} inconnu (attendu : ${ON_WRITE_KEYS.join(', ')})`);
+    if (typeof v.command !== 'string' || v.command.trim() === '')
+        throw bad('onWrite.command doit être une commande');
+    const files = list(v.files).map((f) => {
+        const rel = posix.normalize(f.trim().replace(/\\/g, '/'));
+        if (rel === '.' || rel === '..' || rel.startsWith('../') || isAbsolute(rel))
+            throw bad(`onWrite.files « ${f} » est hors du dépôt`);
+        if (existsSync(resolve(cwd, rel)) && statSync(resolve(cwd, rel)).isDirectory())
+            throw bad(`onWrite.files « ${f} » est un dossier (déclarer les fichiers produits, pas leur dossier)`);
+        return rel;
+    });
+    return { command: v.command, files, cwd };
+}
 /**
  * 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`.
@@ -84,13 +106,20 @@ export function readPlanConfig(file, root) {
         settings.ignore = list(p.ignore);
     if (p.files != null)
         settings.files = list(p.files);
+    if (p.onWrite != null)
+        settings.onWrite = readOnWrite(p.onWrite, root ?? dirname(resolve(file)), bad);
     if (FORMAT_KEYS.some((k) => p[k] != null))
         settings.format = parseFormat(p, bad);
     if (p.path != null && String(p.path).trim() === '')
         throw bad('path est vide');
     if (p.add != null && (typeof p.add !== 'string' || !p.add.includes('{title}')))
         throw bad('add doit être une commande qui contient {title}');
-    return { ...(p.path != null ? { path: String(p.path) } : {}), ...(p.add != null ? { add: String(p.add) } : {}), settings };
+    if (p.commit != null) {
+        const problem = typeof p.commit === 'string' ? planCommitProblem(p.commit) : 'doit être un gabarit de message';
+        if (problem)
+            throw bad(`commit ${problem}`);
+    }
+    return { ...(p.path != null ? { path: String(p.path) } : {}), ...(p.add != null ? { add: String(p.add) } : {}), ...(p.commit != null ? { commit: String(p.commit) } : {}), settings };
 }
 export const PLAN_DEFAULT = '.cadence/raf.yaml';
 export const PLAN_LEGACY = 'docs/plan/raf.yaml';
@@ -283,9 +312,8 @@ export function readSessionConfig(file) {
 }
 const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
 export const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'fix', 'review', 'ux'];
-const MODELS = ['haiku', 'sonnet', 'opus'];
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeDeps', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'effort', '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 = { precheck: true, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, worktrees: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
@@ -320,7 +348,7 @@ export function readOrchestrateConfig(file) {
             throw bad('accept : commande non vide attendue (chaîne ou liste de commandes non vides)');
         config.accept = o.accept.map((x) => x.trim());
     }
-    for (const k of ['start', 'verdict', 'test', 'build', 'accept']) {
+    for (const k of ['start', 'verdict', 'test', 'testReplay', 'build', 'accept']) {
         if (k === 'accept' && Array.isArray(o.accept))
             continue;
         if (o[k] == null)
@@ -329,6 +357,16 @@ export function readOrchestrateConfig(file) {
             throw bad(`${k} : commande non vide attendue`);
         config[k] = o[k].trim();
     }
+    if (config.testReplay && !config.testReplay.includes('{files}'))
+        throw bad('testReplay : la commande doit contenir {files} (remplacé par les fichiers des tests rouges)');
+    if (config.testReplay && config.test && isComposedGate(config.test))
+        throw bad('testReplay : refusé quand orchestrate.test est une porte composée (&&, ||, sous-shell) : le rejeu seul ne vaut que pour un lanceur unique');
+    if (o.worktreeDeps != null) {
+        const deps = o.worktreeDeps;
+        if (!Array.isArray(deps) || !deps.length || deps.some((x) => typeof x !== 'string' || !x.trim() || isAbsolute(x) || x.split(/[\\/]/).includes('..')))
+            throw bad('worktreeDeps : liste de chemins relatifs au dépôt, sans « .. » (node_modules, .venv…)');
+        config.worktreeDeps = deps.map((x) => x.trim().replace(/\/$/, ''));
+    }
     if (o.maquette != null) {
         if (typeof o.maquette !== 'boolean')
             throw bad('maquette : true ou false attendu');
@@ -418,9 +456,9 @@ export function readOrchestrateConfig(file) {
             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 (typeof m !== 'string' || !m.trim())
+                throw bad(`review.${k} : nom de modèle non vide attendu (haiku, sonnet, opus ou un nom passé tel quel à claude --model)`);
+            config.review[k] = m.trim();
         }
     }
     if (o.escalation != null) {

package/dist/corrections.js

@@ -121,6 +121,7 @@ export function readJournals(runsDir, until, since) {
                 ...(typeof rec.escalationReserve === 'number' ? { escalationReserve: rec.escalationReserve } : {}),
                 ...(precheck ? { precheck } : {}),
                 ...(escalation ? { escalation } : {}),
+                ...(Array.isArray(rec.instables) && rec.instables.some((t) => typeof t === 'string') ? { instables: rec.instables.filter((t) => typeof t === 'string') } : {}),
                 ...(Array.isArray(rec.warnings) && rec.warnings.some((w) => typeof w === 'string' && w.startsWith(LOCAL_PRECHECK_UNREADABLE)) ? { localUnreadable: true } : {}),
                 steps: steps.map((s) => {
                     const usage = usageOf(s.tokens);

package/dist/git.js

@@ -1,4 +1,5 @@
 import { execFileSync } from 'node:child_process';
+import { rmSync } from 'node:fs';
 import { basename, dirname, resolve } from 'node:path';
 function git(cwd, args) {
     // Le journal complet d'un gros dépôt dépasse le Mo par défaut : sans marge, il serait lu comme vide.
@@ -110,7 +111,7 @@ export function fileAt(cwd, rev, file) {
         return null;
     }
 }
-function tryGit(cwd, args) {
+export function tryGit(cwd, args) {
     try {
         return git(cwd, args).trim();
     }
@@ -230,6 +231,15 @@ export function commitPaths(root, paths, message) {
     }
     return tryGit(root, ['rev-parse', '--short', 'HEAD']) ?? '';
 }
+/** Remet `paths` comme à HEAD : un fichier suivi retrouve sa version commitée, un fichier que HEAD ne connaît pas est supprimé. */
+export function restorePaths(root, paths) {
+    for (const f of paths) {
+        if (tryGit(root, ['cat-file', '-e', `HEAD:${f}`]) !== null)
+            git(root, ['checkout', '-q', 'HEAD', '--', f]);
+        else
+            rmSync(resolve(root, f), { force: true });
+    }
+}
 /** Un fichier SUIVI est-il modifié (indexé ou non) ? Les fichiers non suivis ne comptent pas : un commit à chemins explicites ne les embarque pas. `except` : chemins qu'on ne compte pas. */
 export function hasTrackedChanges(cwd, except = []) {
     return git(cwd, ['status', '--porcelain', '--untracked-files=no', '--', '.', ...except.map((f) => `:(exclude)${f}`)]).trim() !== '';

package/dist/lead.js

@@ -12,6 +12,7 @@ import { priorityRank, readPriority } from './orchestrate/continue.js';
 import { readNext, sharedStateDir, stateDir } from './state.js';
 import { freeLine, readyFree } from './ready-free.js';
 import { cadenceHome } from './orchestrate/registry.js';
+import { staleNotes, staleText } from './stale-notes.js';
 import { noTestGate, noTestText } from './orchestrate/no-test.js';
 import { KEPT_TITLE, keptLine, keptTrees } from './orchestrate/worktree.js';
 /** Clé `lead.ux` du cadence.yaml du dossier parent (L197) : qui pose le verdict UX (`raf ux`) d'un lot visible. `human` (défaut) : l'humain ; `lead` : le lead, l'humain n'étant consulté qu'en cas de doute. */
@@ -123,6 +124,9 @@ export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
         });
         row.drift = audit(plan, root, join(root, 'docs/nouveautes'), today).map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`);
         row.notes = readNext(stateDir(root))?.lines ?? [];
+        const stale = [...new Set(staleNotes(row.notes, lots).flatMap((n) => n.stale))];
+        if (stale.length)
+            row.staleNotes = stale;
         const counted = lots.filter((l) => l.status !== 'dropped' && l.every === undefined);
         row.progress = {
             done: counted.filter((l) => l.status === 'done').length,
@@ -213,7 +217,7 @@ export function tourLine(r) {
     const drift = r.drift.length
         ? `${r.drift.length} (${r.drift.slice(0, DRIFT_SHOWN).join(' ; ')}${r.drift.length > DRIFT_SHOWN ? ' ; …' : ''})`
         : 'aucune';
-    const notes = r.notes.length ? truncate(r.notes.join(' / '), NOTES_MAX) : 'aucune';
+    const notes = r.notes.length ? `${truncate(r.notes.join(' / '), NOTES_MAX)}${r.staleNotes ? ` ${staleText(r.staleNotes)}` : ''}` : 'aucune';
     const next = r.next ? `${r.next.id} ${truncate(r.next.title, TITLE_MAX)}` : 'aucun';
     return [r.project, `en cours ${doing}`, `dérive ${drift}`, `notes : ${notes}`, `prochain ${next}`, ...(r.waiting?.length ? [`attend ${r.waiting.join(', ')}`] : []), `dépôt ${r.repo.length ? r.repo.join(', ') : 'propre'}`].join(' · ');
 }

package/dist/orchestrate/accept.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, posix } from 'node:path';
 import { parse } from 'yaml';
@@ -180,6 +180,68 @@ export function resealAcceptation(repo, path, test, reason, today, porteur, refs
     writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
     return { avant, apres, lot: a.lot, ...(ficheAmendee ? { ficheAmendee } : {}) };
 }
+/** Les acceptations de `dir` à `vert: false` au HEAD : leur chemin et le lot qu'elles portent. Un fichier illisible n'en est pas une. */
+export function redAcceptations(repo, dir) {
+    const out = [];
+    for (const path of listAcceptations(repo, dir).sort()) {
+        try {
+            const a = parseAcceptation(readFileSync(join(repo, path), 'utf8'));
+            if (typeof a !== 'string' && !a.vert)
+                out.push({ path, lot: a.lot });
+        }
+        catch {
+            // illisible ou absent de l'arbre de travail : le verrou en parle, pas ce signalement
+        }
+    }
+    return out;
+}
+/**
+ * La commande dédiée (`orchestrate.accept`) lancée à la main, sous les mêmes règles que le cycle (`runAccept`) : chaque commande dont la racine contient un fichier listé,
+ * `{acceptation}` substitué, `CADENCE_ACCEPTATION` et `CADENCE_ACCEPTATION_ROOT` posés. Un fichier listé sous la racine d'aucune commande est rendu (`orphans`) sans rien lancer.
+ */
+export function runAcceptation(repo, json, accept) {
+    const abs = join(repo, json);
+    const doc = parseAcceptation(readFileSync(abs, 'utf8'));
+    const plan = planAcceptRuns(acceptCommands(accept), typeof doc === 'string' ? [] : doc.fichiers, !isAcceptList(accept));
+    if (plan.orphans.length)
+        return { runs: [], orphans: plan.orphans };
+    const runs = plan.runs.map((r) => {
+        const done = spawnSync('sh', ['-c', r.command.replaceAll('{acceptation}', abs)], { cwd: repo, encoding: 'utf8', timeout: 30 * 60_000, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, CADENCE_ACCEPTATION: abs, CADENCE_ACCEPTATION_ROOT: r.root || '.' } });
+        return { command: r.command, code: done.status ?? 1, output: `${done.stdout ?? ''}${done.stderr ?? ''}${done.error ? done.error.message : ''}` };
+    });
+    return { runs, orphans: [] };
+}
+/**
+ * `cadence spec green` (L366) : la commande d'acceptation vient de passer au vert sur les tests tels qu'ils sont. Ceux qu'un lot mené à la main a mis au point
+ * après le commit rouge ont une empreinte scellée périmée : le verrou les signalerait encore à chaque lot suivant. Chaque empreinte différente est refaite et
+ * journalisée dans `resceaux` (comme `spec reseal`, sans fiche amendée) ; le commit qui pose `vert: true` devient ainsi le commit rouge. Rend les tests rescellés.
+ * L'appelant s'est assuré que les tests listés sont commités (l'empreinte rescellée est celle de l'arbre de travail) ; un test absent est refusé.
+ */
+export function resealForGreen(repo, path, today) {
+    const file = join(repo, path);
+    const a = parseAcceptation(readFileSync(file, 'utf8'));
+    if (typeof a === 'string')
+        throw new Error(`${path} : ${a}`);
+    const fichiers = a.fichiers.map((f) => posix.normalize(f));
+    const absents = fichiers.filter((f) => !existsSync(join(repo, f)));
+    if (absents.length)
+        throw new Error(`test(s) listé(s) absent(s) de ${path} : ${absents.join(', ')}`);
+    const doc = JSON.parse(readFileSync(file, 'utf8'));
+    const empreintes = isObj(doc.empreintes) ? doc.empreintes : {};
+    const journal = Array.isArray(doc.resceaux) ? doc.resceaux : [];
+    const refaits = fichiers.filter((f) => empreintes[f] !== git(repo, 'hash-object', '--', f).trim());
+    for (const f of refaits) {
+        const apres = git(repo, 'hash-object', '--', f).trim();
+        journal.push({ test: f, raison: 'cadence spec green : tests mis au point après le commit rouge, acceptation verte sur ces tests', date: today, avant: empreintes[f] ?? '', apres });
+        empreintes[f] = apres;
+    }
+    if (refaits.length) {
+        doc.empreintes = empreintes;
+        doc.resceaux = journal;
+        writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
+    }
+    return refaits;
+}
 /** Pose `vert: true` dans le fichier (le cycle, jamais une session) ; le commit est à faire. */
 export function setVert(repo, path) {
     const file = join(repo, path);

package/dist/orchestrate/baseline.js

@@ -49,6 +49,42 @@ export function failedTests(output) {
     }
     return [...found].sort();
 }
+/** Fichiers de test qui ne se chargent pas (vitest « FAIL  a.test.ts [ a.test.ts ] »), triés, sans doublon : les échecs que `failedTests` laisse de côté faute de test à nommer. */
+export function unloadedSuites(output) {
+    const found = new Set();
+    for (const raw of output.replace(ANSI, '').split('\n')) {
+        if (!FILE_LOAD_FAIL.test(raw))
+            continue;
+        const name = raw.replace(/^\s*FAIL\s+/, '').replace(/\s+\[[^\]]*\]\s*$/, '').trim();
+        if (name)
+            found.add(name);
+    }
+    return [...found].sort();
+}
+/** Sortie sans les séquences de couleur du lanceur. */
+export const stripAnsi = (s) => s.replace(ANSI, '');
+/**
+ * jest : le fichier de chaque « ● Suite › test » et de chaque ligne « FAIL projet fichier » (nom rouge à part entière avec displayName), celui de la dernière ligne `FAIL fichier` qui le précède dans la même sortie (L354). Un test jest ne porte pas son fichier dans son nom ;
+ * sans cette lecture on ne saurait pas quel fichier rejouer pour lui, ni si le rejeu l'a couvert.
+ */
+export function jestTestFiles(output) {
+    const files = new Map();
+    let file = null;
+    for (const raw of stripAnsi(output).split('\n')) {
+        const f = /^\s*(PASS|FAIL)\b(.*)$/.exec(raw);
+        if (f) {
+            // « FAIL src/a.test.ts », « FAIL src/a.test.ts (6.21 s) » (jest ajoute la durée au-delà de 5 s : un fichier lent sous charge) ou « FAIL projet src/a.test.ts » (displayName) : le fichier est le dernier mot. Toute autre ligne PASS/FAIL ne désigne aucun fichier : ne pas garder le précédent.
+            const last = f[1] === 'FAIL' ? f[2].replace(/\s*\([^)]*\)\s*$/, '').trim().split(/\s+/).pop() ?? '' : '';
+            file = /^[^\s|]+\.\w+$/.test(last) ? last : null;
+            if (file)
+                files.set(clean(f[2]), file); // « FAIL projet fichier » est lui-même un nom rouge (failedTests) : son fichier est le sien
+        }
+        const t = /^\s*●\s+(.+)$/.exec(raw);
+        if (t && file)
+            files.set(clean(t[1]), file);
+    }
+    return files;
+}
 /** Échecs d'après le lot qui n'étaient pas rouges au départ (`nouveaux`) et ceux qui l'étaient déjà (`existants`). */
 export function compareBaseline(now, base) {
     const was = new Set(base);
@@ -56,11 +92,11 @@ export function compareBaseline(now, base) {
 }
 /**
  * Un échec que la sortie ne rattache à aucun test : erreur non gérée (vitest « Unhandled Errors », promesse rejetée), fichier de spec qui ne se charge plus (jest « Test suite failed to run », vitest « FAIL  a.test.ts [ a.test.ts ] » : le FAIL de fichier existait peut-être au départ), seuil de
- * couverture non atteint. Comparer les seuls noms lus le masquerait derrière d'anciens échecs : l'appelant garde les tests pour rouges.
+ * couverture non atteint. `loadFailsNamed` : l'appelant nomme déjà les fichiers qui ne se chargent pas (`unloadedSuites`), ils ne comptent plus comme échec sans nom. Comparer les seuls noms lus le masquerait derrière d'anciens échecs : l'appelant garde les tests pour rouges.
  */
-export function hasUnnamedFailure(output) {
+export function hasUnnamedFailure(output, loadFailsNamed = false) {
     const text = output.replace(ANSI, '');
-    if (text.split('\n').some((l) => FILE_LOAD_FAIL.test(l)))
+    if (!loadFailsNamed && text.split('\n').some((l) => FILE_LOAD_FAIL.test(l)))
         return true;
     return /Unhandled (?:Errors?|Rejections?)|Test suite failed to run|caught \d+ unhandled|coverage threshold|Coverage for \w+ \([\d.]+%\) does not meet/i.test(text);
 }

package/dist/orchestrate/changelog-merge.js

@@ -1,5 +1,6 @@
 /** Ordre des sections de Keep a Changelog ; un titre inconnu vient après, dans l'ordre où il apparaît. */
 const SECTION_ORDER = ['Added', 'Changed', 'Deprecated', 'Removed', 'Fixed', 'Security'];
+const rank = (s) => (SECTION_ORDER.includes(s) ? SECTION_ORDER.indexOf(s) : SECTION_ORDER.length);
 /** Découpe le fichier autour de `## [Unreleased]` : ce qui précède (titre compris), le bloc, ce qui suit à partir de la version suivante. */
 function split(text) {
     const lines = text.split('\n');
@@ -46,6 +47,8 @@ function onlyAdds(base, side) {
             i++;
     return i === base.length;
 }
+/** `text` porte l'entrée `e` entière, sur ses propres lignes : « - Fix typo » n'est pas dans « - Fix typo in README ». */
+const hasEntry = (text, e) => `\n${text}\n`.includes(`\n${e}\n`);
 /** Un côté qui n'a pas bougé laisse l'autre gagner ; deux côtés qui ont bougé de la même façon aussi ; sinon, pas de réponse. */
 function pick(base, ours, theirs) {
     if (ours === theirs)
@@ -77,18 +80,108 @@ export function mergeUnreleased(base, ours, theirs, start) {
     const st = start === undefined ? null : split(start);
     const startEntries = new Set([...(st ? (sections(st.block)?.values() ?? []) : [])].flat());
     const own = new Set(start === undefined || !st ? [] : [...bs.values()].flat().filter((e) => !startEntries.has(e)));
+    // Une entrée de base que ours range sous une version publiée (la branche a été publiée pendant la vie du lot) n'a pas été retirée : elle a changé de place.
+    // Seule une entrée de base compte, entière : une entrée nouvelle de theirs qui est un bout d'une entrée publiée n'est pas la même, elle reste au lot.
+    // Les entrées du lot (`own`) ne comptent pas dans l'ordre de ours : l'union d'un commit précédent les y a recasées en fin de section.
+    const baseEntries = new Set([...bs.values()].flat());
+    const released = (e) => baseEntries.has(e) && o.tail !== b.tail && hasEntry(o.tail, e) && !hasEntry(b.tail, e);
     for (const [title, entries] of bs) {
         const kept = entries.filter((e) => !own.has(e));
-        if (!onlyAdds(kept, (os.get(title) ?? []).filter((e) => !own.has(e))) || !onlyAdds(entries, os.get(title) ?? []) || !onlyAdds(kept, ts.get(title) ?? [])) {
+        if (!onlyAdds(kept.filter((e) => !released(e)), (os.get(title) ?? []).filter((e) => !own.has(e))) || !onlyAdds(kept, ts.get(title) ?? [])) {
             return null;
         }
     }
     const titles = [...new Set([...os.keys(), ...ts.keys()])];
-    const rank = (s) => (SECTION_ORDER.includes(s) ? SECTION_ORDER.indexOf(s) : SECTION_ORDER.length);
     titles.sort((x, y) => rank(x) - rank(y));
-    const body = titles.map((title) => {
-        const entries = [...new Set([...(os.get(title) ?? []).filter((e) => !own.has(e)), ...(ts.get(title) ?? [])])];
-        return `### ${title}\n\n${entries.join('\n')}\n`;
+    const body = titles.flatMap((title) => {
+        const entries = [...new Set([...(os.get(title) ?? []).filter((e) => !own.has(e)), ...(ts.get(title) ?? []).filter((e) => !released(e))])];
+        return entries.length ? [`### ${title}\n\n${entries.join('\n')}\n`] : [];
     });
     return `${head}\n\n${body.join('\n')}\n${tail}`;
 }
+/** Entrées du bloc `[Unreleased]` de `text`, par section ; null sans bloc ou avec du texte hors entrée. */
+export function unreleasedSections(text) {
+    const s = split(text);
+    return s ? sections(s.block) : null;
+}
+/**
+ * Replace sous `[Unreleased]` les entrées du lot qu'une publication de la branche a laissées sous une version (L362). `lotTip` : le CHANGELOG du sommet du lot
+ * avant le rebase, `start` celui de son point de départ — une entrée de `[Unreleased]` du premier absente du second est au lot — et `main` celui de la
+ * branche du dépôt : une entrée déjà dans sa partie publiée n'a pas été glissée là par le rebase, elle reste. `rebased` : le CHANGELOG après le rebase.
+ * Rend le texte corrigé et le nombre d'entrées déplacées, ou null quand il n'y a rien à déplacer (ou que le fichier n'a pas la forme attendue).
+ */
+export function moveToUnreleased(rebased, lotTip, start, main) {
+    const [r, mainSplit] = [split(rebased), split(main)];
+    const [tip, was] = [unreleasedSections(lotTip), unreleasedSections(start)];
+    const [now, published] = [sections(r?.block ?? []), mainSplit ? mainSplit.tail : ''];
+    if (!r || !tip || !was || !now)
+        return null;
+    const known = new Set([...was.values()].flat());
+    let tail = r.tail;
+    let moved = 0;
+    const added = new Map();
+    for (const [title, entries] of tip) {
+        for (const e of entries) {
+            if (known.has(e) || hasEntry(published, e) || (now.get(title) ?? []).includes(e) || !hasEntry(tail, e))
+                continue;
+            tail = tail.replace(`\n${e}\n`, '\n');
+            added.set(title, [...(added.get(title) ?? []), e]);
+            moved++;
+        }
+    }
+    if (moved === 0)
+        return null;
+    tail = tail.replace(/^### .+\n\n(\n|$)/gm, '');
+    for (const [title, entries] of added)
+        now.set(title, [...(now.get(title) ?? []), ...entries]);
+    const titles = [...now.keys()].sort((x, y) => rank(x) - rank(y));
+    const body = titles.map((title) => `### ${title}\n\n${(now.get(title) ?? []).join('\n')}\n`);
+    return { text: `${r.head}\n\n${body.join('\n')}\n${tail}`, moved };
+}
+/**
+ * Une entrée finale par lot (L369) : après le rebase, le `[Unreleased]` ne porte du lot que ses entrées du sommet de sa branche. Les `intermediates` — les
+ * entrées que ses commits successifs ont écrites puis réécrites, absentes du sommet comme de ses versions publiées — en sont retirées (sous `[Unreleased]` comme sous une version), à moins
+ * que `main` ne les porte aussi : elles sont alors à elle. Une entrée du sommet absente du texte (ni sous `[Unreleased]`, ni sous une version, ni déjà publiée
+ * sur `main`) y est remise sous sa section. `lotTip`, `start`, `main` : comme pour `moveToUnreleased`. Rend le texte corrigé, ou null quand il n'y a rien à
+ * changer (ou que le fichier n'a pas la forme attendue).
+ */
+export function settleLotEntries(rebased, lotTip, start, main, intermediates) {
+    const [r, mainSplit] = [split(rebased), split(main)];
+    const [tip, was] = [unreleasedSections(lotTip), unreleasedSections(start)];
+    const now = sections(r?.block ?? []);
+    if (!r || !mainSplit || !tip || !was || !now)
+        return null;
+    const mainOwn = new Set([...(sections(mainSplit.block)?.values() ?? [])].flat());
+    const known = new Set([...was.values()].flat());
+    const final = new Set([...tip.values()].flat());
+    // Une entrée que le sommet du lot porte sous une version (le lot l'a publiée lui-même) est finale, pas intermédiaire.
+    const tipTail = split(lotTip)?.tail ?? '';
+    const stale = intermediates.filter((e) => !final.has(e) && !hasEntry(tipTail, e) && !mainOwn.has(e) && !hasEntry(mainSplit.tail, e));
+    let changed = false;
+    for (const [title, entries] of now) {
+        const kept = entries.filter((e) => !stale.includes(e));
+        if (kept.length !== entries.length)
+            changed = true;
+        now.set(title, kept);
+    }
+    let tail = r.tail;
+    for (const e of stale) {
+        if (hasEntry(tail, e)) {
+            tail = tail.replace(`\n${e}\n`, '\n');
+            changed = true;
+        }
+    }
+    const present = (e) => [...now.values()].some((v) => v.includes(e)) || hasEntry(tail, e) || hasEntry(mainSplit.tail, e);
+    for (const [title, entries] of tip) {
+        for (const e of entries.filter((x) => !known.has(x) && !present(x))) {
+            now.set(title, [...(now.get(title) ?? []), e]);
+            changed = true;
+        }
+    }
+    if (!changed)
+        return null;
+    tail = tail.replace(/^### .+\n\n(\n|$)/gm, '');
+    const titles = [...now.keys()].filter((t) => (now.get(t) ?? []).length > 0).sort((x, y) => rank(x) - rank(y));
+    const body = titles.map((title) => `### ${title}\n\n${(now.get(title) ?? []).join('\n')}\n`);
+    return `${r.head}\n\n${body.join('\n')}\n${tail}`;
+}