@sylad/cadence 1.41.0 → 1.43.0

package/dist/orchestrate/status.js

@@ -0,0 +1,264 @@
+import { basename } from 'node:path';
+import { gitRoot } from '../git.js';
+import { localOverdueLines } from '../local-task.js';
+import { RafError } from '../plan.js';
+import { findProjects, isProject as isLeadProject } from '../lead.js';
+import { freeLine, readyFree } from '../ready-free.js';
+import { cadenceHome, expiredHolds, freeSlots, liveHolds, liveSlots, liveWaves } from './registry.js';
+import { longDuration } from './guard.js';
+import { keptLines } from './worktree.js';
+import { lotFinished, lotKey, RunStore } from './state.js';
+import { launchPrices, renderDetail, renderTable, resumeCommand } from './table.js';
+import { waveReadsAnswerQueue, waveReadsControl } from './snapshot.js';
+import { DEFAULT_MAX_SESSIONS, parseMaxSessions } from './command-args.js';
+export function maxSessions(args, io) {
+    if (args.maxSessions !== undefined)
+        return args.maxSessions;
+    const env = io.env.CADENCE_MAX_SESSIONS;
+    return env ? parseMaxSessions(env, 'CADENCE_MAX_SESSIONS') : DEFAULT_MAX_SESSIONS;
+}
+/** Plafond à AFFICHER (`--status`, `lead tour`) : le réglage de l'humain, jamais 2 en dur. Un réglage invalide ne casse pas l'affichage (le lancement, lui, le refuse) : retour au défaut. */
+export function configuredCap(env, flag) {
+    if (flag !== undefined)
+        return flag;
+    try {
+        return env.CADENCE_MAX_SESSIONS ? parseMaxSessions(env.CADENCE_MAX_SESSIONS, 'CADENCE_MAX_SESSIONS') : DEFAULT_MAX_SESSIONS;
+    }
+    catch {
+        return DEFAULT_MAX_SESSIONS;
+    }
+}
+export function duration(ms) {
+    const s = Math.round(ms / 1000);
+    return s < 60 ? `${s} s` : `${Math.floor(s / 60)} min ${String(s % 60).padStart(2, '0')} s`;
+}
+/** La ligne des créneaux (L141, L255) et leur nombre libre : toujours, même sans vague ni session du lead (L416 : « libres : 3 sur 3 » se lit, il ne se déduit pas d'une absence de ligne). */
+export function slotsLine(cap = DEFAULT_MAX_SESSIONS, now = new Date()) {
+    const home = cadenceHome();
+    const holds = liveHolds(home, now);
+    const free = freeSlots(liveWaves(home), cap, holds.length);
+    const lead = holds.length ? ` · sessions du lead : ${holds.length} (${holds.map((h) => h.label).join(', ')})` : '';
+    return { line: `vagues en cours : ${liveWaves(home).length} · sessions en cours : ${liveSlots(home).length}${lead} · créneaux libres : ${free} sur ${cap}`, free };
+}
+/** Vagues vivantes (toutes, quel que soit leur dossier de départ), sessions du lead (L255), créneaux libres et dépôts qu'elles tiennent. Rien sans vague ni session du lead. */
+export function liveLines(cap = DEFAULT_MAX_SESSIONS, now = new Date()) {
+    const home = cadenceHome();
+    const waves = liveWaves(home);
+    if (waves.length === 0 && liveHolds(home, now).length === 0)
+        return [];
+    const lines = [slotsLine(cap, now).line];
+    for (const w of waves)
+        lines.push(`  ${w.wave} (pid ${w.pid}, depuis ${w.started}) lancée depuis ${w.cwd} · plafond ${w.cap ?? '?'} · dépôts : ${w.repos.join(', ')}`);
+    return lines;
+}
+/** Une ligne ⚠ par session du lead dont le TTL est échu et qui n'a pas été rendue (L278) : vide sans session échue. */
+export function expiredHoldLines(now = new Date()) {
+    return expiredHolds(cadenceHome(), now).map((h) => {
+        const since = Date.parse(h.since);
+        const age = Number.isFinite(since) ? `inscrite depuis ${longDuration(now.getTime() - since)}, ` : '';
+        return `⚠ session du lead échue : ${h.label} (${age}échue depuis ${longDuration(now.getTime() - Date.parse(h.expires))}) — la reprendre (cadence lead hold ${h.label} --ttl <minutes>) ou l'arrêter (cadence lead release ${h.label})`;
+    });
+}
+/** `--continue` (L252) : la ligne des lots prêts dont aucune ressource n'est prise par un lot en cours ni par une vague, sans les lots du premier tirage `drawn` ni les ressources qu'ils tiennent. Vide si aucun. */
+export function freeLines(launch, drawn) {
+    const dirs = isLeadProject(launch) ? [launch] : findProjects(launch);
+    const free = readyFree(dirs, cadenceHome(), drawn);
+    const line = freeLine(dirs.filter((d) => free.has(d)).map((d) => ({ project: basename(d), free: free.get(d) })), 60);
+    return line ? [line] : [];
+}
+/** Efface l'écran et replace le curseur en haut : l'entrée d'un rendu de `--status --watch`. */
+const CLEAR_SCREEN = '\x1b[H\x1b[2J';
+const DEFAULT_WATCH_INTERVAL = 10;
+/** Ce que `--status` montre à un instant : les vagues vivantes, puis le tableau (absent si seules les vagues vivantes comptent). */
+function statusView(args, launch, cap, now) {
+    const id = statusWave(args);
+    const store = id !== undefined ? RunStore.find(launch, id) : RunStore.last(launch);
+    const live = [...liveLines(cap, now), ...expiredHoldLines(now), ...localOverdueLines((isLeadProject(launch) ? [launch] : findProjects(launch)).map((d) => gitRoot(d) ?? d), now)];
+    const waveLive = liveWaves(cadenceHome()).length > 0;
+    if (!store && live.length && id === undefined)
+        return { live, running: waveLive };
+    if (!store)
+        throw new RafError(id !== undefined ? `vague inconnue : ${id}` : 'aucune vague dans ce dossier');
+    // `running` : la vague suivie tourne — pour un <id> explicite, elle seule compte, pas les autres vagues de la machine
+    const running = id !== undefined ? liveWaves(cadenceHome()).some((w) => w.wave === store.readWave().id) : waveLive;
+    const lots = store.lots();
+    if (args.detail !== undefined) {
+        try {
+            return { live: [], table: renderDetail(lots, args.detail), running };
+        }
+        catch (e) {
+            throw new RafError(e.message);
+        }
+    }
+    return { live, table: [...renderTable(store.readWave(), lots, { compact: true, prices: launchPrices(launch, (w) => live.push(`⚠ ${w}`)) }), ...keptLines(lots.map((l) => l.repo), now.getTime())], running };
+}
+/** La vague que `--status` suit (L395) : `--status <id>` ou `--status --wave <id>` ; aucune : la dernière du dossier. Deux ids différents : refus. */
+function statusWave(args) {
+    if (typeof args.status === 'string' && args.wave !== undefined && args.status !== args.wave)
+        throw new RafError(`--status ${args.status} et --wave ${args.wave} désignent deux vagues : une seule`);
+    return typeof args.status === 'string' ? args.status : args.status === true ? args.wave : undefined;
+}
+/** Refus d'une `--wave` déjà existante, identique en simulation et au vrai lancement. */
+export function waveExists(wave, io) {
+    io.err(`orchestrate : --wave ${wave} : cette vague existe déjà`);
+    return 2;
+}
+/** L382 : `claude auth status` peut durer jusqu'à 20 s ; en --continue, preflight() le relancerait pour chaque lot candidat de chaque tour. Une seule lecture par lancement (une vague). */
+export function onceAuth(deps) {
+    const read = deps.claudeAuth;
+    if (!read)
+        return deps;
+    let cached;
+    return { ...deps, claudeAuth: () => (cached ??= { value: read() }).value };
+}
+/** `--status` (L395) : le tableau des vagues vivantes et de la vague suivie, une fois ou rafraîchi avec `--watch` jusqu'à ce que plus rien ne tourne. */
+export async function statusCommand(args, io, deps, launch) {
+    maxSessions(args, io); // une valeur invalide est refusée ici aussi
+    const view = () => statusView(args, launch, configuredCap(io.env, args.maxSessions), io.now());
+    if (!args.watch) {
+        const { live, table } = view();
+        printStatus(io, live, table); // sans identifiant (pas de tableau) : les vagues vivantes suffisent
+        return 0;
+    }
+    // --watch : le même tableau, rafraîchi ; il s'arrête seul quand plus aucune vague ne tourne (le dernier rendu reste affiché)
+    const sleep = deps.watchSleep ?? ((ms) => new Promise((res) => setTimeout(res, ms)));
+    const seconds = args.interval ?? DEFAULT_WATCH_INTERVAL;
+    for (;;) {
+        const { live, table, running } = view();
+        io.out(CLEAR_SCREEN);
+        printStatus(io, live, table);
+        if (!running)
+            return 0;
+        io.out('');
+        io.out(`rafraîchi toutes les ${seconds} s — Ctrl-C pour quitter`);
+        await sleep(seconds * 1000);
+    }
+}
+/** Les vagues vivantes, puis (s'il y en a un) le tableau de la vague suivie, séparés d'une ligne vide. */
+function printStatus(io, live, table) {
+    for (const line of live)
+        io.out(line);
+    if (!table)
+        return;
+    if (live.length)
+        io.out('');
+    for (const line of table)
+        io.out(line);
+}
+/**
+ * `--answer` sur une vague VIVANTE (L407) : la réponse est déposée dans la file de la vague (`answers.log`), qui la prend entre deux étapes et rejoue le lot dès qu'un créneau est libre.
+ * Sans cela le lead attendait la fin de la vague (15 min d'un lot bloqué le 28-10). Les lots visés sont contrôlés comme à la reprise : connus, en question.
+ */
+export function answerLive(args, io, store) {
+    const lots = store.lots();
+    const refusals = [];
+    const keys = [];
+    for (const a of args.answers) {
+        const matches = lots.filter((l) => l.lot === a.lot && (a.project ? l.project === a.project : true));
+        const where = `${a.project ? `${a.project}:` : ''}${a.lot}`;
+        if (matches.length !== 1)
+            refusals.push(matches.length ? `--answer ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--answer ${where} : lot inconnu dans la vague ${store.id}`);
+        else if (matches[0].status !== 'question')
+            refusals.push(`--answer ${lotKey(matches[0].project, matches[0].lot)} : le lot n'attend pas de réponse (${matches[0].status})`);
+        else
+            keys.push({ key: lotKey(matches[0].project, matches[0].lot), text: a.text });
+    }
+    if (!waveReadsAnswerQueue(store.dir))
+        refusals.push(`la vague ${store.id} ne lit pas la file de réponses (lancée avec une version de cadence d'avant L407) : attendre sa fin, puis ${resumeCommand(store.id, '--answer', '<projet>:<lot>', '"…"')}`);
+    if (refusals.length) {
+        for (const r of refusals)
+            io.err(`orchestrate : ${r}`);
+        return 2;
+    }
+    for (const { key, text } of keys) {
+        const id = store.requestAnswer(key, text);
+        // La vague a pu finir entre le contrôle et le dépôt : sa file ne sera plus lue, la réponse est retirée et le lead reprend à la main.
+        if (!liveWaves(cadenceHome()).some((w) => w.wave === store.id)) {
+            store.markAnswerTaken(id);
+            io.err(`orchestrate : ${key} : la vague ${store.id} vient de finir, réponse non prise : ${resumeCommand(store.id, '--answer', key, '"…"')}`);
+            return 2;
+        }
+        store.journal(`demande : réponse du lead pour ${key}`);
+        io.out(`${key} : réponse déposée — la vague ${store.id} la prend entre deux étapes et rejoue le lot dès qu'un créneau est libre`);
+    }
+    return 0;
+}
+/** La vague vivante, pour `--answer` seul (sans --resume) : la même recherche que `--drop`. */
+export function answerOnly(args, io) {
+    if (args.drop.length || args.stopAfterCurrent || args.budget !== undefined || args.dryRun || args.continue || args.lots.length)
+        throw new RafError("--answer ne se combine pas avec --drop, --stop-after-current, --budget, --dry-run, --continue ni des lots à lancer (sur une vague arrêtée : --resume --answer)");
+    const store = liveStore('--answer', args, io);
+    if (typeof store === 'number') {
+        io.err(`orchestrate : --answer : une vague arrêtée se reprend avec ${resumeCommand('<vague>', '--answer', '<projet>:<lot>', '"…"')}`);
+        return store;
+    }
+    return answerLive(args, io, store);
+}
+/** La vague vivante lancée depuis ce dossier que vise `--wave` (ou la seule) ; sinon le refus (code 2) déjà écrit. */
+export function liveStore(flags, args, io) {
+    const live = liveWaves(cadenceHome()).filter((w) => w.cwd === io.cwd && (args.wave === undefined || w.wave === args.wave));
+    if (live.length === 0) {
+        io.err(`orchestrate : ${flags} : aucune vague en cours${args.wave ? ` (${args.wave})` : ''} lancée depuis ce dossier`);
+        return 2;
+    }
+    if (live.length > 1) {
+        io.err(`orchestrate : ${flags} : plusieurs vagues tournent depuis ce dossier (${live.map((w) => w.wave).join(', ')}) : précisez --wave`);
+        return 2;
+    }
+    const store = RunStore.find(io.cwd, live[0].wave);
+    if (!store) {
+        io.err(`orchestrate : ${flags} : dossier d'état de la vague ${live[0].wave} introuvable`);
+        return 2;
+    }
+    return store;
+}
+/** `--drop` / `--stop-after-current` (L79) : une demande écrite dans le dossier d'état de la vague vivante ; c'est elle qui la lit avant sa prochaine session. */
+export function control(args, io) {
+    const flags = '--drop / --stop-after-current';
+    if (args.lots.length || args.continue || args.dryRun || args.budget !== undefined || args.answers.length)
+        throw new RafError(`${flags} ne se combinent pas avec des lots à lancer, --continue, --dry-run, --budget ou --answer`);
+    const store = liveStore(flags, args, io);
+    if (typeof store === 'number')
+        return store;
+    const lots = store.lots();
+    const refusals = [];
+    const keys = [];
+    for (const d of args.drop) {
+        const matches = lots.filter((l) => l.lot === d.lot && (d.project ? l.project === d.project : true));
+        const where = `${d.project ? `${d.project}:` : ''}${d.lot}`;
+        if (matches.length !== 1)
+            refusals.push(matches.length ? `--drop ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--drop ${where} : lot inconnu dans la vague ${store.id}`);
+        else if (lotFinished(matches[0]))
+            refusals.push(`--drop ${lotKey(matches[0].project, matches[0].lot)} : le lot est déjà fini (${matches[0].status})`);
+        else
+            keys.push(lotKey(matches[0].project, matches[0].lot));
+    }
+    if (refusals.length) {
+        for (const r of refusals)
+            io.err(`orchestrate : ${r}`);
+        return 2;
+    }
+    // La demande est écrite quoi qu'il arrive (le fichier est inoffensif) ; mais une vague d'avant L79 ne le lira jamais : on le dit.
+    if (!waveReadsControl(store.dir))
+        io.err(`orchestrate : ${flags} : la vague ${store.id} ne lit pas les demandes de contrôle (lancée avec une version de cadence d'avant L79) : la demande est écrite dans control.log mais cette vague ne la lira pas`);
+    for (const k of keys) {
+        store.requestDrop(k);
+        store.journal(`demande : retirer ${k} de la vague`);
+        io.out(`${k} : retrait demandé — la vague ${store.id} l'écarte avant sa prochaine session (la session en cours finit)`);
+    }
+    if (args.stopAfterCurrent) {
+        store.requestStopAfterCurrent();
+        store.journal('demande : arrêt après les sessions en cours');
+        io.out(`vague ${store.id} : arrêt demandé — les sessions en cours finissent, aucune autre ne part ; reprise par « ${resumeCommand(store.id)} »`);
+    }
+    return 0;
+}
+/** La seule vague non terminée du dossier (L309) ; plusieurs : refus qui les liste, aucune : refus (jamais le choix silencieux de la plus récente). */
+export function singleUnfinished(launch) {
+    const open = RunStore.unfinished(launch);
+    if (open.length === 0)
+        throw new RafError('aucune vague à reprendre dans ce dossier');
+    if (open.length > 1)
+        throw new RafError(`plusieurs vagues non terminées dans ce dossier, laquelle reprendre ?\n${open.map((s) => `  ${s.id} (${s.readWave()?.status ?? 'illisible'}, lancée ${s.readWave()?.created ?? '?'})`).join('\n')}\nreprise : ${resumeCommand('<vague>')}`);
+    return open[0];
+}

package/dist/plan-extras.js

@@ -1,8 +1,9 @@
+import { PLACE_KEY } from './archive.js';
 import { FIELDS, RafError } from './plan.js';
 const EXTRA_KEYS = ['enum', 'default'];
 const EXTRA_NAME = /^[a-z][a-z0-9_]*$/;
-/** Les clés que raf lit ou écrit sur un lot : un champ d'extension ne peut pas en prendre le nom. */
-const LOT_KEYS = ['tasks', 'uses', 'local', 'ux', 'review', 'docs_ok', 'extras', 'problems', 'state', 'state_before'];
+/** Les clés que raf lit ou écrit sur un lot (`place` : le rang d'un lot archivé sous `plan.idPattern`, L536) : un champ d'extension ne peut pas en prendre le nom. */
+const LOT_KEYS = ['tasks', 'uses', 'local', 'ux', 'review', 'docs_ok', 'extras', 'problems', 'state', 'state_before', PLACE_KEY];
 const nonEmptyText = (v) => typeof v === 'string' && v.trim() !== '';
 /** Une déclaration `plan.extras.<nom>` lue, ou l'erreur (message sans préfixe) qui la refuse. */
 function readDecl(name, decl) {

package/dist/plan-ids.js

@@ -0,0 +1,95 @@
+export function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Ce qui ne peut pas suivre un identifiant cité : un point suivi d'un caractère de mot — « L1.4 » n'est
+ * pas le lot L1, « NC2.4 » n'est pas NC2 — alors que le point qui finit une phrase (« voir L1. ») passe.
+ * Même garde pour le format de raf et pour les identifiants d'un plan en lecture seule.
+ */
+export const DOTTED = '\\.\\w';
+/** Matches `L3` or `L3/t1` as whole words. Group 1 = lot id, group 2 = task id. */
+function refPattern(prefix) {
+    return new RegExp(`(?<![\\w/])(${escapeRe(prefix)}\\d+)(?:/(t\\d+))?(?!\\w|${DOTTED})`, 'g');
+}
+export function extractRefs(text, prefix) {
+    return [...text.matchAll(refPattern(prefix))].map((m) => ({ lot: m[1], task: m[2] }));
+}
+/**
+ * Le motif des références d'un plan natif qui déclare `plan.idPattern` : `<préfixe>\d+` ou le motif du projet, puis un sous-id `/slug` facultatif
+ * (`X7/t1-fusion`). Garde des `<préfixe>\d+` : celle du format de raf (pas collés à un mot ni à un chemin, pas suivis d'un point et d'un mot ; « feat(L3-L5) » cite L3 et L5) ; les ids du motif du projet, plus strictes, refusent aussi un `-` ou un `.` avant et un `-` après (« AB-1-x »). Le point de fin de phrase passe.
+ * Seul le groupe nommé `sub` est capturé, après le motif du projet : ses groupes numérotés (`([A-Z])\1\d+`) gardent leur numéro. L'id est le reste de la correspondance.
+ */
+function idRefPattern(prefix, idPattern) {
+    const own = `(?<![\\w/])${escapeRe(prefix)}\\d+`;
+    const free = `(?<![\\w/.-])(?:${idPattern})(?=/|(?!-))`;
+    return new RegExp(`(?:${own}|${free})(?:/(?<sub>[\\w-]+(?:\\.[\\w-]+)*)(?![\\w-]|${DOTTED})|(?!\\w|${DOTTED}))`, 'g');
+}
+/** Références d'un message dans un plan natif qui déclare `plan.idPattern`. Un sous-id `t<n>` est une sous-tâche du lot ; tout autre (`t1-fusion`) n'est qu'une précision sur le lot cité. */
+export function idRefs(text, prefix, idPattern) {
+    return [...text.matchAll(idRefPattern(prefix, idPattern))].map((m) => {
+        const sub = m.groups.sub;
+        return { lot: sub === undefined ? m[0] : m[0].slice(0, -(sub.length + 1)), ...(/^t\d+$/.test(sub ?? '') ? { task: sub } : {}) };
+    });
+}
+/** Ce que le motif `plan.idPattern` a de refusable (ancres, groupe nommé `id` ou `sub` réservé, id vide), null s'il est utilisable. Vérifié à la lecture de cadence.yaml. */
+function idPatternProblem(idPattern) {
+    if (idPattern.trim() === '')
+        return 'est vide';
+    if (/^\^|(?<!\\)\$$/.test(idPattern))
+        return "ne prend pas d'ancre (^ ou $) : le motif est ancré par raf";
+    if (/\(\?<(?:id|sub)>/.test(idPattern))
+        return 'ne peut pas nommer un groupe « id » ou « sub » (noms réservés à raf)';
+    try {
+        idRefPattern('L', idPattern);
+        if (new RegExp(`^(?:${idPattern})$`).test(''))
+            return "accepte l'identifiant vide";
+    }
+    catch (e) {
+        return `n'est pas une expression régulière utilisable (${e.message.split('\n')[0]})`;
+    }
+    return null;
+}
+/** Pourquoi `id` ne peut pas être donné à `raf add --id` : sans `plan.idPattern`, avec un « / » (réservé aux sous-tâches), hors du motif, ou déjà pris (archivés compris). Null s'il est libre. */
+function freeIdProblem(id, idPattern, known) {
+    if (idPattern === undefined)
+        return '--id exige plan.idPattern dans cadence.yaml : sans motif déclaré, les identifiants sont <préfixe><n> générés par raf';
+    if (id.includes('/'))
+        return `identifiant invalide : ${id} (« / » est réservé aux sous-tâches)`;
+    if (!new RegExp(`^(?:${idPattern})$`).test(id))
+        return `identifiant invalide : ${id === '' ? '(vide)' : id} ne suit pas plan.idPattern (${idPattern})`;
+    return known.has(id) ? `identifiant déjà pris : ${id}` : null;
+}
+/**
+ * L'identifiant d'un lot ajouté : celui que `raf add --id` donne (libre, voir `freeIdProblem`), sinon `<préfixe><n+1>` ; `under`, le lot parent
+ * d'un sous-lot, doit exister. `known` : tous les lots du plan, archivés compris — un identifiant n'est jamais réutilisé.
+ */
+export function pickId(prefix, given, under, idPattern, known) {
+    if (under !== undefined && !known.has(under))
+        return { problem: `lot parent inconnu : ${under}` };
+    if (given !== undefined) {
+        const problem = freeIdProblem(given, idPattern, known);
+        return problem ? { problem } : { id: given };
+    }
+    const re = new RegExp(`^${escapeRe(prefix)}(\\d+)$`);
+    return { id: `${prefix}${Math.max(0, ...[...known].map((id) => Number(re.exec(id)?.[1] ?? 0))) + 1}` };
+}
+/** Le `parent:` d'un lot à plat : un identifiant de lot ; toute autre forme est un problème du lot et ne désigne aucun parent. */
+export function readParent(raw, problems) {
+    if (raw == null)
+        return {};
+    if (typeof raw === 'string' && raw.trim() !== '')
+        return { parent: raw.trim() };
+    problems.push(`parent : un identifiant de lot attendu (reçu « ${String(raw)} »)`);
+    return {};
+}
+/** `plan.idPattern` lu dans cadence.yaml : `{ idPattern }` (rien sans la clé), ou l'erreur que `bad` fabrique (qui nomme la clé). */
+export function readIdPattern(raw, bad) {
+    if (raw == null)
+        return {};
+    if (typeof raw !== 'string')
+        throw bad('idPattern doit être une expression régulière (texte)');
+    const problem = idPatternProblem(raw);
+    if (problem)
+        throw bad(`idPattern ${problem}`);
+    return { idPattern: raw };
+}

package/dist/plan-read.js

@@ -1,5 +1,6 @@
 import { isDay } from './dates.js';
 import { RESOURCE_NAME, RESOURCES_BAD_LIST, SCREENS, STATUSES } from './plan.js';
+import { readParent } from './plan-ids.js';
 const GATE_INVALID = 'gate invalide : count: entier ≥ 1 et un critère spec: true ou screen: page attendus';
 /** Lit `gate: { count: N, spec: true }` ou `{ count: N, screen: page }` ; toute autre forme est un problème du lot et une condition jamais remplie. */
 function readGate(raw, problems) {
@@ -68,6 +69,7 @@ export function normalizeLot(raw, problems = []) {
     const docsOk = okRaw && typeof okRaw === 'object' && typeof okRaw.reason === 'string' && okRaw.reason.trim() !== '' ? { date: String(okRaw.date ?? ''), reason: okRaw.reason.trim() } : undefined;
     return {
         id: String(raw.id),
+        ...readParent(raw.parent, problems),
         title: String(raw.title ?? ''),
         status,
         ...(typeof raw.state === 'string' && raw.state.trim() !== '' ? { state: raw.state.trim() } : {}),

package/dist/plan.js

@@ -8,7 +8,8 @@ import { normalizeLot } from './plan-read.js';
 import { currentState, defaultState, rebase, stateProblems, transitionProblem } from './plan-states.js';
 import { DOCS_OK_FILE, readDocsOkFile } from './docs-ok-file.js';
 import { checkedExtras, withExtras } from './plan-extras.js';
-import { ARCHIVE_DIR, archiveFiles, archiveLots, archiveYear, mergeArchived, newArchiveDoc, readArchiveDoc, selectArchivable } from './archive.js';
+import { DOTTED, escapeRe, extractRefs, idRefs, pickId } from './plan-ids.js';
+import { ARCHIVE_DIR, PLACE_KEY, archiveFiles, archiveLots, archiveYear, mergeArchived, newArchiveDoc, readArchiveDoc, reopenArchived, selectArchivable } from './archive.js';
 /** Délai de la commande `plan.onWrite` : une republication du plan, pas un build. */
 const ON_WRITE_TIMEOUT_MS = 120_000;
 /**
@@ -42,28 +43,13 @@ function cleanUses(names) {
     return [...new Set(names)];
 }
 const trueFlags = (flags) => Object.fromEntries(Object.entries(flags).filter(([, on]) => on).map(([k]) => [k, true])); // les drapeaux vrais, chacun à `true` : les absents et les faux ne s'écrivent pas
+export { escapeRe, extractRefs, readIdPattern } from './plan-ids.js';
 export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'screen', 'spec', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'repos', 'parent', 'gate', 'goal'];
 /** Nature de l'écran d'un lot visible : nouvelle page, nouveau composant, parcours modifié. */
 export const SCREENS = ['page', 'component', 'journey'];
 export function isOpen(status) {
     return status === 'todo' || status === 'doing';
 }
-export function escapeRe(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Ce qui ne peut pas suivre un identifiant cité : un point suivi d'un caractère de mot — « L1.4 » n'est
- * pas le lot L1, « NC2.4 » n'est pas NC2 — alors que le point qui finit une phrase (« voir L1. ») passe.
- * Même garde pour le format de raf et pour les identifiants d'un plan en lecture seule.
- */
-const DOTTED = '\\.\\w';
-/** Matches `L3` or `L3/t1` as whole words. Group 1 = lot id, group 2 = task id. */
-function refPattern(prefix) {
-    return new RegExp(`(?<![\\w/])(${escapeRe(prefix)}\\d+)(?:/(t\\d+))?(?!\\w|${DOTTED})`, 'g');
-}
-export function extractRefs(text, prefix) {
-    return [...text.matchAll(refPattern(prefix))].map((m) => ({ lot: m[1], task: m[2] }));
-}
 function initialContent(project, prefix, since) {
     return `# Plan « reste à faire » tenu par raf (https://github.com/Sylad/cadence).
 # Édité par le CLI, mais les modifications à la main et les commentaires sont préservés.
@@ -305,7 +291,7 @@ export class Plan {
      */
     refs = (text) => {
         if (!this.settings.format)
-            return extractRefs(text, this.prefix);
+            return this.settings.idPattern === undefined ? extractRefs(text, this.prefix) : idRefs(text, this.prefix, this.settings.idPattern);
         const { refs, tasks, ids } = this.read();
         if (!refs)
             return [];
@@ -395,7 +381,8 @@ export class Plan {
         // L396 : l'archive est un détail de stockage — les lots archivés reprennent leur place parmi ceux du fichier actif, comme un seul plan.
         const archived = this.loadArchives().flatMap((a) => archiveLots(a.doc).toJSON());
         const read = (r) => withExtras(normalizeLot(r), r, this.settings.extras);
-        const lots = mergeArchived(archived.map(read), this.activeRaw().map(read));
+        const places = new Map(archived.flatMap((r) => (typeof r[PLACE_KEY] === 'string' || r[PLACE_KEY] === null ? [[String(r.id), r[PLACE_KEY] ?? '']] : [])));
+        const lots = mergeArchived(archived.map(read), this.activeRaw().map(read), places);
         const model = this.settings.states;
         return model ? lots.map((l) => ({ ...l, problems: [...l.problems, ...stateProblems(model, l)] })) : lots;
     }
@@ -472,20 +459,11 @@ export class Plan {
     }
     /**
      * Un lot archivé qui n'est plus clos (`raf todo` sur un lot done archivé) revient à la fin du fichier du plan à l'écriture :
-     * l'archive ne porte que des lots done ou dropped, et le plan actif reste le seul fichier à porter du travail ouvert.
+     * l'archive ne porte que des lots done ou dropped, et le plan actif reste le seul fichier à porter du travail ouvert. Seul lui bouge :
+     * les lots archivés dont le `place:` le nommait (L536) sont re-pointés sur le lot qui le précédait, et gardent leur place dans le plan présenté.
      */
     reopened() {
-        const active = this.doc.get('lots');
-        for (const a of this.archives ?? []) {
-            const seq = archiveLots(a.doc);
-            const back = seq.items.filter((n) => isMap(n) && !['done', 'dropped'].includes(String(n.get('status'))));
-            if (back.length === 0)
-                continue;
-            seq.items = seq.items.filter((n) => !back.includes(n));
-            for (const n of back)
-                active.add(n);
-            a.dirty = true;
-        }
+        reopenArchived(this.archives ?? [], this.doc.get('lots'), () => this.lots().map((l) => l.id));
     }
     /**
      * `raf archive` : déplace les lots done et dropped du fichier du plan (terminés avant `before` s'il est donné) vers le fichier de leur année
@@ -506,8 +484,13 @@ export class Plan {
         // De quoi revenir en arrière en mémoire : les items du plan, ceux de chaque archive déjà chargée, et le nombre d'archives (les nouvelles s'ajoutent à la fin).
         const archives = this.loadArchives();
         const snapshot = { items: [...seq.items], archives: archives.map((a) => ({ a, items: [...archiveLots(a.doc).items], dirty: a.dirty })) };
+        // Sous plan.idPattern, le nombre final d'un id ne dit rien de l'ordre : chaque lot archivé garde le lot qui le précède dans le plan
+        // PRÉSENTÉ (archivés compris, ordre d'avant ce passage), pas dans le fichier seul — deux passages successifs gardent ainsi l'ordre du plan.
+        const merged = this.settings.idPattern === undefined ? [] : this.lots().map((l) => l.id);
         for (const n of nodes) {
             const lot = move.find((l) => l.id === String(n.get('id')));
+            if (this.settings.idPattern !== undefined)
+                n.set(PLACE_KEY, merged[merged.indexOf(lot.id) - 1] ?? '');
             const target = this.archiveFor(archiveYear(lot, today));
             archiveLots(target.doc).add(n);
             target.dirty = true;
@@ -563,15 +546,18 @@ export class Plan {
         for (const dep of opts.after ?? [])
             if (!known.has(dep))
                 throw new RafError(`dépendance inconnue : ${dep}`);
-        const re = new RegExp(`^${escapeRe(this.prefix)}(\\d+)$`);
-        const max = Math.max(0, ...[...known].map((id) => Number(re.exec(id)?.[1] ?? 0)));
-        const id = `${this.prefix}${max + 1}`;
+        const picked = pickId(this.prefix, opts.id, opts.under, this.settings.idPattern, known);
+        if ('problem' in picked)
+            throw new RafError(picked.problem);
+        const { id } = picked;
         const pub = opts.public === undefined ? undefined : cleanPublic(opts.public);
         if (opts.every !== undefined && !(Number.isInteger(opts.every) && opts.every > 0)) {
             throw new RafError(`périodicité invalide : ${opts.every} (un nombre entier de jours, 1 au moins)`);
         }
         const extras = checkedExtras(this.settings.extras, opts.extras);
         const entry = { id, title };
+        if (opts.under !== undefined)
+            entry.parent = opts.under;
         if (pub !== undefined)
             entry.public = pub;
         Object.assign(entry, { status: 'todo', estimate: opts.estimate ?? 1 }, trueFlags({ quickwin: opts.quickwin, visible: opts.visible }));
@@ -595,6 +581,15 @@ export class Plan {
         this.doc.get('lots').add(node);
         return id;
     }
+    /** Remplace l'estimation (en jours) d'un lot de tout statut, archivé compris ; jamais sur une sous-tâche. */
+    setEstimate(ref, days) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`l'estimation se pose sur un lot, pas une sous-tâche : ${ref}`);
+        if (!(Number.isFinite(days) && days > 0))
+            throw new RafError(`estimation invalide : ${days} (un nombre de jours > 0)`);
+        this.lotNode(ref).set('estimate', days);
+    }
     /** Déclare les dépôts voisins d'un lot (clé `repos:`) : un chemin seul, ou `{ path, cite }` quand le voisin est partagé. */
     setRepos(lotId, repos) {
         this.writable();

package/dist/ref/command.js

@@ -1,10 +1,9 @@
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { RafError } from '../plan.js';
 import { AGENTS_DIR } from '../skills.js';
-import { realClaude, readAgents } from '../orchestrate/launch.js';
+import { claudeConfigDir, realClaude, readAgents } from '../orchestrate/launch.js';
 import { add } from './add.js';
 import { analyse } from './analyse.js';
 import { checkInventaire, readInventaire, summaryInventaire } from './check.js';
@@ -33,7 +32,7 @@ export function refCommand(rest, values, root, io) {
     }
     if (verb === 'analyse' && args.length === 1) {
         const claude = realClaude(io.env.CADENCE_CLAUDE_BIN || 'claude', io.env);
-        return analyse({ document: args[0], slug: values.slug, sections: values.sections, model: values.model, modelB: values['model-b'], double: values.double === true, seuil: values.seuil, env: io.env, cwd: io.cwd, refsDir, configPath, claudeHome: io.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), now: io.now(), out: io.out, err: io.err, claude, agents: readAgents(AGENTS_DIR) });
+        return analyse({ document: args[0], slug: values.slug, sections: values.sections, model: values.model, modelB: values['model-b'], double: values.double === true, seuil: values.seuil, env: io.env, cwd: io.cwd, refsDir, configPath, claudeHome: claudeConfigDir(io.env), now: io.now(), out: io.out, err: io.err, claude, agents: readAgents(AGENTS_DIR) });
     }
     if (verb === 'measure' && args.length === 3) {
         measure({ slug: args[0], page: args[1], zone: args[2], quoi: values.quoi, largeur: values.largeur, env: io.env, refsDir, json: values.json === true, out: io.out });

package/dist/resources.js

@@ -1,6 +1,6 @@
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { parse } from 'yaml';
+import { readYamlFile } from './yaml-keys.js';
 import { isOpen, RafError, RESOURCE_NAME, RESOURCES_BAD_LIST } from './plan.js';
 /**
  * Clé `resources:` du cadence.yaml le plus proche en remontant depuis le dossier parent de `root` : le premier fichier qui porte la clé
@@ -12,13 +12,7 @@ export function readResources(root) {
     for (let dir = dirname(root);; dir = dirname(dir)) {
         const file = join(dir, 'cadence.yaml');
         if (existsSync(file) && statSync(file).isFile()) {
-            let raw;
-            try {
-                raw = parse(readFileSync(file, 'utf8'));
-            }
-            catch (e) {
-                throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-            }
+            const raw = readYamlFile(file);
             if (raw != null && typeof raw === 'object' && Object.hasOwn(raw, 'resources')) {
                 const list = raw.resources ?? [];
                 if (!Array.isArray(list) || !list.every((n) => typeof n === 'string' && RESOURCE_NAME.test(n)))

package/dist/state.js

@@ -52,7 +52,11 @@ export function writeSessionMark(dir, mark) {
 export function lockPath(dir) {
     return join(dir, 'deliver.lock');
 }
-function readLockFile(file) {
+/**
+ * Lit un fichier de verrou : null s'il est absent ou illisible du système de fichiers ; sinon son contenu mis en forme par `fromRaw` et l'âge du fichier,
+ * ou `broken` (marqué `unreadable`) quand ce n'est pas du JSON. Commun au verrou de livraison et à celui de l'orchestration.
+ */
+export function readLockJson(file, fromRaw, broken) {
     let text;
     let ageMs;
     try {
@@ -63,13 +67,13 @@ function readLockFile(file) {
         return null;
     }
     try {
-        const raw = JSON.parse(text);
-        return { pid: Number(raw.pid), sha: String(raw.sha), started: String(raw.started), ageMs };
+        return { ...fromRaw(JSON.parse(text)), ageMs };
     }
     catch {
-        return { pid: 0, sha: '?', started: '?', unreadable: true, ageMs };
+        return { ...broken, unreadable: true, ageMs };
     }
 }
+const readLockFile = (file) => readLockJson(file, (raw) => ({ pid: Number(raw.pid), sha: String(raw.sha), started: String(raw.started) }), { pid: 0, sha: '?', started: '?' });
 export function readLock(dir) {
     return readLockFile(lockPath(dir));
 }
@@ -282,7 +286,3 @@ export function readFailedEntries(dir) {
         return [];
     }
 }
-/** Les jours de `deliveries-failed.log` (une ligne par livraison rouge), dans l'ordre du fichier. */
-export function readFailedDeliveries(dir) {
-    return readFailedEntries(dir).map((e) => e.day);
-}