@sylad/cadence 1.40.0 → 1.42.1

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/lot-budget.js

@@ -38,7 +38,7 @@ function ordinaryBasis(estimate, stage) {
     const basis = estimate <= 0.5 ? "plancher d'un lot jusqu'à 0,5 j" : estimate <= 1 ? "p90 mesuré du total d'un lot de 0,5 à 1 j" : Math.round(estimate * LOT_BUDGET_PER_DAY) <= LOT_BUDGET_ONE_DAY ? `plancher de ${LOT_BUDGET_ONE_DAY} au-delà d'un jour, l'estimate × ${LOT_BUDGET_PER_DAY} ne le dépasse pas encore` : `${LOT_BUDGET_PER_DAY} par jour, p90 mesuré du total au-delà d'un jour`;
     if (!stage)
         return basis;
-    return `${ordinary} dérivés de l'estimate (${basis}), plus ${SPEC_STAGE_ALLOCATION} pour les étapes spec, ${stage === 'screen' ? 'maquette' : 'fiche'} et accept`;
+    return `${ordinary} dérivés de l'estimate (${basis}), plus ${SPEC_STAGE_ALLOCATION} pour ${stage === 'light' ? 'les étapes spec et maquette' : `les étapes spec, ${stage === 'screen' ? 'maquette' : 'fiche'} et accept`}`;
 }
 /** Budget d'un lot, dérivé de son estimate et de sa catégorie : empêche quelques lots d'avaler le budget de la vague au détriment des autres. Un lot à `screen:` vaut le total mesuré d'un lot à écran (L194) ; un lot à `spec: true` y ajoute l'allocation de son étape (L191) ; `escalation` (orchestrate.escalation déclarée) y ajoute la part de l'escalade (L349). */
 export const lotBudget = (estimate, stage, escalation = false) => lotBaseBudget(estimate, stage) + (escalation ? ESCALATION_RESERVE : 0);
@@ -46,5 +46,5 @@ const lotBaseBudget = (estimate, stage) => {
     const ordinary = estimate <= 0.5 ? LOT_BUDGET_FLOOR : Math.max(LOT_BUDGET_ONE_DAY, Math.round(estimate * LOT_BUDGET_PER_DAY));
     if (stage === 'screen')
         return Math.max(SCREEN_LOT_BUDGET, ordinary + SPEC_STAGE_ALLOCATION);
-    return ordinary + (stage === 'spec' ? SPEC_STAGE_ALLOCATION : 0);
+    return ordinary + (stage === 'spec' || stage === 'light' ? SPEC_STAGE_ALLOCATION : 0);
 };

package/dist/orchestrate/maquette.js

@@ -15,6 +15,9 @@ export function maquetteText(o) {
             ? `This is review ${rank} of ${o.max}${rank >= o.max ? ', the last review' : ''}: the spec writer fixed the points of the previous one (below). Check them first, then run the whole sweep again and report ALL the blocking and major findings of it in this report. Mark \`inchange: true\` on every blocking or major finding about a point the spec writer did not change and the previous review had not raised.`
             : `This is the first review of this mockup (${o.max} review${o.max > 1 ? 's' : ''} at most): there is no later review to keep a finding for. Report ALL the blocking and major findings in this first report; do not keep one back for a later review.`,
     ];
+    if (o.light) {
+        lines.push(`Light mockup (L459): the sheet covers only the states the lot touches. Sweep those states only, at ${LARGEURS.join(' and ')} px, and compare the target of each one to the capture of the current screen \`${folder}/actuel-<état>-<largeur>.png\` (a free file, not checked by the program; when one is missing the spec writer said so under "nonVerifie": judge the target against the code and the neighbouring pages). Report what makes the target worse than the current screen or inconsistent with the rest of the application, not the defects of the screen the lot does not touch.`);
+    }
     if (later && o.previous?.length)
         lines.push('', 'Points of the previous review that the spec writer had to fix:', ...bulletLines(o.previous));
     return lines.join('\n');

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/spec.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { isMap, isNode, isScalar, isSeq, parse, parseDocument, stringify } from 'yaml';
 import { acceptationFile } from './accept.js';
 import { checkFiche, fichesDuDossier, LARGEURS } from '../spec.js';
+import { EXPRESS_MAX_ESTIMATE } from './express.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 const list = (v) => (Array.isArray(v) ? v.filter(isObj) : []);
 /** Chemin (relatif au dépôt) de la fiche du lot sous `<dir>/<écran ou sujet>/fiche.yaml` (`ecran.lot` ou `sujet.lot`), ou null : sert à ne pas rejouer une spec déjà écrite. */
@@ -24,6 +25,34 @@ export function specScreen(repo, dir, lot) {
     const entered = fichesDuDossier(repo, dir).some(({ name, doc }) => isObj(doc.ecran) && (doc.ecran.lot === lot.id || existsSync(join(repo, dir, name, acceptation))));
     return entered ? lot.screen : undefined;
 }
+/**
+ * Maquette légère (L459) : un lot visible, sans `spec: true`, d'estimate au-dessus de la retouche (voie express), dont le `screen:` du plan n'est pas `page`
+ * (`component`, `journey` ou absent) passe par spec → maquette avant le code, sans accept. Se déduit du plan à chaque appel, sans champ d'état :
+ * `orchestrate.maquette: false` la retire (la maquette légère est la revue de maquette, sans elle rien n'est à valider).
+ */
+export function lightMaquette(lot, maquette) {
+    return maquette && !!lot.visible && !lot.spec && typeof lot.estimate === 'number' && lot.estimate > EXPRESS_MAX_ESTIMATE && lot.screen !== 'page';
+}
+/**
+ * Le lot a une acceptation scellée (`acceptation-<lot>.json` à côté d'une fiche à bloc `ecran` de `dir`) : il est entré dans la chaîne complète
+ * avant L459 (spec → maquette → accept) et la garde, même s'il répond aujourd'hui à `lightMaquette` ; une maquette légère n'écrit jamais d'acceptation.
+ */
+export function sealedAcceptation(repo, dir, lot) {
+    const acceptation = acceptationFile('fiche.yaml', lot);
+    return fichesDuDossier(repo, dir).some(({ name, doc }) => isObj(doc.ecran) && existsSync(join(repo, dir, name, acceptation)));
+}
+/** Le lot est une maquette légère : son état a une étape spec (`screen` posé au lancement), son lot du plan répond à `lightMaquette` et il n'a pas d'acceptation scellée (`sealedAcceptation`). Relu du plan et du dépôt à chaque appel, aucun champ d'état. */
+export const lightLot = (state, lot, maquette, repo, dir) => !!state.screen && lightMaquette(lot, maquette) && !sealedAcceptation(repo, dir, lot.id);
+/** `screen` de l'état d'un lot à étape spec : celui de `specScreen`, ou, pour une maquette légère, celui du plan (`component` quand le plan n'en déclare pas : l'état ne sert alors qu'à dire « ce lot a une étape spec »). */
+export function stageScreen(repo, dir, lot, maquette) {
+    return specScreen(repo, dir, lot) ?? (lightMaquette(lot, maquette) ? (lot.screen ?? 'component') : undefined);
+}
+/** Catégorie de budget d'un lot (`lotBudget`) : `screen` pour un écran page, `light` pour une maquette légère, `spec` pour un lot `spec: true` sans écran. */
+export function budgetStage(lot, stateScreen, maquette, repo, dir) {
+    if (stateScreen)
+        return lightLot({ screen: stateScreen }, lot, maquette, repo, dir) ? 'light' : 'screen';
+    return lot.spec ? 'spec' : undefined;
+}
 /** Texte sans accents ni majuscules, pour les mots-clés. */
 const plain = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
 /**
@@ -267,20 +296,36 @@ export function hypothesisLines(doc) {
 }
 /** Texte de la note du lot pour une hypothèse (une note par règle). */
 export const hypothesisNote = (sujet, line) => `Hypothèses (fiche ${sujet}) — ${line}`;
+/** Consigne de rendu de la maquette : la commande que le projet déclare (`orchestrate.spec.render`), sinon Playwright. `use` : comment la reprendre. */
+const renderLine = (render, use) => render
+    ? `The project declares how to render mockups (\`orchestrate.spec.render\`): \`${render}\` (from the repository root). ${use}; fall back on Playwright only if it cannot run, and say so under "nonVerifie".`
+    : 'No render command is declared (`orchestrate.spec.render`): render with Playwright (open `maquette.html` as a local file, resize to each width, open each `#etat-<état>`).';
+/** Consigne de la maquette d'un lot `screen: page` (ou déjà entré dans la chaîne complète). */
+const pageLines = (o) => [
+    `The lot declares \`screen: ${o.screen}\`. The specs of this project live in \`${o.dir}/<écran>/\` (one folder per screen, \`<écran>\` = the kebab-case \`ecran.id\` of the sheet).`,
+    `Render each state of the mockup at ${LARGEURS.map((w) => `${w}`).join(' and ')} px width: one capture per state and per width, named \`maquette-<état>-<largeur>.png\` (e.g. \`maquette-vide-1440.png\`).`,
+    renderLine(o.render, 'Use it'),
+];
+/** Consigne de la maquette légère (L459) : l'écran actuel et la version visée des seuls états touchés. */
+const lightLines = (o) => [
+    `This lot is a visible lot that is not a whole page: write a light mockup, before any code. The specs of this project live in \`${o.dir}/<écran>/\` (one folder per screen, \`<écran>\` = the kebab-case \`ecran.id\` of the sheet).`,
+    'Cover only the states the lot touches (not the whole screen). For each touched state, capture the CURRENT screen of the application at each width, then the target version: the sheet and the mockup are limited to the states, fields and rules the lot changes.',
+    `Name the captures of the current screen \`actuel-<état>-<largeur>.png\` and those of the target \`maquette-<état>-<largeur>.png\`, one per touched state and per width (${LARGEURS.join(' and ')} px; e.g. \`actuel-vide-1440.png\`, \`maquette-vide-1440.png\`), in the folder of the sheet. The program checks the captures of the target, not the \`actuel-*\` ones.`,
+    'If the current screen cannot be captured (the application does not start, the page is protected), say so under "nonVerifie" and base the mockup on the code: never invent a capture of the current screen.',
+    'Each touched state is a section `id="etat-<état>"` of `maquette.html`, and each touched field carries a `data-testid`.',
+    renderLine(o.render, 'Use it for the target'),
+];
 /** Consigne propre à l'étape spec dans le brief : dossier, largeurs, commande de rendu, et les écarts de la passe précédente. */
 export function specText(o) {
     const lines = [];
-    if (o.screen) {
-        lines.push(`The lot declares \`screen: ${o.screen}\`. The specs of this project live in \`${o.dir}/<écran>/\` (one folder per screen, \`<écran>\` = the kebab-case \`ecran.id\` of the sheet).`, `Render each state of the mockup at ${LARGEURS.map((w) => `${w}`).join(' and ')} px width: one capture per state and per width, named \`maquette-<état>-<largeur>.png\` (e.g. \`maquette-vide-1440.png\`).`, o.render
-            ? `The project declares how to render mockups (\`orchestrate.spec.render\`): \`${o.render}\` (from the repository root). Use it; fall back on Playwright only if it cannot run, and say so under "nonVerifie".`
-            : 'No render command is declared (`orchestrate.spec.render`): render with Playwright (open `maquette.html` as a local file, resize to each width, open each `#etat-<état>`).');
-    }
+    if (o.screen)
+        lines.push(...(o.light ? lightLines(o) : pageLines(o)));
     if (o.back) {
         lines.push(o.screen
             ? `The sheet has both parts, \`sujet\`, \`cas\`, \`contrats\`, \`donnees\` next to \`ecran\`, in the same folder (\`sujet.id\` = \`ecran.id\` = the folder name, \`sujet.lot\` = \`ecran.lot\`); the API calls of the screen are listed once in \`contrats\`, and the actions point to them with \`contrat: Ax\`.`
             : `The lot declares \`spec: true\` (it changes a behaviour, with no screen). The specs of this project live in \`${o.dir}/<sujet>/\` (one folder per subject, \`<sujet>\` = the kebab-case \`sujet.id\` of the sheet); the sheet has no screen part.`);
     }
-    if (o.screen && !o.back) {
+    if (o.screen && !o.back && !o.light) {
         lines.push(`If the lot also changes a behaviour (an API call, a stored datum, a contract), add the back part to the same sheet: \`sujet\`, \`cas\`, \`contrats\`, \`donnees\` next to \`ecran\` (\`sujet.id\` = \`ecran.id\` = the folder name, \`sujet.lot\` = \`ecran.lot\`); the program then also has the sheet reviewed (rules sourced, contradictions, errors and limits, one test per rule), before the mockup. A lot that only draws a screen keeps a sheet without \`sujet\`.`);
     }
     if (o.template)

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

@@ -0,0 +1,119 @@
+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 (`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) {
+    if (decl == null)
+        return {};
+    if (typeof decl !== 'object' || Array.isArray(decl))
+        return `extras.${name} doit être un objet { enum, default }`;
+    const d = decl;
+    const unknown = Object.keys(d).find((k) => !EXTRA_KEYS.includes(k));
+    if (unknown)
+        return `extras.${name}.${unknown} inconnu (attendu : ${EXTRA_KEYS.join(', ')})`;
+    const out = {};
+    if (d.enum != null) {
+        if (!Array.isArray(d.enum) || d.enum.length === 0 || !d.enum.every(nonEmptyText))
+            return `extras.${name}.enum doit être une liste non vide de textes`;
+        if (new Set(d.enum).size !== d.enum.length)
+            return `extras.${name}.enum : une valeur est donnée deux fois`;
+        out.enum = d.enum;
+    }
+    if (d.default != null) {
+        if (!nonEmptyText(d.default))
+            return `extras.${name}.default doit être un texte non vide`;
+        if (out.enum && !out.enum.includes(d.default))
+            return `extras.${name}.default « ${d.default} » hors de enum (${out.enum.join(', ')})`;
+        out.default = d.default;
+    }
+    return out;
+}
+/**
+ * Clé `plan.extras` de cadence.yaml (L464) lue en `{ extras }` (`{}` quand la clé manque). Refuse, en nommant la clé : une forme fausse, un nom invalide ou pris
+ * par un champ de raf, un plan tenu par un autre outil (`foreign` : lecture seule, raf n'y écrit aucun champ).
+ */
+export function readExtras(v, foreign, bad) {
+    if (v == null)
+        return {};
+    if (foreign)
+        throw bad("extras ne s'applique pas à un plan tenu par un autre outil (lecture seule)");
+    if (typeof v !== 'object' || Array.isArray(v))
+        throw bad('extras doit être un objet { champ: { enum, default } }');
+    const extras = {};
+    for (const [name, raw] of Object.entries(v)) {
+        if (!EXTRA_NAME.test(name))
+            throw bad(`extras.${name} : nom invalide (minuscules, chiffres et _, commençant par une lettre)`);
+        if (FIELDS.includes(name) || LOT_KEYS.includes(name))
+            throw bad(`extras.${name} : c'est un champ de raf, pas un champ d'extension`);
+        const decl = readDecl(name, raw);
+        if (typeof decl === 'string')
+            throw bad(decl);
+        extras[name] = decl;
+    }
+    return { extras };
+}
+/** Ce qui cloche dans la valeur d'un champ d'extension, ou null : champ non déclaré, pas un texte non vide, hors de `enum`. */
+function valueProblem(decls, name, value) {
+    const decl = decls[name];
+    if (!decl) {
+        const names = Object.keys(decls);
+        return names.length === 0 ? `${name} : aucun champ d'extension déclaré (cadence.yaml : plan.extras)` : `${name} : champ d'extension non déclaré (${names.join(', ')})`;
+    }
+    if (!nonEmptyText(value))
+        return `${name} : texte non vide attendu`;
+    if (decl.enum && !decl.enum.includes(value.trim()))
+        return `${name} « ${value.trim()} » hors de enum (${decl.enum.join(', ')})`;
+    return null;
+}
+/** Les champs à poser à la création d'un lot (`raf add --set`), validés et nettoyés ; une erreur refuse tout. Sans valeur donnée : rien. */
+export function checkedExtras(decls, given) {
+    const out = {};
+    for (const [name, value] of Object.entries(given ?? {})) {
+        const problem = valueProblem(decls ?? {}, name, value);
+        if (problem)
+            throw new RafError(problem);
+        out[name] = value.trim();
+    }
+    return out;
+}
+/**
+ * Le lot lu avec ses champs d'extension : la valeur écrite, sinon le `default`. Une valeur fausse est remontée par check (`bad-field`) et n'est pas gardée.
+ * Les clés non déclarées ne sont pas lues : elles restent sur le disque, intactes.
+ */
+export function withExtras(lot, raw, decls) {
+    const extras = {};
+    for (const [name, decl] of Object.entries(decls ?? {})) {
+        const written = raw[name];
+        if (written == null) {
+            if (decl.default !== undefined)
+                extras[name] = decl.default;
+            continue;
+        }
+        const problem = valueProblem(decls ?? {}, name, written);
+        if (problem)
+            lot.problems.push(problem);
+        else
+            extras[name] = written.trim();
+    }
+    return Object.keys(extras).length > 0 ? { ...lot, extras } : lot;
+}
+/** Les `--set champ=valeur` de `raf add` : champ → valeur, coupée au premier « = ». Une forme sans champ ou sans valeur, un champ donné deux fois : refusés. Rend undefined sans `--set`. */
+export function parseSet(sets) {
+    if (sets === undefined)
+        return undefined;
+    const out = {};
+    for (const item of sets) {
+        const [name, ...rest] = item.split('=');
+        const value = rest.join('=').trim();
+        if (name.trim() === '' || value === '')
+            throw new RafError(`--set attend champ=valeur (reçu « ${item} »)`);
+        if (Object.hasOwn(out, name.trim()))
+            throw new RafError(`--set ${name.trim()} est donné deux fois`);
+        out[name.trim()] = value;
+    }
+    return out;
+}

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 };
+}