@sylad/cadence 1.41.0 → 1.43.0

package/dist/config.js

@@ -1,6 +1,5 @@
-import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { existsSync, realpathSync, statSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
-import { parse } from 'yaml';
 import { isDay } from './dates.js';
 import { readGate } from './gate-config.js';
 import { DEFAULT_TEST_PATTERNS } from './testgate.js';
@@ -9,9 +8,9 @@ import { gitRoot } from './git.js';
 import { planCommitProblem } from './plan-commit.js';
 import { parseStates } from './plan-states.js';
 import { checkTestReplay, readGateTest } from './orchestrate/gate-parts.js';
-import { booleanKey, isObject, list } from './yaml-keys.js';
-import { FIELDS, Plan, RafError, STATUSES } from './plan.js';
-const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit', 'states', 'transitions', 'doneState', 'blockedState', 'extras'];
+import { booleanKey, isObject, list, readYamlFile, readYamlKey } from './yaml-keys.js';
+import { FIELDS, Plan, RafError, readIdPattern, STATUSES } from './plan.js';
+const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates', 'add', 'onWrite', 'commit', 'states', 'transitions', 'doneState', 'blockedState', 'extras', 'idPattern'];
 const ON_WRITE_KEYS = ['command', 'files'];
 const FORMAT_KEYS = ['lots', 'fields', 'statuses', 'estimates'];
 /** Chemin réel (liens symboliques résolus) du plus proche ancêtre existant, le reste rattaché tel quel. */
@@ -72,15 +71,9 @@ function readOnWrite(v, cwd, bad) {
  * Null quand le fichier ou la clé manque — le plan est alors .cadence/raf.yaml (ou docs/plan/raf.yaml hérité) au format de raf.
  */
 export function readPlanConfig(file, root) {
-    if (!existsSync(file))
+    const raw = readYamlFile(file);
+    if (raw === undefined)
         return null;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
     const doc = raw;
     const qa = readQa(doc?.qa, file, root);
     const p = doc?.plan;
@@ -112,7 +105,7 @@ export function readPlanConfig(file, root) {
         settings.onWrite = readOnWrite(p.onWrite, root ?? dirname(resolve(file)), bad);
     if (FORMAT_KEYS.some((k) => p[k] != null))
         settings.format = parseFormat(p, bad);
-    Object.assign(settings, parseStates(p, bad, settings.format !== undefined), readExtras(p.extras, !!settings.format, bad));
+    Object.assign(settings, parseStates(p, bad, settings.format !== undefined), readExtras(p.extras, !!settings.format, bad), readIdPattern(p.idPattern, bad));
     if (p.path != null && String(p.path).trim() === '')
         throw bad('path est vide');
     if (p.add != null && (typeof p.add !== 'string' || !p.add.includes('{title}')))
@@ -175,16 +168,7 @@ function parseFormat(p, bad) {
 }
 /** Clé `news:` de cadence.yaml. */
 export function readNewsConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const n = raw?.news;
+    const n = readYamlKey(file, 'news');
     if (n == null)
         return {};
     if (!isObject(n))
@@ -201,16 +185,7 @@ export function readNewsConfig(file) {
 const AUTOSTART = ['warn', 'refuse', 'start'];
 /** Clé `hook:` de cadence.yaml. */
 export function readHookConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const h = raw?.hook;
+    const h = readYamlKey(file, 'hook');
     if (h == null)
         return {};
     if (!isObject(h))
@@ -229,16 +204,7 @@ const PRICED_MODELS = ['sonnet', 'opus', 'haiku'];
 const PRICE_KEYS = ['input', 'output', 'cacheRead'];
 /** Clé `perf.prices` de cadence.yaml : la grille de prix du coût par lot livré ; null sans grille (clé absente ou vide). */
 export function readPerfConfig(file) {
-    if (!existsSync(file))
-        return null;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const perf = raw?.perf;
+    const perf = readYamlKey(file, 'perf');
     if (perf == null)
         return null;
     if (!isObject(perf))
@@ -276,16 +242,7 @@ export function readPerfConfig(file) {
  * joués par cadence au lieu d'être remplacés.
  */
 export function readSessionConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const s = raw?.session;
+    const s = readYamlKey(file, 'session');
     if (s == null)
         return {};
     if (!isObject(s))
@@ -316,16 +273,7 @@ const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
 const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'probe', 'fix', 'review', 'ux'];
 /** Clé `verify:` de cadence.yaml. Absente : `{}`. */
 export function readVerifyConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const v = raw?.verify;
+    const v = readYamlKey(file, 'verify');
     if (v == null)
         return {};
     if (!isObject(v))
@@ -344,16 +292,7 @@ const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeD
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
     const config = { precheck: true, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, worktrees: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', probe: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
-    if (!existsSync(file))
-        return config;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const o = raw?.orchestrate;
+    const o = readYamlKey(file, 'orchestrate');
     if (o == null)
         return config;
     const bad = (what) => new RafError(`${file} : orchestrate.${what}`);
@@ -583,15 +522,7 @@ const DOCS_KEYS = ['sync', 'since', 'articles'];
 /** Clé `docs:` de cadence.yaml : `docs.sync`, la documentation qui doit suivre le code. */
 export function readDocsConfig(file) {
     const none = { sync: [] };
-    if (!existsSync(file))
-        return none;
-    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?.describedBy != null) {
         throw new RafError(`${file} : describedBy n'existe plus (L308) : les documents hors dépôt se déclarent dans docs.articles, { repo, file } relatif au projet`);
     }
@@ -650,16 +581,7 @@ export function readDocsConfig(file) {
 }
 /** Clé `references:` de cadence.yaml. */
 export function readReferencesConfig(file) {
-    if (!existsSync(file))
-        return {};
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const r = raw?.references;
+    const r = readYamlKey(file, 'references');
     if (r == null)
         return {};
     if (!isObject(r))
@@ -676,16 +598,7 @@ export function readReferencesConfig(file) {
 /** Clé `migrate:` de cadence.yaml (L284) : `migrate.keep`. */
 export function readMigrateConfig(file) {
     const none = { keep: [] };
-    if (!existsSync(file))
-        return none;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const m = raw?.migrate;
+    const m = readYamlKey(file, 'migrate');
     if (m == null)
         return none;
     if (!isObject(m))

package/dist/corrections.js

@@ -198,32 +198,37 @@ Règle de départ : si le code livré ne fait pas ce que le lot ou le commit ann
 - donnees-sql : requête, schéma, migration, format ou contenu de données faux ;
 - test-manquant : le code est juste mais un comportement n'est pas couvert, ou un test ne vérifie pas ce que son titre promet ;
 - faux-constat : la revue se trompe (le code était correct, constat infondé, hors lot, sans effet réel).`;
+/** Appel `/api/chat` d'Ollama (température 0, sortie contrainte par `format`) : le texte du message, null sur réponse refusée ou échec réseau. Commun au classeur et au sous-classeur. */
+async function ollamaChat(opts, format, system, user) {
+    const doFetch = opts.fetch ?? fetch;
+    try {
+        const res = await doFetch(`${opts.url.replace(/\/$/, '')}/api/chat`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                model: opts.model,
+                stream: false,
+                options: { temperature: 0 },
+                format,
+                messages: [{ role: 'system', content: system }, { role: 'user', content: user }],
+            }),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return body.message?.content ?? '';
+    }
+    catch {
+        return null;
+    }
+}
 /** Classeur sur un modèle local servi par Ollama (/api/chat, température 0, sortie contrainte par un schéma) : hors quota Anthropic. */
 export function ollamaClassifier(opts) {
-    const doFetch = opts.fetch ?? fetch;
     return async (pass) => {
         const findings = pass.findings.length ? pass.findings.map((f, i) => `${i + 1}. ${f.slice(0, 1500)}`).join('\n') : '(aucun constat lisible)';
         const user = `Lot ${pass.project} ${pass.lot}.\nConstats de la revue :\n${findings}\n\nCommits de la correction :\n${pass.commits.join('\n') || '(aucun)'}`;
-        try {
-            const res = await doFetch(`${opts.url.replace(/\/$/, '')}/api/chat`, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({
-                    model: opts.model,
-                    stream: false,
-                    options: { temperature: 0 },
-                    format: { type: 'object', properties: { cause: { type: 'string', enum: [...CAUSES] }, raison: { type: 'string' } }, required: ['cause', 'raison'] },
-                    messages: [{ role: 'system', content: SYSTEM }, { role: 'user', content: user }],
-                }),
-            });
-            if (!res.ok)
-                return null;
-            const body = (await res.json());
-            return parseCause(body.message?.content ?? '');
-        }
-        catch {
-            return null;
-        }
+        const text = await ollamaChat(opts, { type: 'object', properties: { cause: { type: 'string', enum: [...CAUSES] }, raison: { type: 'string' } }, required: ['cause', 'raison'] }, SYSTEM, user);
+        return text === null ? null : parseCause(text);
     };
 }
 /** Classe les passes absentes du cache, une à une ; un échec n'entre pas au cache (une relance le reprend). */
@@ -323,30 +328,11 @@ const SOUS_SYSTEM = `Tu sous-classes une passe de correction déjà classée «
 ${SOUS_CAUSES.map((s) => `- ${s} : ${SOUS_DEFINITIONS[s]} ;`).join('\n')}`;
 /** Sous-classeur sur un modèle local servi par Ollama (comme `ollamaClassifier` : /api/chat, température 0, sortie contrainte par un schéma à sept valeurs). */
 export function ollamaSousClassifier(opts) {
-    const doFetch = opts.fetch ?? fetch;
     return async (pass) => {
         const findings = pass.findings.map((f, i) => `${i + 1}. ${f.slice(0, 1500)}`).join('\n');
         const user = `Lot ${pass.project} ${pass.lot}.\nConstats de la revue :\n${findings}\n\nCommits de la correction :\n${pass.commits.join('\n') || '(aucun)'}`;
-        try {
-            const res = await doFetch(`${opts.url.replace(/\/$/, '')}/api/chat`, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({
-                    model: opts.model,
-                    stream: false,
-                    options: { temperature: 0 },
-                    format: { type: 'object', properties: { sous: { type: 'string', enum: [...SOUS_CAUSES] }, raison: { type: 'string' } }, required: ['sous', 'raison'] },
-                    messages: [{ role: 'system', content: SOUS_SYSTEM }, { role: 'user', content: user }],
-                }),
-            });
-            if (!res.ok)
-                return null;
-            const body = (await res.json());
-            return parseSousCause(body.message?.content ?? '');
-        }
-        catch {
-            return null;
-        }
+        const text = await ollamaChat(opts, { type: 'object', properties: { sous: { type: 'string', enum: [...SOUS_CAUSES] }, raison: { type: 'string' } }, required: ['sous', 'raison'] }, SOUS_SYSTEM, user);
+        return text === null ? null : parseSousCause(text);
     };
 }
 /** La cause retenue d'une passe à constats : la relecture à la main, sinon le modèle ; absente sans classement. */

package/dist/docsync.js

@@ -1,5 +1,17 @@
 import { resolve } from 'node:path';
 import { changedFiles } from './git.js';
+/**
+ * Commits dont les fichiers comptent pour `docs.sync` (L537) : ceux de type `refactor` (`refactor(L1): …`) sont un nettoyage ou
+ * un découpage déclaré sans changement de commande, de clé ni de sortie, donc sans document à écrire. `refactor!` et un refactor
+ * dont le corps porte le pied `BREAKING CHANGE:` restent un changement.
+ */
+function docSyncCommits(commits) {
+    return commits.filter((c) => !/^refactor(\([^)]*\))?:/.test(c.subject) || /^BREAKING[ -]CHANGE:/m.test(c.body));
+}
+/** Les écarts d'un lot : les fichiers de `paths` viennent des commits qui comptent, mais un document écrit dans un refactor reste écrit. */
+export function lotDocSyncGaps(rules, root, commits) {
+    return docSyncGaps(rules, filesOf(root, docSyncCommits(commits)), filesOf(root, commits));
+}
 /** Motif de chemin : `*` reste dans un dossier, `**` le traverse, `?` un caractère, un `/` final prend tout le dossier ; sinon chemin exact. */
 export function docSyncMatcher(pattern) {
     const p = pattern.trim().replace(/\\/g, '/').replace(/^\.\//, '');
@@ -20,11 +32,11 @@ export function docSyncSet(patterns) {
 export function filesOf(root, commits, opts = {}) {
     return new Set(commits.flatMap((c) => changedFiles(root, c.sha, opts)));
 }
-/** Les règles que ces fichiers enfreignent : ils touchent `paths` sans qu'aucun `docs` ne soit parmi eux. */
-export function docSyncGaps(rules, files) {
+/** Les règles que ces fichiers enfreignent : ils touchent `paths` sans qu'aucun `docs` ne soit parmi les fichiers `written`. */
+function docSyncGaps(rules, files, written) {
     const gaps = [];
     for (const rule of rules) {
-        if ([...files].some(docSyncSet(rule.docs)))
+        if ([...written].some(docSyncSet(rule.docs)))
             continue;
         const inPaths = docSyncSet(rule.paths);
         const touched = [...files].filter(inPaths).sort();

package/dist/lead.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { basename, dirname, join, relative, sep } from 'node:path';
 import { audit, gateWaiting, nextUp, planCommits, workByLot } from './audit.js';
 import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readPlanConfig } from './config.js';
@@ -7,7 +7,7 @@ import { localRepoNotes } from './local-task.js';
 import { gitRoot, repoStatus } from './git.js';
 import { linkCommits } from './link.js';
 import { commitCount, lastActivity, lockStatus } from './session.js';
-import { parse } from 'yaml';
+import { isObject, readYamlFile, readYamlKey } from './yaml-keys.js';
 import { isOpen, RafError } from './plan.js';
 import { isRecurring } from './recurring.js';
 import { priorityRank, readPriority } from './orchestrate/continue.js';
@@ -20,16 +20,7 @@ import { KEPT_TITLE, keptLine, keptTrees } from './orchestrate/worktree.js';
 /** Le bloc `lead:` du cadence.yaml du dossier parent (absent = `undefined`) ; un `lead` qui n'est pas une table est refusé en nommant `key`. */
 function readLeadBlock(parent, key, expected) {
     const file = join(parent, 'cadence.yaml');
-    if (!existsSync(file))
-        return undefined;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const l = raw?.lead;
+    const l = readYamlKey(file, 'lead');
     if (l == null)
         return undefined;
     if (typeof l !== 'object' || Array.isArray(l))
@@ -52,8 +43,8 @@ export function findLeadDir(start) {
         const file = join(dir, 'cadence.yaml');
         if (existsSync(file)) {
             try {
-                const raw = parse(readFileSync(file, 'utf8'));
-                if (raw && typeof raw === 'object' && ('lead' in raw || 'priority' in raw))
+                const raw = readYamlFile(file);
+                if (isObject(raw) && ('lead' in raw || 'priority' in raw))
                     return dir;
             }
             catch {
@@ -79,16 +70,7 @@ export function readLeadContextThreshold(parent) {
 /** Clé `depth:` du cadence.yaml du dossier parent (L201, issue #8), à côté de `priority:` : combien de niveaux `lead tour` parcourt (1 : sous-dossiers directs, le défaut). */
 export function readDepth(parent) {
     const file = join(parent, 'cadence.yaml');
-    if (!existsSync(file))
-        return 1;
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const d = raw?.depth;
+    const d = readYamlKey(file, 'depth');
     if (d == null)
         return 1;
     if (typeof d !== 'number' || !Number.isInteger(d) || d < 1)

package/dist/orchestrate/attente.js

@@ -0,0 +1,82 @@
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { processStart } from '../proc.js';
+import { holderAlive } from './lock.js';
+import { lotKey } from './state.js';
+import { priorityRank, readPriority } from './continue.js';
+const waitersDir = (home) => join(home, 'waiters');
+let waiterSeq = 0;
+/** Les attentes vivantes, toutes vagues confondues, de la première servie à la dernière : étape en cours avant nouveau tirage, puis rang de priorité, puis ancienneté. */
+function liveWaiters(home) {
+    let names;
+    try {
+        names = readdirSync(waitersDir(home)).filter((n) => n.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names) {
+        const file = join(waitersDir(home), n);
+        try {
+            const r = JSON.parse(readFileSync(file, 'utf8'));
+            const w = {
+                pid: Number(r.pid),
+                start: r.start === undefined ? undefined : String(r.start),
+                wave: String(r.wave),
+                since: Number(r.since),
+                seq: Number(r.seq),
+                fresh: !!r.fresh,
+                rank: Number.isFinite(Number(r.rank)) ? Number(r.rank) : Number.MAX_SAFE_INTEGER,
+                file,
+            };
+            if (holderAlive(w.pid, w.start))
+                out.push(w);
+            else
+                rmSync(file, { force: true }); // le processus est mort sans désinscrire son attente
+        }
+        catch {
+            // inscription illisible (en cours d'écriture) : ignorée à ce tour
+        }
+    }
+    return out.sort((a, b) => Number(a.fresh) - Number(b.fresh) || a.rank - b.rank || a.since - b.since || a.pid - b.pid || a.seq - b.seq);
+}
+/** Inscrit une attente de créneau le temps de `run`, qui reçoit la question « est-ce mon tour ? » ; désinscrite à la fin, obtenue ou abandonnée (L531). */
+export async function whileWaiting(home, o, run) {
+    const me = {
+        pid: process.pid,
+        start: processStart(process.pid) ?? undefined,
+        wave: o.wave,
+        since: Date.now(),
+        seq: waiterSeq++,
+        fresh: o.fresh ?? false,
+        rank: o.rank ?? Number.MAX_SAFE_INTEGER,
+    };
+    const file = join(waitersDir(home), `${me.pid}-${me.seq}.json`);
+    mkdirSync(waitersDir(home), { recursive: true });
+    writeFileSync(file, JSON.stringify(me));
+    try {
+        return await run(() => liveWaiters(home)[0]?.file === file);
+    }
+    finally {
+        rmSync(file, { force: true });
+    }
+}
+/** Un créneau est à prendre quand le total est sous le plafond et qu'aucune attente vivante ne passe avant la nôtre. */
+export const hasRoom = (taken, limit, myTurn) => taken() < limit && myTurn();
+/**
+ * La place dans la file des créneaux de la session que le lot `key` (`projet:lot`) lance : un lot qui n'a qu'un pas (celui qui part, déjà inscrit) n'a rien joué (`fresh`) ;
+ * le rang est celui de son projet dans `priority:` (`--priority`, sinon le cadence.yaml du dossier de lancement ; illisible : rang neutre). Lot inconnu : place neutre.
+ */
+export function slotPlace(all, launch, given, key) {
+    const l = key ? all.find((x) => lotKey(x.project, x.lot) === key) : undefined;
+    if (!l)
+        return {};
+    const fresh = l.steps.length <= 1;
+    try {
+        return { fresh, rank: priorityRank(l.project, given ?? readPriority(launch)) };
+    }
+    catch {
+        return { fresh }; // priority: illisible : rang neutre (après tous les déclarés), le lancement n'en dépend pas
+    }
+}

package/dist/orchestrate/command-args.js

@@ -0,0 +1,138 @@
+import { isDay } from '../dates.js';
+import { RafError } from '../plan.js';
+import { parsePriority } from './continue.js';
+import { resumeCommand } from './table.js';
+/** Sessions simultanées, toutes vagues confondues (`--max-sessions`, ou CADENCE_MAX_SESSIONS). */
+export const DEFAULT_MAX_SESSIONS = 2;
+/** `1500000`, `1.5M`, `800k`. */
+export function parseBudget(text) {
+    const m = /^(\d+(?:[.,]\d+)?)\s*([kKmM]?)$/.exec(text.trim());
+    if (!m)
+        throw new RafError(`--budget invalide : ${text} (1500000, 1.5M, 800k)`);
+    const n = Number(m[1].replace(',', '.')) * ({ '': 1, k: 1e3, m: 1e6 }[m[2].toLowerCase()]);
+    if (!(n > 0))
+        throw new RafError(`--budget invalide : ${text}`);
+    return Math.round(n);
+}
+export function parseMaxSessions(text, what = '--max-sessions') {
+    if (!/^\d+$/.test(text.trim()) || Number(text) < 1)
+        throw new RafError(`${what} invalide : ${text} (entier ≥ 1)`);
+    return Number(text);
+}
+// une vague (2026-10-04-1412) n'a ni « : » ni « / » : leur présence désigne un lot, quel que soit son motif (R-M7/ux-1)
+export const LOT_LIKE = /^(?:[\w.-]+(?:\/[\w.-]+)*:[\w.-][\w./-]*|[\w.-]+\/[\w./-]*|[A-Za-z]+\d+)(?:@[\w.-]+)?$/;
+function lotArg(text) {
+    // le premier « : » sépare le projet du lot, un « @ » final le modèle ; le lot garde ses « / » (L120), le projet peut être un chemin depuis le dossier (`groupe/gamma`, projet imbriqué de lead tour --depth, L201)
+    const m = /^(?:([\w.-]+(?:\/[\w.-]+)*):)?([\w.-][\w./-]*?)(?:@([\w.-]+))?$/.exec(text);
+    if (!m)
+        throw new RafError(`lot invalide : ${text} (projet:lot, lot, projet:lot@haiku ; @ suivi d'un alias ou d'un nom de modèle)`);
+    return { project: m[1], lot: m[2], model: m[3] };
+}
+/** `projet:lot=+200k`, `lot=+0.3M` (L223) : le « = » distingue le relèvement d'un lot du budget de la vague. */
+function lotBudgetArg(text) {
+    const bad = () => new RafError(`--budget invalide : ${text} (projet:lot=+500k)`);
+    const m = /^([^=]+)=\+(.+)$/.exec(text);
+    if (!m)
+        throw bad();
+    let target;
+    let raise;
+    try {
+        target = lotArg(m[1]);
+        raise = parseBudget(m[2]);
+    }
+    catch {
+        throw bad();
+    }
+    if (target.model)
+        throw bad();
+    return { project: target.project, lot: target.lot, raise, text: m[2] };
+}
+export function parseOrchestrateArgs(argv) {
+    const a = { lots: [], lotBudgets: [], dryRun: false, waits: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false, add: [], integrate: [], abandonCommits: false };
+    const optional = (i) => (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-') && !LOT_LIKE.test(argv[i + 1]) ? argv[i + 1] : undefined);
+    for (let i = 0; i < argv.length; i++) {
+        const t = argv[i];
+        const value = (flag) => {
+            if (argv[i + 1] === undefined)
+                throw new RafError(`${flag} attend une valeur`);
+            return argv[++i];
+        };
+        if (t === '--dry-run')
+            a.dryRun = true;
+        else if (t === '--status' || t === '--resume') {
+            const v = optional(i);
+            if (v !== undefined)
+                i++;
+            a[t === '--status' ? 'status' : 'resume'] = v ?? true;
+        }
+        else if (t === '--waits')
+            a.waits = true;
+        else if (t === '--since') {
+            a.since = value(t);
+            if (!isDay(a.since))
+                throw new RafError(`--since invalide : ${a.since} (AAAA-MM-JJ)`);
+        }
+        else if (t === '--detail')
+            a.detail = value(t);
+        else if (t === '--watch')
+            a.watch = true;
+        else if (t === '--interval')
+            a.interval = parseMaxSessions(value(t), '--interval');
+        else if (t === '--budget') {
+            const v = value(t);
+            if (v.includes('='))
+                a.lotBudgets.push(lotBudgetArg(v));
+            else
+                a.budget = parseBudget(v);
+        }
+        else if (t === '--max-sessions')
+            a.maxSessions = parseMaxSessions(value(t));
+        else if (t === '--goal') {
+            // Un texte oublié ne doit pas avaler l'option suivante (`--goal --dry-run` lancerait une vraie vague payante).
+            const next = argv[i + 1];
+            if (next?.startsWith('--'))
+                throw new RafError(`--goal attend un texte, pas l'option ${next}`);
+            a.goal = value(t).trim();
+            if (a.goal === '')
+                throw new RafError('--goal attend un texte non vide');
+        }
+        else if (t === '--wave')
+            a.wave = value(t);
+        else if (t === '--drop')
+            a.drop.push(lotArg(value(t)));
+        else if (t === '--stop-after-current')
+            a.stopAfterCurrent = true;
+        else if (t === '--add')
+            a.add.push(lotArg(value(t)));
+        else if (t === '--integrate')
+            a.integrate.push(lotArg(value(t)));
+        else if (t === '--replay')
+            a.integrate.push({ ...lotArg(value(t)), replay: true });
+        else if (t === '--remove-worktree')
+            a.removeWorktree = lotArg(value(t));
+        else if (t === '--abandon-commits')
+            a.abandonCommits = true;
+        else if (t === '--continue')
+            a.continue = true;
+        else if (t === '--until')
+            a.until = value(t);
+        else if (t === '--priority')
+            a.priority = parsePriority(value(t));
+        else if (t === '--answer') {
+            const target = lotArg(value(t));
+            a.answers.push({ project: target.project, lot: target.lot, text: value(t) });
+        }
+        else if (t.startsWith('-'))
+            throw new RafError(`option inconnue : ${t}`);
+        else
+            a.lots.push(lotArg(t));
+    }
+    // L309 : --wave <id> après un --resume sans valeur désigne la vague à reprendre ; sans cela le --resume reprenait en silence une AUTRE vague.
+    if (a.resume !== undefined && a.wave !== undefined) {
+        if (a.resume === true)
+            a.resume = a.wave;
+        else if (a.resume !== a.wave)
+            throw new RafError(`--resume ${a.resume} et --wave ${a.wave} désignent deux vagues : une seule (${resumeCommand('<vague>')})`);
+    }
+    return a;
+}