@sylad/cadence 1.8.0 → 1.10.0

package/dist/lead.js

@@ -1,15 +1,19 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, relative, sep } from 'node:path';
 import { audit, gateWaiting, nextUp, planCommits } from './audit.js';
-import { planLoader, readPlanConfig } from './config.js';
+import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readPlanConfig } from './config.js';
 import { diffDays } from './dates.js';
 import { gitRoot, repoStatus } from './git.js';
 import { linkCommits } from './link.js';
-import { lastActivity, lockStatus } from './session.js';
+import { commitCount, lastActivity, lockStatus } from './session.js';
 import { parse } from 'yaml';
 import { RafError } from './plan.js';
 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 { 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. */
 export function readLeadUx(parent) {
     const file = join(parent, 'cadence.yaml');
@@ -63,9 +67,9 @@ const empty = (project) => ({ project, doing: [], drift: [], notes: [], next: nu
 export function truncate(text, max) {
     return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
-/** Un dossier est un projet s'il porte docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
+/** Un dossier est un projet s'il porte .cadence/raf.yaml ou docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
 export function isProject(dir) {
-    if (existsSync(join(dir, 'docs/plan/raf.yaml')))
+    if (existsSync(join(dir, PLAN_DEFAULT)) || existsSync(join(dir, PLAN_LEGACY)))
         return true;
     const conf = join(dir, 'cadence.yaml');
     if (!existsSync(conf) || !statSync(conf).isFile())
@@ -79,7 +83,7 @@ export function isProject(dir) {
         return true; // un cadence.yaml illisible reste un projet : sa ligne dit l'erreur
     }
 }
-/** Les projets sous `parent`, jusqu'à `depth` niveaux (1 : sous-dossiers directs) ; on ne descend pas dans un projet. */
+/** Les projets sous `parent`, jusqu'à `depth` niveaux (1 : sous-dossiers directs) ; on ne descend pas dans un projet, ni dans `tmp/` (copies de travail jetables, L241). */
 export function findProjects(parent, depth = 1) {
     const found = [];
     let entries;
@@ -90,7 +94,7 @@ export function findProjects(parent, depth = 1) {
         return found; // dossier illisible : on le saute, les autres projets tournent
     }
     for (const e of entries) {
-        if (!e.isDirectory() || e.name.startsWith('.') || e.name === 'node_modules')
+        if (!e.isDirectory() || e.name.startsWith('.') || e.name === 'node_modules' || e.name === 'tmp')
             continue;
         const dir = join(parent, e.name);
         if (isProject(dir))
@@ -110,11 +114,12 @@ export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
         const all = linkCommits(lots, planCommits(plan, root), plan.refs);
         const { doing, ready, blocked } = nextUp(lots);
         row.doing = doing.map((l) => {
-            const last = lastActivity(l, all.byLot.get(l.id) ?? []);
+            const commits = all.byLot.get(l.id) ?? [];
+            const last = lastActivity(l, commits);
             if (!last)
-                return { id: l.id, noActivity: true };
+                return { id: l.id, commits: commits.length, noActivity: true };
             const days = diffDays(last, today);
-            return days > idle ? { id: l.id, silentDays: days } : { id: l.id };
+            return days > idle ? { id: l.id, commits: commits.length, silentDays: days } : { id: l.id, commits: commits.length };
         });
         row.drift = audit(plan, root, join(root, 'docs/nouveautes'), today).map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`);
         row.notes = readNext(stateDir(root))?.lines ?? [];
@@ -136,6 +141,12 @@ export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
             row.repo.push('non poussé');
         if (lockStatus(sharedStateDir(root))?.live)
             row.repo.push('livraison en cours');
+        const kept = keptTrees(root);
+        if (kept.length)
+            row.worktrees = kept;
+        const noTest = noTestGate(root);
+        if (noTest)
+            row.noTest = noTest;
     }
     catch (e) {
         return { ...empty(row.project), error: (e instanceof Error ? e.message : String(e)).split('\n')[0] };
@@ -164,19 +175,41 @@ export function leadTour(parent, today, idle = TOUR_IDLE, depth) {
     const levels = depth ?? attempt(() => readDepth(parent), 1);
     const dirs = findProjects(parent, levels);
     if (dirs.length === 0 && isProject(parent))
-        return [...problems, tourRow(parent, today, idle)];
+        return [...problems, ...withFree([{ dir: parent, row: tourRow(parent, today, idle) }])];
     // un projet imbriqué est nommé par son chemin depuis le dossier : unique, et adressable par `orchestrate <projet>:<lot>` lancé d'ici ; la priorité et l'ordre alphabétique lisent le nom du dossier, comme orchestrate --continue
     const rows = dirs.map((dir) => ({ dir, key: basename(dir), row: tourRow(dir, today, idle, relative(parent, dir).split(sep).join('/')) }));
     const priority = attempt(() => readPriority(parent), []);
-    const sorted = rows.sort((a, b) => priorityRank(a.key, priority) - priorityRank(b.key, priority) || a.key.localeCompare(b.key) || a.row.project.localeCompare(b.row.project)).map((x) => x.row);
+    const sorted = withFree(rows.sort((a, b) => priorityRank(a.key, priority) - priorityRank(b.key, priority) || a.key.localeCompare(b.key) || a.row.project.localeCompare(b.row.project)));
     return [...problems, ...sorted];
 }
+/** Joint à chaque ligne ses lots prêts aux ressources libres (L252), calculés sur tous les projets du tour : ce qu'un projet tient en retire aux autres. */
+function withFree(rows) {
+    const ok = rows.filter((x) => !x.row.error);
+    const free = readyFree(ok.map((x) => x.dir), cadenceHome());
+    for (const x of ok)
+        if (free.has(x.dir))
+            x.row.free = free.get(x.dir);
+    return rows.map((x) => x.row);
+}
+/** La ligne « prêts, ressources libres » du tour, ou null quand aucun lot prêt n'est libre. */
+export function tourFreeLine(rows) {
+    return freeLine(rows.filter((r) => r.free).map((r) => ({ project: r.project, free: r.free })), TITLE_MAX);
+}
+/** Les worktrees de lot conservés du tour (L279, R19) : un titre puis une ligne chacun — dépôt, lot, âge, commits non intégrés, chemin ; rien quand il n'y en a pas. */
+export function tourWorktreeLines(rows, now = Date.now()) {
+    const lines = rows.flatMap((r) => (r.worktrees ?? []).map((t) => keptLine(r.project, t, now)));
+    return lines.length ? [KEPT_TITLE, ...lines] : [];
+}
+/** Une ligne par projet sans `orchestrate.test` (L327) : la vague ne lancera pas la suite ; rien quand tous le déclarent. */
+export function tourNoTestLines(rows) {
+    return rows.filter((r) => r.noTest).map((r) => `${r.project} · ${noTestText(r.noTest)}`);
+}
 const DRIFT_SHOWN = 2;
 /** Une ligne par projet : projet · en cours · dérive · notes · prochain lot prêt · dépôt. */
 export function tourLine(r) {
     if (r.error)
         return `${r.project} · ✗ erreur : ${r.error}`;
-    const doing = r.doing.length ? r.doing.map((d) => (d.noActivity ? `${d.id} (aucune activité)` : d.silentDays === undefined ? d.id : `${d.id} (silencieux ${d.silentDays}j)`)).join(', ') : 'rien';
+    const doing = r.doing.length ? r.doing.map((d) => `${d.id} (${[commitCount(d.commits), ...(d.noActivity ? ['aucune activité'] : d.silentDays === undefined ? [] : [`silencieux ${d.silentDays}j`])].join(', ')})`).join(', ') : 'rien';
     const drift = r.drift.length
         ? `${r.drift.length} (${r.drift.slice(0, DRIFT_SHOWN).join(' ; ')}${r.drift.length > DRIFT_SHOWN ? ' ; …' : ''})`
         : 'aucune';

package/dist/migrate.js

@@ -0,0 +1,166 @@
+import { execFileSync } from 'node:child_process';
+import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { docSyncSet } from './docsync.js';
+import { PLAN_DEFAULT, PLAN_LEGACY, readMigrateConfig } from './config.js';
+import { gitRoot, isTracked } from './git.js';
+import { RafError } from './plan.js';
+/** L'historique n'est pas un lecteur : journaux de commits, journaux ndjson et fichiers d'exécution de `.cadence/`. */
+const HISTORY = ['**/CHANGELOG*', '**/*.ndjson', '.cadence/**'];
+/** Une référence à l'ancien emplacement que `raf migrate` sait réécrire : le chemin complet, pas suivi d'un nom plus long. */
+const REWRITABLE = /docs\/plan\/raf\.yaml(?![\w-]|\.\w)/g;
+/** Le chemin construit morceau par morceau : `'docs', 'plan'` (join, éventuellement sur plusieurs lignes) ou `Path('docs') / 'plan'` (pathlib). */
+const BUILT = /['"`]docs['"`]\s*\)?\s*[,/]\s*['"`]plan['"`]/;
+/** Toute autre façon de désigner docs/plan : un autre fichier du dossier, un dossier, un chemin construit morceau par morceau. */
+const OTHER = new RegExp(`docs/plan(?!/raf\\.yaml(?![\\w-]|\\.\\w))|${BUILT.source}`, 'g');
+const MAX_BYTES = 2 * 1024 * 1024;
+const BLOCK = 1024 * 1024;
+/** Le recouvrement entre deux blocs : un chemin construit (`'docs',\n  'plan'`) ne doit pas passer entre deux. */
+const OVERLAP = 4096;
+/** Un gros fichier cite-t-il le chemin ? Lu par blocs d'octets (latin1, un octet par caractère) : jamais décodé en une seule chaîne. */
+function citesPath(path) {
+    const fd = openSync(path, 'r');
+    try {
+        const buf = Buffer.alloc(BLOCK + OVERLAP);
+        let kept = 0;
+        for (;;) {
+            const n = readSync(fd, buf, kept, BLOCK, null);
+            if (n === 0)
+                return false;
+            const text = buf.toString('latin1', 0, kept + n);
+            if (text.includes('docs/plan') || BUILT.test(text))
+                return true;
+            const total = kept + n;
+            kept = Math.min(OVERLAP, total);
+            buf.copy(buf, 0, total - kept, total);
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Les fichiers à lire : ceux que git suit, ou tout le dossier (sans .git ni node_modules) hors d'un dépôt. */
+function candidates(root) {
+    if (gitRoot(root) === root) {
+        return execFileSync('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard'], { cwd: root, encoding: 'utf8', maxBuffer: 1 << 30 })
+            .split('\0')
+            .filter((f) => f !== '' && existsSync(join(root, f)));
+    }
+    const files = [];
+    const walk = (dir) => {
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+            if (e.name === '.git' || e.name === 'node_modules')
+                continue;
+            if (e.isDirectory())
+                walk(join(dir, e.name));
+            else if (e.isFile())
+                files.push(relative(root, join(dir, e.name)).split('\\').join('/'));
+        }
+    };
+    walk(root);
+    return files;
+}
+/** Ce que la migration ferait, sans rien modifier. Rejouable : un plan déjà déplacé ne laisse que les lecteurs restants. */
+export function planMigration(root) {
+    const hasLegacy = existsSync(join(root, PLAN_LEGACY));
+    const hasDefault = existsSync(join(root, PLAN_DEFAULT));
+    if (hasLegacy && hasDefault)
+        throw new RafError(`${PLAN_LEGACY} et ${PLAN_DEFAULT} existent tous deux : migration refusée, fusionner ou supprimer l'un des deux d'abord`);
+    if (!hasLegacy && !hasDefault)
+        throw new RafError(`aucun plan à migrer : ni ${PLAN_LEGACY} ni ${PLAN_DEFAULT} sous ${root}`);
+    const config = readMigrateConfig(join(root, 'cadence.yaml'));
+    const isKept = docSyncSet(config.keep);
+    const isHistory = docSyncSet(HISTORY);
+    const result = { move: hasLegacy ? (gitRoot(root) && isTracked(root, PLAN_LEGACY) ? 'git mv' : 'mv') : null, readers: [], kept: [], unhandled: [] };
+    for (const file of candidates(root).sort()) {
+        if (file === PLAN_LEGACY || file === PLAN_DEFAULT || isHistory(file))
+            continue;
+        const path = join(root, file);
+        // ni lien symbolique (sa cible est lue sous son propre nom), ni dossier (sous-module), ni fichier hors du commun
+        const stat = lstatSync(path);
+        if (!stat.isFile())
+            continue;
+        // un gros fichier n'est jamais lu en entier ni décodé : cherché par blocs, signalé s'il cite le chemin, ignoré sinon
+        if (stat.size > MAX_BYTES) {
+            if (!citesPath(path))
+                continue;
+            if (isKept(file))
+                result.kept.push(file);
+            else
+                result.unhandled.push({ file, text: 'fichier de plus de 2 Mio qui cite le chemin : trop gros pour être réécrit' });
+            continue;
+        }
+        const buffer = readFileSync(path);
+        const text = buffer.toString('utf8');
+        if (!text.includes('docs/plan') && !BUILT.test(text))
+            continue;
+        if (isKept(file)) {
+            result.kept.push(file);
+            continue;
+        }
+        if (buffer.includes(0)) {
+            result.unhandled.push({ file, text: 'fichier binaire : le chemin ne peut pas y être réécrit' });
+            continue;
+        }
+        if (!Buffer.from(text, 'utf8').equals(buffer)) {
+            result.unhandled.push({ file, text: 'fichier non UTF-8 : le réécrire en altérerait les octets' });
+            continue;
+        }
+        // le texte entier, pas ligne par ligne : un chemin construit peut s'étendre sur plusieurs lignes ; signalé à la ligne où il commence
+        const lines = text.split('\n');
+        const seen = new Set();
+        for (const m of text.matchAll(OTHER)) {
+            const line = text.slice(0, m.index).split('\n').length;
+            if (seen.has(line))
+                continue;
+            seen.add(line);
+            result.unhandled.push({ file, line, text: lines[line - 1].trim().slice(0, 160) });
+        }
+        const count = text.match(REWRITABLE)?.length ?? 0;
+        if (count > 0)
+            result.readers.push({ file, count });
+    }
+    return result;
+}
+/** La sortie lisible de la migration (aussi pour --dry-run) : le déplacement, chaque fichier touché, ce qui est épargné. */
+export function describeMigration(m, dryRun) {
+    const out = [];
+    if (dryRun)
+        out.push('raf migrate --dry-run : rien n\'est modifié');
+    if (!m.move && m.readers.length === 0)
+        out.push(`rien à migrer : le plan est déjà à ${PLAN_DEFAULT} et aucun lecteur ne cite ${PLAN_LEGACY}`);
+    out.push(m.move ? `plan : ${m.move} ${PLAN_LEGACY} ${PLAN_DEFAULT}` : `plan : déjà à ${PLAN_DEFAULT}`);
+    if (m.readers.length === 0)
+        out.push('lecteurs : rien à mettre à jour');
+    else {
+        const refs = m.readers.reduce((n, r) => n + r.count, 0);
+        out.push(`lecteurs mis à jour : ${m.readers.length} fichiers, ${refs} références`);
+        for (const r of m.readers)
+            out.push(`  ${r.file} (${r.count})`);
+    }
+    if (m.kept.length > 0) {
+        out.push(`laissés tels quels (migrate.keep) : ${m.kept.length} fichiers`);
+        for (const f of m.kept)
+            out.push(`  ${f}`);
+    }
+    return out;
+}
+/** Le refus : un lecteur reste non traité. */
+export function unhandledError(m) {
+    const rows = m.unhandled.map((u) => `  ${u.file}${u.line === undefined ? '' : `:${u.line}`}  ${u.text}`);
+    return new RafError(`migration refusée, aucun fichier modifié : ${m.unhandled.length} lecteur(s) non traité(s) (à corriger à la main, ou à déclarer sous migrate.keep dans cadence.yaml s'ils ne lisent pas le plan) :\n${rows.join('\n')}`);
+}
+/** Déplace le plan puis réécrit les lecteurs. L'appelant a vérifié qu'aucun lecteur n'est non traité. */
+export function applyMigration(root, m) {
+    if (m.move) {
+        mkdirSync(join(root, dirname(PLAN_DEFAULT)), { recursive: true });
+        if (m.move === 'git mv')
+            execFileSync('git', ['mv', '--', PLAN_LEGACY, PLAN_DEFAULT], { cwd: root, stdio: ['ignore', 'pipe', 'pipe'] });
+        else
+            renameSync(join(root, PLAN_LEGACY), join(root, PLAN_DEFAULT));
+    }
+    for (const r of m.readers) {
+        const path = join(root, r.file);
+        writeFileSync(path, readFileSync(path, 'utf8').replace(REWRITABLE, PLAN_DEFAULT));
+    }
+}

package/dist/orchestrate/briefs.js

@@ -24,20 +24,53 @@ export function reposText(role, lot, repos) {
         `\`raf commits ${lot}\` lists them all; read the diff of the neighbouring ones with \`git -C <path> log\` / \`git -C <path> show\` (${repos.map((r) => `git -C ${r.path} log`).join(' ; ')}), and review them like the rest. You are read-only there too.`,
     ].join('\n');
 }
+/** Revue courte du diff rebasé (L279, R17) : la branche du lot vient d'être rebasée sur celle du dépôt et son diff n'est plus celui que la revue a lu. */
+export function integrationText(base) {
+    return `Integration re-review: this lot's branch was just rebased onto \`${base}\`, which moved while the lot was being written, and the diff of the lot is no longer the one an earlier review read (context changed or a conflict was resolved). Review the rebased diff only (\`git diff ${base}...HEAD\`): report a finding only for what the rebase changed or broke in the lot's own change. The program has already re-run the tests and the build on the rebased tip.`;
+}
+/** Consigne du dossier temporaire (L242) : les sessions y rangent journaux de tests, dumps et exports, jamais dans le dépôt (4 « dépôt sale » le 18-10). */
+export function tmpText(dir) {
+    return `Temporary files: this session's \`TMPDIR\` is \`${dir}\` (short and outside the repository, never tracked by git, already created and exported; removed when the pass ends). Write test logs, dumps, exports and any scratch file there (\`> $TMPDIR/suite.txt\`), never inside the repository: not in its \`tmp/\`, not at its root. Leave the working tree with only the files of the lot.`;
+}
 /** Consigne d'implémentation d'un lot `visible` : son entrée Nouveautés (convention de `cadence news`, voir docs/news.md du paquet @sylad/cadence). */
 export function newsText(lot, captureDir) {
     return [
         `This lot is visible: write its News entry. Run \`cadence news new ${lot}\` (it creates \`docs/nouveautes/<date>-<slug>.md\`), then write the text in terms of what changes for the user, factual (what the user sees or can now do, no implementation detail, no promise).`,
         `The entry's title is user-side: \`cadence news new\` takes the lot's public title when it has one; otherwise rewrite the title in the user's words with \`--title\` (never the internal title of the lot).`,
         captureDir
-            ? `Add a screenshot of the result: copy it into \`docs/nouveautes/captures/\` and list it under \`captures:\` (a Playwright capture lands in the wave's output directory, outside the repository: \`${captureDir}\`, which this session may read; the file you keep for the entry is the one exception, copied into \`docs/nouveautes/captures/\`); if a screenshot makes no sense (or the app cannot be run), write \`nocapture: <reason>\` instead.`
+            ? `Add a screenshot of the result: copy it into \`docs/nouveautes/captures/\` and list it under \`captures:\` (a capture taken with the absolute path given above lands in the wave's output directory, outside the repository: \`${captureDir}\`, which this session may read; the file you keep for the entry is the one exception, copied into \`docs/nouveautes/captures/\`); if a screenshot makes no sense (or the app cannot be run), write \`nocapture: <reason>\` instead.`
             : `Add a screenshot of the result: save it under the OS temp directory (never inside the repository), then copy it into \`docs/nouveautes/captures/\` and list it under \`captures:\` (the file you keep for the entry is the one exception to "nothing inside the repository"); if a screenshot makes no sense (or the app cannot be run), write \`nocapture: <reason>\` instead.`,
         'Commit the entry with the lot (`cadence news check` must pass).',
     ].join('\n');
 }
 /** Consigne des briefs de correction d'un lot `visible` : où la vague range les captures Playwright (même dossier que l'étape implement). */
 export function capturesText(captureDir) {
-    return `Playwright captures of this wave land in \`${captureDir}\` (outside the repository; this session may read it): a screenshot a finding asks for is copied from there into \`docs/nouveautes/captures/\`.`;
+    return `A Playwright capture taken with the absolute path given above lands in \`${captureDir}\` (outside the repository; this session may read it): a screenshot a finding asks for is copied from there into \`docs/nouveautes/captures/\`.`;
+}
+/**
+ * Consigne de nommage des captures Playwright (L249). Mesuré sur @playwright/mcp 0.0.83 : `--output-dir` ne sert qu'aux fichiers que le serveur nomme lui-même ;
+ * un nom donné par la session est résolu sur la racine de travail du serveur (le dépôt), d'où cinq lots sur cinq le 23-10 avec des captures à la racine. La session donne donc le chemin absolu du dossier de la vague, que le serveur autorise.
+ */
+export function shotsText(captureDir) {
+    return `The Playwright server resolves a file name you give it against the repository, not against its output directory: a bare name such as page-home.png lands at the repository root. Give every screenshot, snapshot and trace the absolute path of the wave's capture directory, \`${captureDir}/\`, followed by the name (e.g. \`${captureDir}/page-home.png\`): the server allows it, and the repository stays clean. Never the \`--output-dir\` option (the server's launch argument, which a session cannot set).`;
+}
+/** Précheck : la session lit le lot dans le plan (Sonnet, qui a la place pour un plan de plusieurs centaines de ko). */
+export const PLAN_READING = 'Read the lot, its notes and sub-tasks in the plan (`.cadence/raf.yaml`, the legacy `docs/plan/raf.yaml`, or the file named by `plan:` in `cadence.yaml`),';
+/**
+ * Précheck sur le modèle local (L322) : le lot est dans le brief et la session n'ouvre pas le plan. Un plan de 474 ko lu en entier remplissait la fenêtre de 64 k
+ * de qwen3-coder:30b (7 « Autocompact is thrashing » sur 32 lots, 23 au 25-10) ; les lectures du dépôt restent courtes pour la même raison.
+ */
+export function localReading(lot) {
+    const notes = lot.notes.slice(-5).map((n) => `- ${n.date ? `${n.date} : ` : ''}${n.text.length > 1500 ? `${n.text.slice(0, 1500)} […]` : n.text}`);
+    const tasks = lot.tasks.map((t) => `- ${t.id} [${t.status}] ${t.title}`);
+    return [
+        'Here is the lot as written in the plan; do not open the plan file (hundreds of kB: it would fill your context window).',
+        `Title: ${lot.title}`,
+        ...(lot.goal ? [`Goal: ${lot.goal}`] : []),
+        ...(notes.length ? ['Notes:', ...notes] : []),
+        ...(tasks.length ? ['Sub-tasks:', ...tasks] : []),
+        'Keep every read small (`grep -n`, `git log --oneline -S`, a few dozen lines at a time, never a whole large file),',
+    ].join('\n');
 }
 const FILES = {
     precheck: 'precheck.md',
@@ -50,6 +83,7 @@ const FILES = {
     implement: 'implement.md',
     fix: 'fix.md',
     'fix-minors': 'fix-minors.md',
+    'fix-docs': 'fix-docs.md',
     review: 'review.md',
     ux: 'ux.md',
     'review-small': 'review-small.md',
@@ -75,7 +109,7 @@ export function loadTemplates(dir = TEMPLATES_DIR) {
 export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     const text = typeof source === 'string' ? loadTemplates(source)[kind] : source[kind];
     const out = text.replace(/\{\{(\w+)\}\}/g, (_m, name) => {
-        const v = { ...vars, repos: vars.repos ?? '', docs: vars.docs ?? '', spec: vars.spec ?? '', accept: vars.accept ?? '', maquette: vars.maquette ?? '', fiche: vars.fiche ?? '' }[name];
+        const v = { ...vars, repos: vars.repos ?? '', integration: vars.integration ?? '', docs: vars.docs ?? '', elsewhere: vars.elsewhere ?? '', ack: vars.ack ?? '', spec: vars.spec ?? '', accept: vars.accept ?? '', maquette: vars.maquette ?? '', tmp: vars.tmp ?? '', shots: vars.shots ?? '', fiche: vars.fiche ?? '', lecture: vars.lecture ?? PLAN_READING }[name];
         if (v === undefined)
             throw new RafError(`gabarit ${FILES[kind]} : valeur manquante pour {{${name}}}`);
         return v;
@@ -83,9 +117,15 @@ export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     // Un marqueur vide ne laisse pas de trou : lignes vides en double ramenées à une.
     return `${out.replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim()}\n`;
 }
-/** `{{objectif}}` : le titre du lot, ses notes et ses sous-tâches — Sylvain n'écrit rien d'autre. */
-export function objective(lot) {
-    const lines = [`${lot.title}`];
+/**
+ * L'objectif d'un lot (L258) : celui gardé dans l'état du lot (`LotState.goal`, fixé au lancement : `--goal`, sinon la clé `goal:` du plan),
+ * sinon son titre. Une seule source pour les briefs, la simulation et le tableau : la clé `goal:` du plan n'est pas relue en cours de vague,
+ * donc une reprise rejoue l'objectif du lancement.
+ */
+export const headline = (lot, goal) => goal ?? lot.title;
+/** `{{objectif}}` : l'objectif du lot (`headline`, le titre faute d'autre), ses notes et ses sous-tâches — Sylvain n'écrit rien d'autre. */
+export function objective(lot, goal) {
+    const lines = [headline(lot, goal)];
     if (lot.notes.length)
         lines.push('', 'Notes of the lot (decisions included):', ...lot.notes.map((n) => `- ${n.date}: ${n.text}`));
     if (lot.tasks.length)

package/dist/orchestrate/changelog-merge.js

@@ -0,0 +1,94 @@
+/** 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'];
+/** 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');
+    const at = lines.findIndex((l) => /^## \[Unreleased\]/i.test(l));
+    if (at < 0)
+        return null;
+    let end = lines.findIndex((l, i) => i > at && l.startsWith('## '));
+    if (end < 0)
+        end = lines.length;
+    return { head: lines.slice(0, at + 1).join('\n'), block: lines.slice(at + 1, end), tail: lines.slice(end).join('\n') };
+}
+/** Sections du bloc `[Unreleased]` : une entrée est une ligne `- ` et ses lignes de suite. Deux titres identiques sont fondus. Du texte hors entrée : null. */
+function sections(block) {
+    const out = new Map();
+    let current = null;
+    for (const line of block) {
+        if (line.trim() === '')
+            continue;
+        const title = /^### (.+?)\s*$/.exec(line)?.[1];
+        if (title) {
+            current = out.get(title) ?? [];
+            out.set(title, current);
+        }
+        else if (!current) {
+            return null;
+        }
+        else if (line.startsWith('- ')) {
+            current.push(line);
+        }
+        else if (current.length > 0) {
+            current[current.length - 1] += `\n${line}`;
+        }
+        else {
+            return null;
+        }
+    }
+    return out;
+}
+/** `base` est une sous-suite de `side` : rien n'a été retiré ni modifié, seul de l'ajout s'y est glissé. */
+function onlyAdds(base, side) {
+    let i = 0;
+    for (const e of side)
+        if (i < base.length && e === base[i])
+            i++;
+    return i === base.length;
+}
+/** 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)
+        return ours;
+    if (ours === base)
+        return theirs;
+    if (theirs === base)
+        return ours;
+    return null;
+}
+/**
+ * Fusion à trois du CHANGELOG quand deux lots y ont chacun ajouté une entrée sous `[Unreleased]` (L314) : union par section, un seul titre par section,
+ * sections dans l'ordre de Keep a Changelog, les entrées de `ours` puis celles de `theirs` qui n'y sont pas déjà. Le reste du fichier suit le côté qui l'a
+ * changé. Rend null quand ce n'est pas de l'ajout pur — une entrée de base retirée ou modifiée, du texte libre sous `[Unreleased]`, le reste du fichier
+ * changé des deux côtés, pas de section `[Unreleased]` — : le conflit reste alors à la main.
+ *
+ * `start` est le CHANGELOG du point de départ de la branche rejouée (L323). Une entrée de `base` qui n'y était pas a été ajoutée par un commit précédent du
+ * lot lui-même : `theirs` peut la modifier ou la retirer, sa version gagne (l'ancienne est écartée de `ours`). Sans `start`, aucune entrée n'est au lot.
+ */
+export function mergeUnreleased(base, ours, theirs, start) {
+    const [b, o, t] = [split(base), split(ours), split(theirs)];
+    if (!b || !o || !t)
+        return null;
+    const head = pick(b.head, o.head, t.head);
+    const tail = pick(b.tail, o.tail, t.tail);
+    const [bs, os, ts] = [sections(b.block), sections(o.block), sections(t.block)];
+    if (head === null || tail === null || !bs || !os || !ts)
+        return null;
+    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)));
+    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) ?? [])) {
+            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`;
+    });
+    return `${head}\n\n${body.join('\n')}\n${tail}`;
+}