@sylad/cadence 1.41.0 → 1.42.1

package/dist/orchestrate/cycle.js

@@ -8,7 +8,7 @@ import { tmpdir } from 'node:os';
 import { coveredTasks, lotCommits, lotWork } from '../audit.js';
 import { planLoader, readDocsConfig, readPlanConfig } from '../config.js';
 import { PLAN_ACTIONS, leadAnswerMessage, planCommitMessage } from '../plan-commit.js';
-import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
+import { articleRepoDir, articlesBrief, docSyncBrief, filesOf, gapMessage, lotDocSyncGaps } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
 import { citesPriorWork, keepPrecheckReading, localYesNote, precheckNothingToFind } from './precheck.js';
 import { PROBE_FAILED, PROBE_RESERVE, probeStep, probeVars, scheduleProbe } from './probe.js';
@@ -30,7 +30,7 @@ import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, t
 import { cleanPlaywrightOutput, pushed, remoteAdvances, snapshot } from './guard.js';
 import { sumTokens } from './result.js';
 import { cutReport, EXTENSION_MS, MAX_EXTENSIONS, workTimeoutMs } from './timeouts.js';
-import { ACCEPT_SCHEMA, agentOf, checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, WORK_SCHEMA } from './schemas.js';
+import { ACCEPT_SCHEMA, checkShape, effortKey, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, stepAgent, WORK_SCHEMA } from './schemas.js';
 import { acceptationFile, acceptCommands, isAcceptList, acceptText, checkAcceptation, findAcceptation, isAcceptationFile, lockViolations, lotStartHead, parseAcceptation, planAcceptRuns, redSha, resealedRouge, sealAcceptation, setVert } from './accept.js';
 import { lotIds, referenceIdsText } from '../ref/coverage.js';
 import { avalFicheText, ficheContracts, ficheRules, hasScreenPart } from './aval.js';
@@ -413,7 +413,7 @@ function docGaps(c) {
     const { sync } = docsConfig(c);
     const plan = histPlan(c);
     const acknowledged = !!plan.lots().find((x) => x.id === c.lot.lot)?.docsOk;
-    return { sync, gaps: sync.length && !acknowledged ? docSyncGaps(sync, filesOf(wd(c), lotWork(plan, wd(c), c.lot.lot))) : [] };
+    return { sync, gaps: sync.length && !acknowledged ? lotDocSyncGaps(sync, wd(c), lotWork(plan, wd(c), c.lot.lot)) : [] };
 }
 /** Cause du renvoi au lead d'un lot dont l'écart docs.sync est ouvert (L317), null sans écart. */
 function openDocGap(c) {
@@ -699,7 +699,7 @@ async function session(c, kind, local = false) {
     if (WRITE_STEPS.includes(kind) && (lotOver(l) || (kind === 'fix' && !fixAffordable(l))))
         return overBudget(c, kind === 'fix' && !lotOver(l));
     const model = ['spec', 'accept', 'fiche', 'probe'].includes(kind) ? 'sonnet' : write ? (kind === 'fix' && l.escalation?.stage === 'fix' ? l.escalation.model : l.model) : local ? 'local' : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
-    const effort = c.config.effort[kind === 'review-small' ? 'review' : kind];
+    const effort = c.config.effort[effortKey(kind)];
     const before = await snapshot(wd(c));
     const neighbours = l.repos ?? [];
     const beforeOthers = await Promise.all(neighbours.map((r) => snapshot(r.path)));
@@ -759,7 +759,7 @@ async function session(c, kind, local = false) {
         effort,
         local,
         schema: schemaFor(kind),
-        agent: kind === 'fix' && l.docsFix ? 'doc-keeper' : agentOf(kind),
+        agent: stepAgent(kind, l.docsFix),
         cwd: wd(c),
         wave: w.id,
         lot: lotKey(l.project, l.lot),

package/dist/orchestrate/integration-vivante.js

@@ -0,0 +1,138 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { planLoader } from '../config.js';
+import { leadReviewedHandBack } from './cycle.js';
+import { trackedDirty } from './depot.js';
+import { cadenceHome, liveWaves } from './registry.js';
+import { waveReadsIntegrateQueue } from './snapshot.js';
+import { lotKey } from './state.js';
+import { resumeCommand } from './table.js';
+import { lotTreeDir } from './worktree.js';
+/**
+ * Un lot rendu que `--integrate` peut reprendre (L279, L370) : rendu à l'étape d'intégration (`next: integrate`), ou rendu ailleurs puis corrigé et revu conforme par le lead dans son worktree (la revue porte le dernier commit).
+ * Rend le verdict du lead dans ce second cas (`lead`), `{ lead: null }` dans le premier, null si le lot n'est pas reprenable.
+ */
+export function integrationHandBack(store, l) {
+    if (l.status !== 'handed-back')
+        return null;
+    if (l.next === 'integrate')
+        return { lead: null };
+    // La revue du lead est écrite par `raf review` lancé dans le worktree : c'est le plan du worktree qui la porte, pas celui du dépôt principal.
+    const tree = lotTreeDir(store.dir, l.project, l.lot, l.repo);
+    const lead = existsSync(join(tree, '.git')) ? leadReviewedHandBack(l, planLoader(tree)(), tree) : null;
+    return lead ? { lead } : null;
+}
+/** La revue du lead tient lieu de revue du lot : le rebase reporte son verdict (même patch-id) ou joue la revue courte du diff rebasé. */
+export function adoptLeadReview(l, lead) {
+    l.next = 'integrate';
+    l.code = { conforme: true, bloquants: 0, majeurs: 0, mineurs: 0, verdict: lead.verdict, sousTaches: [], nonVerifie: [], head: lead.head };
+    l.verdict = lead.verdict;
+    l.constats = [];
+}
+/** La ligne de journal d'une intégration reprise (à la reprise comme sur la vague vivante). */
+export const integrationText = (lead) => (lead ? `intégration reprise (--resume --integrate) : revue conforme du lead hors vague, ${lead.head.slice(0, 7)}` : 'intégration reprise (--resume --integrate)');
+/** Le contrôle d'une cible de `--integrate` : sa clé `projet:lot`, ou le refus. */
+function checkTarget(store, t, seen) {
+    const matches = store.lots().filter((l) => l.lot === t.lot && (t.project ? l.project === t.project : true));
+    const where = `${t.project ? `${t.project}:` : ''}${t.lot}`;
+    if (matches.length !== 1)
+        return { refusal: matches.length ? `--integrate ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--integrate ${where} : lot inconnu dans la vague ${store.id}` };
+    const l = matches[0];
+    const key = lotKey(l.project, l.lot);
+    if (seen.includes(key))
+        return { refusal: `--integrate ${key} : lot visé deux fois` };
+    if (!integrationHandBack(store, l))
+        return { refusal: `--integrate ${key} : le lot n'est pas rendu à l'étape d'intégration (${l.status}, étape ${l.next ?? 'aucune'} : ${l.outcome ?? 'sans cause'})` };
+    return { key };
+}
+/**
+ * `--resume --integrate` sur une vague VIVANTE (L532) : l'intégration est déposée dans la file de la vague (`integrates.log`), qui la reprend entre deux étapes, comme un `--add`.
+ * Sans cela le lead attendait la fin de la vague (qui dure des heures sous `--continue`). Les lots visés sont contrôlés comme à la reprise : connus, rendus à l'intégration ou revus par le lead.
+ */
+export function depositIntegrations(targets, io, store) {
+    const refusals = [];
+    const keys = [];
+    for (const t of targets) {
+        const r = checkTarget(store, t, keys);
+        if ('key' in r)
+            keys.push(r.key);
+        else
+            refusals.push(r.refusal);
+    }
+    if (!waveReadsIntegrateQueue(store.dir))
+        refusals.push(`la vague ${store.id} ne lit pas la file d'intégrations (lancée avec une version de cadence d'avant L532) : attendre sa fin, puis ${resumeCommand(store.id, '--integrate', '<projet>:<lot>')}`);
+    if (refusals.length) {
+        for (const r of refusals)
+            io.err(`orchestrate : ${r}`);
+        return 2;
+    }
+    for (const key of keys) {
+        const id = store.requestIntegrate(key);
+        // La vague a pu finir entre le contrôle et le dépôt : sa file ne sera plus lue, la demande est retirée et le lead reprend à la main.
+        if (!liveWaves(cadenceHome()).some((w) => w.wave === store.id)) {
+            store.markIntegrateTaken(id);
+            io.err(`orchestrate : ${key} : la vague ${store.id} vient de finir, intégration non prise : ${resumeCommand(store.id, '--integrate', key)}`);
+            return 2;
+        }
+        store.journal(`demande : intégration du lot ${key}`);
+        io.out(`${key} : intégration déposée — la vague ${store.id} la reprend entre deux étapes dès qu'un créneau est libre`);
+    }
+    return 0;
+}
+/** Pourquoi la demande ne peut plus être jouée (lot inconnu, déjà repris, revue du lead perdue), ou le lot et ce qui le reprend. */
+function eligible(store, ctxs, lot) {
+    const c = ctxs.find((x) => lotKey(x.lot.project, x.lot.lot) === lot);
+    if (!c)
+        return { why: 'lot inconnu' };
+    if (c.lot.status !== 'handed-back')
+        return { why: `le lot n'est plus rendu (${c.lot.status})` };
+    const back = integrationHandBack(store, c.lot);
+    return back ? { c, back } : { why: "le lot n'est pas rendu à l'étape d'intégration ni revu par le lead au dernier commit de son worktree" };
+}
+/**
+ * La vague vivante prend les intégrations déposées (L532) : le lot rendu repart à l'étape `integrate` comme sous `--resume --integrate`, quand `canRun` l'accepte ; une demande dont le lot ne qualifie plus
+ * (déjà repris, commit après la revue du lead, fichier suivi modifié) est écartée et dite au journal. Rend les lots à jouer ; `settled` est la liste des lots qui ont fini de jouer.
+ */
+export async function takeIntegrations(w, canRun) {
+    const { store, wctx } = w;
+    const taken = [];
+    const drop = (id, lot, why) => {
+        wctx.log(`${lot} : intégration écartée (${why})`);
+        store.markIntegrateTaken(id);
+    };
+    for (const e of store.integrateQueue()) {
+        const r = eligible(store, w.ctxs, e.lot);
+        if ('why' in r) {
+            drop(e.id, e.lot, r.why);
+            continue;
+        }
+        const { c, back } = r;
+        if (!canRun(c))
+            continue;
+        const dirty = await trackedDirty(lotTreeDir(store.dir, c.lot.project, c.lot.lot, c.lot.repo));
+        if (dirty.length) {
+            drop(e.id, e.lot, `arbre sale, ${dirty.length} fichier(s) suivi(s) modifié(s) : ${dirty.join(', ')}`);
+            continue;
+        }
+        if (back.lead)
+            adoptLeadReview(c.lot, back.lead);
+        c.lot.next = 'integrate';
+        c.lot.status = 'suspended';
+        c.lot.outcome = null;
+        store.writeLot(c.lot);
+        store.markIntegrateTaken(e.id);
+        wctx.log(`${e.lot} → suspended — ${integrationText(back.lead)}`);
+        // Le lot avait fini de jouer (`settled`) : il rejoue, il tient de nouveau un créneau (L433).
+        w.settled.delete(c);
+        taken.push(c);
+    }
+    return taken;
+}
+/** `--resume --integrate` seul (sans --replay, --answer, --budget, --drop ni --continue) sur une vague qui tourne encore : l'intégration est déposée, pas refusée. */
+export function depositsOnly(a, live) {
+    return live && a.integrate.length > 0 && a.integrate.every((t) => !t.replay) && !a.answers.length && !a.lotBudgets.length && !a.drop.length && a.budget === undefined && !a.continue;
+}
+/** La vague tourne dans un autre processus de ce dossier, et joue (« running ») : une reprise qui attend le dépôt (L443) est inscrite vivante sans rien jouer encore, elle ne lit pas la file. */
+export function runsElsewhere(store, launch) {
+    return store.readWave()?.status === 'running' && liveWaves(cadenceHome()).some((w) => w.wave === store.id && w.cwd === launch && w.pid !== process.pid);
+}

package/dist/orchestrate/launch.js

@@ -88,14 +88,15 @@ export function enabledPlugins(files) {
  * En argument, pas dans un fichier : des identifiants seulement (`nom@marketplace`, aucun secret), 1 000 plugins pèsent 50 ko sous la limite d'un argument Linux (128 ko).
  */
 const settingsArgs = (spec) => (spec.disablePlugins?.length ? ['--settings', JSON.stringify({ enabledPlugins: Object.fromEntries(spec.disablePlugins.map((id) => [id, false])) })] : []);
-export function buildArgs(spec, agents) {
-    const args = ['-p', spec.brief, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
+/** Le corps commun d'une session `claude -p` et de sa relance : prompt, schéma, modèle, effort, agent restreint, puis (après `session`) mode de permission, dossiers, plugins désactivés, interdits et MCP. `session` : `--session-id <id>` ou `--resume <id>`. */
+function claudeArgs(spec, agents, prompt, session) {
+    const args = ['-p', prompt, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
     if (spec.agent) {
         if (!agents[spec.agent])
             throw new RafError(`agent introuvable dans le paquet : ${spec.agent}`);
         args.push('--agents', JSON.stringify(agentsFor(spec, agents)), '--agent', spec.agent);
     }
-    args.push('--session-id', spec.sessionId, '--permission-mode', spec.permissionMode);
+    args.push(...session, '--permission-mode', spec.permissionMode);
     for (const d of spec.addDirs)
         args.push('--add-dir', d);
     args.push(...settingsArgs(spec), '--disallowedTools', ...DISALLOWED);
@@ -103,6 +104,7 @@ export function buildArgs(spec, agents) {
         args.push('--strict-mcp-config', '--mcp-config', spec.mcpConfig);
     return args;
 }
+export const buildArgs = (spec, agents) => claudeArgs(spec, agents, spec.brief, ['--session-id', spec.sessionId]);
 /**
  * Arguments de `claude-local` (L146) : le prompt vient en premier, le script ajoute lui-même `--bare`, `--model` et le
  * serveur Ollama. Le harnais `--bare` ne charge pas `--agents` : le prompt de l'agent est joint au brief et ses outils
@@ -150,21 +152,7 @@ const isCut = (out) => !out.timedOut && out.code > 128 && out.stdout.trim() ===
 /** Consigne de la relance de mise en forme : rendre le rapport déjà établi au format demandé, rien d'autre. */
 export const FORMAT_RETRY_PROMPT = 'Return your report now in the required format (the JSON structure of the schema), exactly as you concluded it. Do not do any further work, do not add anything else.';
 /** Arguments de la relance : même session (--resume), mêmes schéma, modèle, agent (outils restreints), mode de permission, dossiers et interdits. */
-export function buildRetryArgs(spec, sessionId, agents) {
-    const args = ['-p', FORMAT_RETRY_PROMPT, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
-    if (spec.agent) {
-        if (!agents[spec.agent])
-            throw new RafError(`agent introuvable dans le paquet : ${spec.agent}`);
-        args.push('--agents', JSON.stringify(agentsFor(spec, agents)), '--agent', spec.agent);
-    }
-    args.push('--resume', sessionId, '--permission-mode', spec.permissionMode);
-    for (const d of spec.addDirs)
-        args.push('--add-dir', d);
-    args.push(...settingsArgs(spec), '--disallowedTools', ...DISALLOWED);
-    if (spec.mcpConfig)
-        args.push('--strict-mcp-config', '--mcp-config', spec.mcpConfig);
-    return args;
-}
+export const buildRetryArgs = (spec, sessionId, agents) => claudeArgs(spec, agents, FORMAT_RETRY_PROMPT, ['--resume', sessionId]);
 /**
  * Lance une session et range son issue : ok, quota atteint, ou échec nommé (jamais de nouvel essai ici), à une
  * exception près : une session réussie qui finit en texte sans `structured_output` est relancée UNE fois, par

package/dist/orchestrate/lock.js

@@ -1,7 +1,7 @@
-import { linkSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { linkSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { processStart } from '../proc.js';
-import { pidAlive } from '../state.js';
+import { pidAlive, readLockJson } from '../state.js';
 /**
  * Le porteur vit encore : son pid existe ET, quand l'heure de démarrage est connue des deux côtés, c'est la même.
  * Un pid repris par un autre processus est un porteur mort.
@@ -18,24 +18,7 @@ export function holderAlive(pid, start) {
 export const REPO_LOCK = 'orchestrate.lock';
 /** Un champ facultatif du verrou, tel qu'écrit ; absent : absent. */
 const optional = (v) => (v === undefined ? undefined : String(v));
-function read(file) {
-    let text;
-    let ageMs;
-    try {
-        ageMs = Date.now() - statSync(file).mtimeMs;
-        text = readFileSync(file, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    try {
-        const raw = JSON.parse(text);
-        return { pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), start: optional(raw.start), until: optional(raw.until), ageMs };
-    }
-    catch {
-        return { pid: 0, wave: '?', started: '?', unreadable: true, ageMs };
-    }
-}
+const read = (file) => readLockJson(file, (raw) => ({ pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), start: optional(raw.start), until: optional(raw.until) }), { pid: 0, wave: '?', started: '?' });
 const alive = (l) => (l.unreadable ? l.ageMs < 5_000 : l.until !== undefined || holderAlive(l.pid, l.start));
 /** Un verrou déclaré dont l'échéance est passée à `now` ; faux pour un verrou de processus (il n'a pas d'échéance). */
 export const lockOverdue = (l, now) => l.until !== undefined && Date.parse(l.until) <= now.getTime();

package/dist/orchestrate/registry.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { processStart } from '../proc.js';
 import { gitCommonDir } from '../git.js';
 import { lotFinished, lotKey, lotRepoPaths, RunStore } from './state.js';
+import { hasRoom, whileWaiting } from './attente.js';
 import { activeLock, holderAlive, releaseLock, takeLock } from './lock.js';
 /**
  * État commun à toutes les vagues de l'utilisateur, quel que soit le dossier d'où elles partent : le registre
@@ -198,6 +199,9 @@ export class SlotAbandoned extends Error {
  * Deux vagues qui prennent en même temps se départagent au recomptage : si le total dépasse `cap` une fois
  * le créneau pris, il est rendu et l'attente reprend.
  *
+ * `fresh`/`rank` (L531) : quand plusieurs sessions attendent, le créneau qui se libère va à l'étape suivante d'un lot déjà en cours (`fresh` faux, défaut) avant un nouveau tirage (`fresh`),
+ * puis au projet le plus haut dans `priority:` (`rank` le plus petit), puis à l'attente la plus ancienne, toutes vagues confondues ; une session ne prend un créneau que si aucune attente vivante ne la précède (`attente.ts`).
+ *
  * `onWait(holders, waitedMs)` : appelé quand on commence à attendre (0 ms), puis toutes les minutes.
  * `onGot(waitedMs)` : appelé à l'obtention, seulement si on a attendu.
  * `abandon()` : relu seulement pendant une VRAIE attente, c'est-à-dire une fois qu'une première tentative n'a pas trouvé de créneau libre,
@@ -206,6 +210,9 @@ export class SlotAbandoned extends Error {
  * la relance d'une session coupée n'est pas une attente, la demande d'arrêt s'applique ensuite.
  */
 export async function acquireSlot(home, cap, opts) {
+    return whileWaiting(home, opts, (myTurn) => takeSlot(home, cap, opts, myTurn));
+}
+async function takeSlot(home, cap, opts, myTurn) {
     mkdirSync(slotsDir(home), { recursive: true });
     const now = opts.now ?? Date.now; // injectable : les tests pilotent l'horloge
     const t0 = now();
@@ -223,7 +230,7 @@ export async function acquireSlot(home, cap, opts) {
             checkAbandon(); // pas à la première tentative : un créneau libre est pris même si une demande est posée
         // Les sessions du lead (`lead hold`) tournent hors de toute vague mais prennent un créneau : relues à chaque comptage (L424).
         const taken = () => live(home).length + liveHolds(home, new Date()).length;
-        if (taken() < limit) {
+        if (hasRoom(taken, limit, myTurn)) {
             for (let k = 0; k < MAX_SLOT_INDEX; k++) {
                 const file = join(slotsDir(home), `slot-${k}.lock`);
                 const got = takeLock(file, { pid: process.pid, wave: opts.wave, started: new Date().toISOString() });

package/dist/orchestrate/schemas.js

@@ -63,7 +63,11 @@ export const PROBE_SCHEMA = {
 export const schemaFor = (kind) => (kind === 'precheck' ? PRECHECK_SCHEMA : kind === 'spec' ? SPEC_SCHEMA : kind === 'accept' ? ACCEPT_SCHEMA : kind === 'probe' ? PROBE_SCHEMA : kind === 'implement' || kind === 'fix' ? WORK_SCHEMA : REVIEW_SCHEMA);
 /** L'agent du paquet de chaque étape qui en a un, ou `undefined` pour une écriture sans agent ; les revues et la fiche n'y sont pas : `code-reviewer`. */
 const STEP_AGENT = { implement: undefined, fix: undefined, probe: undefined, spec: 'spec-writer', accept: 'acceptance-writer', ux: 'ux-reviewer', maquette: 'ux-reviewer', precheck: 'precheck-reader' };
-export const agentOf = (kind) => (kind in STEP_AGENT ? STEP_AGENT[kind] : 'code-reviewer');
+const agentOf = (kind) => (kind in STEP_AGENT ? STEP_AGENT[kind] : 'code-reviewer');
+/** L'agent d'une étape, la passe du bibliothécaire (`fix` de documentation) comprise : un seul choix pour la session réelle et pour le `--dry-run`. */
+export const stepAgent = (kind, docsFix) => (kind === 'fix' && docsFix ? 'doc-keeper' : agentOf(kind));
+/** La clé de `effort` d'une étape : la revue d'un petit lot visible (`review-small`) prend l'effort de `review`. */
+export const effortKey = (kind) => (kind === 'review-small' ? 'review' : kind);
 /** Contrôle la forme d'une sortie structurée : un champ absent ou mal typé est une erreur nommée. */
 export function checkShape(value, schema) {
     if (!value || typeof value !== 'object' || Array.isArray(value))

package/dist/orchestrate/snapshot.js

@@ -130,6 +130,19 @@ export function waveReadsAnswerQueue(waveDir) {
         return false;
     }
 }
+/**
+ * La vague lit-elle la file d'intégrations `integrates.log` (L532, `--resume --integrate` sur une vague vivante) ? Une vague lancée avant L532 ne la lirait jamais : la demande y dormirait. Sans instantané : on suppose que oui.
+ */
+export function waveReadsIntegrateQueue(waveDir) {
+    if (!snapshotExists(waveDir))
+        return true;
+    try {
+        return readFileSync(join(toolDirOf(waveDir), 'dist', 'orchestrate', 'state.js'), 'utf8').includes('integrates.log');
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * La vague lit-elle la file d'ajouts `adds.log` (L421, `--add`) ? Une vague lancée avant L421 ne la lirait jamais : le lot y dormirait. Sans instantané : on suppose que oui.
  */

package/dist/orchestrate/state.js

@@ -219,6 +219,23 @@ export class RunStore {
     markAnswerTaken(id) {
         appendFileSync(join(this.dir, 'answers.log'), `${JSON.stringify({ taken: id })}\n`);
     }
+    /**
+     * File des intégrations demandées à une vague vivante (L532, `--resume --integrate` sur une vague qui tourne encore) : `integrates.log`, une ligne JSON par demande (`{id, lot}`, le lot écrit `projet:lot`).
+     * La vague la relit entre deux étapes, comme celle des réponses.
+     */
+    integrateQueue() {
+        return this.queue('integrates.log', (o) => (typeof o.lot === 'string' ? { lot: o.lot } : null));
+    }
+    /** Dépose une intégration dans la file ; rend son numéro. */
+    requestIntegrate(lot) {
+        const id = this.nextId('integrates.log');
+        appendFileSync(join(this.dir, 'integrates.log'), `${JSON.stringify({ id, lot })}\n`);
+        return id;
+    }
+    /** La demande `id` est prise (intégration reprise ou écartée) : elle ne sera plus relue. */
+    markIntegrateTaken(id) {
+        appendFileSync(join(this.dir, 'integrates.log'), `${JSON.stringify({ taken: id })}\n`);
+    }
     /**
      * File des lots à ajouter à une vague vivante (L421, `--add`) : `adds.log`, une ligne JSON par demande (`{id, lot, project?, model?}`), le projet étant écrit comme le lead l'a donné
      * (nom de dossier depuis le dossier de lancement). La vague la relit entre deux étapes, comme celle des réponses.

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();