@sylad/cadence 1.41.0 → 1.42.1

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

@@ -1,7 +1,7 @@
 import { gateProgress, gateText } from '../audit.js';
 import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { availableParallelism, homedir, tmpdir } from 'node:os';
+import { availableParallelism, tmpdir } from 'node:os';
 import { testWorkersFrom } from './workers.js';
 import { basename, join, resolve } from 'node:path';
 import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readOrchestrateConfig, readPlanConfig } from '../config.js';
@@ -29,15 +29,17 @@ import { fichesDuDossier } from '../spec.js';
 import { candidates, fillTargets, handedBackStreak, parsePriority, parseUntil, drawSettingsReport, readPriority, stopReason } from './continue.js';
 import { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, leadReviewedHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
 import { installPrePush, keepGateGuard, longDuration, removePrePush } from './guard.js';
-import { buildArgs, buildLocalArgs, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude, enabledPlugins, settingsFiles } from './launch.js';
+import { buildArgs, buildLocalArgs, claudeConfigDir, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude, enabledPlugins, settingsFiles } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { groupLots, runPool } from './pool.js';
+import { slotPlace } from './attente.js';
 import { AddFeed, addNotAlone, addToLive, openInRepo, projectName } from './ajout.js';
 import { repoRefusals, trackedDirty } from './depot.js';
+import { adoptLeadReview, depositIntegrations, depositsOnly, integrationText, runsElsewhere, takeIntegrations } from './integration-vivante.js';
 import { removeWorktree } from './retrait.js';
 import { repoBranch } from './integrate.js';
 import { baseBranchOf, keptLines, lotBranch, lotTreeDir, planFileSet, recoverTree } from './worktree.js';
-import { agentOf, schemaFor } from './schemas.js';
+import { effortKey, schemaFor, stepAgent } from './schemas.js';
 import { resolveLotRepos } from '../repos.js';
 import { excludeState, lotFinished, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
 import { isExpress } from './express.js';
@@ -527,7 +529,7 @@ function dryRun(lots, io, deps, { budget, id, multiSlot }) {
             writeFileSync(file, renderBrief(briefName(l, s.kind), s.kind === 'fiche' || vars.fiche === undefined ? vars : { ...vars, fiche: '' }, deps.templatesDir)); // la consigne de revue de fiche ne sert qu'au brief de la fiche : implement et review en sont la base d'une délégation à la main
             const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen).playwright;
             const local = s.model === 'local';
-            const args = (local ? buildLocalArgs : buildArgs)({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model === 'local' ? 'sonnet' : s.model, local, effort: env.config.effort[s.kind === 'review-small' ? 'review' : s.kind], schema: schemaFor(s.kind), agent: agentOf(s.kind), cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && (s.kind === 'implement' || s.kind === 'spec') ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright, disablePlugins: enabledPlugins(settingsFiles(deps.claudeHome, l.repo)) }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
+            const args = (local ? buildLocalArgs : buildArgs)({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model === 'local' ? 'sonnet' : s.model, local, effort: env.config.effort[effortKey(s.kind)], schema: schemaFor(s.kind), agent: stepAgent(s.kind), cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && (s.kind === 'implement' || s.kind === 'spec') ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright, disablePlugins: enabledPlugins(settingsFiles(deps.claudeHome, l.repo)) }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
             io.out(`  ${s.kind} : ${local ? 'claude-local' : 'claude'} ${args.join(' ')}`);
             io.out(`    brief : ${file}`);
             const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen));
@@ -1102,9 +1104,8 @@ async function execute(wave, lots, store, io, deps, today, args, all = lots) {
         throw e;
     }
     // Plafond de sessions simultanées, toutes vagues confondues : chaque session attend un créneau libre avant de partir.
-    const claude = async (args, o) => {
-        const free = await acquireSlot(home, cap, {
-            wave: wave.id,
+    const claude = async (argv, o) => {
+        const free = await acquireSlot(home, cap, { wave: wave.id, ...slotPlace(all, launch, args.priority, o.lot), // L531 : place dans la file des créneaux, commune aux vagues
             pollMs: deps.slotPollMs,
             // L332 : une demande écrite pendant l'attente (`--drop` de ce lot, `--stop-after-current`) l'interrompt ; la session ne part pas.
             abandon: () => {
@@ -1120,7 +1121,7 @@ async function execute(wave, lots, store, io, deps, today, args, all = lots) {
             onGot: (ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}créneau de session obtenu après ${duration(ms)} d'attente`),
         });
         try {
-            return await deps.claude(args, o);
+            return await deps.claude(argv, o);
         }
         finally {
             free();
@@ -1259,6 +1260,8 @@ async function execute(wave, lots, store, io, deps, today, args, all = lots) {
                         taken.push(c);
                     }
                 }
+                // L532 : les intégrations déposées par `--resume --integrate` pendant la vague sont reprises de la même façon, au tour où le lot peut jouer.
+                taken.push(...(await takeIntegrations({ store, ctxs, wctx, settled }, canRun)));
                 if (taken.length) {
                     try {
                         updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)), lanes());
@@ -1469,6 +1472,9 @@ async function resume(args, argv, io, deps, launch, today) {
     const store = typeof args.resume === 'string' ? RunStore.find(launch, args.resume) : singleUnfinished(launch);
     if (!store)
         throw new RafError(`vague inconnue : ${args.resume}`);
+    // L532 : `--integrate` seul sur une vague qui tourne encore dépose l'intégration dans sa file au lieu de refuser ; dit avant l'instantané (le dépôt ne demande rien à son code) ; une reprise qui attend le dépôt (L443) est inscrite vivante mais ne joue pas encore : la vague doit être « running ». Avec une autre option de reprise ou --replay, le refus ci-dessous reste.
+    if (depositsOnly(args, runsElsewhere(store, launch)))
+        return depositIntegrations(args.integrate, io, store);
     if (deps.snapshot) {
         // La reprise tourne sur l'instantané de la vague, jamais sur le dist/ courant ; une vague d'avant L61 n'en a pas.
         if (LOT_LIKE.test(store.id) && snapshotExists(store.dir)) {
@@ -1743,19 +1749,14 @@ async function resume(args, argv, io, deps, launch, today) {
         for (const l of integ) {
             const k = lotKey(l.project, l.lot);
             const lead = leadReviewed.get(l);
-            if (lead) {
-                // 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é.
-                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 = [];
-            }
+            if (lead)
+                adoptLeadReview(l, lead);
             const planNote = l.next !== 'integrate'; // rendu sur une écriture de plan refusée (--replay) : le lot repart de l'étape gardée
             if (planNote && l.outcome?.startsWith(HYPOTHESES_HANDBACK))
                 l.hypotheses = undefined; // les notes d'hypothèses se posent de nouveau (sans doublon) à l'entrée de l'étape
             l.status = 'suspended';
             l.outcome = null;
-            const text = lead ? `intégration reprise (--resume --integrate) : revue conforme du lead hors vague, ${lead.head.slice(0, 7)}` : planNote ? `écriture du plan reprise à l'étape ${l.next} (--resume --replay)` : 'intégration reprise (--resume --integrate)';
+            const text = planNote ? `écriture du plan reprise à l'étape ${l.next} (--resume --replay)` : integrationText(lead ?? null);
             store.journal(`${k} → suspended — ${text}`);
             io.out(`${k} → suspended — ${text}`);
         }
@@ -1847,6 +1848,6 @@ export function realOrchestrateDeps(env) {
         },
         agentsDir: AGENTS_DIR,
         snapshot: child ? undefined : { packageRoot: PACKAGE_ROOT, reexec: spawnReexec },
-        claudeHome: env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'),
+        claudeHome: claudeConfigDir(env),
     };
 }

package/dist/orchestrate/continue.js

@@ -1,11 +1,10 @@
-import { existsSync, readFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
-import { parse } from 'yaml';
 import { nextUp } from '../audit.js';
 import { planLoader } from '../config.js';
 import { gitRoot } from '../git.js';
 import { findProjects, isProject } from '../lead.js';
 import { RafError } from '../plan.js';
+import { readYamlKey } from '../yaml-keys.js';
 import { lotBudget, projectEnv } from './command.js';
 import { readyFree } from '../ready-free.js';
 import { lotFinished, lotKey } from './state.js';
@@ -32,16 +31,7 @@ export function parsePriority(text) {
 /** Clé `priority:` du cadence.yaml du dossier de lancement (le dossier parent des projets) ; absente : aucune priorité déclarée. */
 export function readPriority(launchDir) {
     const file = join(launchDir, 'cadence.yaml');
-    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 p = raw?.priority;
+    const p = readYamlKey(file, 'priority');
     if (p == null)
         return [];
     if (!Array.isArray(p) || p.length === 0 || p.some((n) => typeof n !== 'string' || !n.trim()))