@sylad/cadence 1.8.0 → 1.10.0

package/dist/orchestrate/registry.js

@@ -1,4 +1,4 @@
-import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { processStart } from '../proc.js';
@@ -7,7 +7,8 @@ import { lotFinished, lotKey, lotRepoPaths, RunStore } from './state.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
- * des vagues vivantes (`waves/<pid>.json`) et les créneaux de sessions simultanées (`slots/slot-<n>.lock`).
+ * des vagues vivantes (`waves/<pid>.json`), les créneaux de sessions simultanées (`slots/slot-<n>.lock`) et les
+ * sessions lancées à la main par le lead (`holds/<étiquette>.json`, L255).
  * Les verrous de DÉPÔT restent dans le dépôt (`.git/cadence/orchestrate.lock`).
  */
 export function cadenceHome(env = process.env) {
@@ -21,6 +22,8 @@ function readWave(file) {
         const w = { pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), cwd: String(raw.cwd), repos: Array.isArray(raw.repos) ? raw.repos.map(String) : [] };
         if (raw.cap !== undefined)
             w.cap = Number(raw.cap);
+        if (raw.lanes !== undefined)
+            w.lanes = Number(raw.lanes);
         if (raw.start !== undefined)
             w.start = String(raw.start);
         return w;
@@ -48,13 +51,82 @@ export function liveWaves(home) {
 }
 /**
  * Les créneaux que le lead peut encore donner à des sous-agents : `total` moins, pour chaque vague vivante, le
- * plus petit de son plafond et du nombre de dépôts qu'elle tient encore (ses pas prennent un créneau et le
+ * plus petit de son plafond et du nombre de lots qu'elle joue à la fois — un par dépôt qu'elle tient encore, un par lot pour des lots en worktrees (ses pas prennent un créneau et le
  * rendent entre deux étapes : les sessions vivantes à l'instant ne disent pas ce que la vague va reprendre).
  * Une vague sans plafond connu compte pour `total`.
  */
-export function freeSlots(waves, total) {
-    const held = waves.reduce((n, w) => n + Math.min(w.cap ?? total, w.repos.length), 0);
-    return Math.max(0, total - held);
+export function freeSlots(waves, total, leadSessions = 0) {
+    const held = waves.reduce((n, w) => n + Math.min(w.cap ?? total, w.lanes ?? w.repos.length), 0);
+    return Math.max(0, total - held - leadSessions);
+}
+const holdsDir = (home) => join(home, 'holds');
+/** Le libellé est libre (espaces, « / »), le nom de fichier l'encode. */
+const holdFile = (home, label) => join(holdsDir(home), `${encodeURIComponent(label)}.json`);
+/** Inscrit la session `label` pour `ttlMinutes` minutes à partir de `now` ; la poser de nouveau la renouvelle. */
+export function addHold(home, label, ttlMinutes, now) {
+    mkdirSync(holdsDir(home), { recursive: true });
+    const file = holdFile(home, label);
+    const hold = { label, since: now.toISOString(), expires: new Date(now.getTime() + ttlMinutes * 60_000).toISOString() };
+    writeFileSync(`${file}.tmp`, JSON.stringify(hold));
+    renameSync(`${file}.tmp`, file);
+}
+/** Retire la session `label` ; faux quand elle n'était pas inscrite. */
+export function releaseHold(home, label) {
+    const file = holdFile(home, label);
+    if (!existsSync(file))
+        return false;
+    rmSync(file, { force: true });
+    return true;
+}
+/** Une session échue reste lisible (et signalée en ⚠) jusqu'à son `release` ou, oubliée, ce délai après son échéance. */
+const EXPIRED_HOLD_KEEP_MS = 24 * 3600_000;
+/** Lit les sessions du lead : celles dont l'échéance n'est pas passée à `now`, et celles échues depuis moins de 24 h ; le reste, et les fichiers illisibles, sont écartés au passage. */
+function scanHolds(home, now) {
+    let names;
+    try {
+        names = readdirSync(holdsDir(home)).filter((n) => n.endsWith('.json'));
+    }
+    catch {
+        return { live: [], expired: [] };
+    }
+    const live = [];
+    const expired = [];
+    for (const n of names) {
+        const file = join(holdsDir(home), n);
+        let hold = null;
+        let overdue = false;
+        try {
+            const raw = JSON.parse(readFileSync(file, 'utf8'));
+            const end = Date.parse(raw.expires);
+            if (typeof raw.label === 'string' && Number.isFinite(end)) {
+                hold = { label: raw.label, since: String(raw.since), expires: String(raw.expires) };
+                overdue = end <= now.getTime();
+                if (now.getTime() - end >= EXPIRED_HOLD_KEEP_MS)
+                    hold = null;
+            }
+        }
+        catch {
+            // illisible : écarté
+        }
+        if (!hold)
+            rmSync(file, { force: true });
+        else
+            (overdue ? expired : live).push(hold);
+    }
+    const byAge = (a, b) => a.since.localeCompare(b.since) || a.label.localeCompare(b.label);
+    return { live: live.sort(byAge), expired: expired.sort(byAge) };
+}
+/** Les sessions du lead dont l'échéance n'est pas passée à `now` : seules elles comptent dans les créneaux. */
+export function liveHolds(home, now) {
+    return scanHolds(home, now).live;
+}
+/**
+ * Les sessions du lead dont le TTL est échu à `now` (L278) et que personne n'a rendues : plus de créneau pris, mais la
+ * session tourne peut-être encore. `lead tour`, `orchestrate --status` et la bande les signalent en ⚠ : le lead la
+ * reprend (`lead hold`) ou l'arrête (`lead release`). Rien ne l'arrête ici.
+ */
+export function expiredHolds(home, now) {
+    return scanHolds(home, now).expired;
 }
 /** Inscrit la vague ; écarte au passage les entrées de processus morts (les `.tmp` d'une inscription en cours ne sont pas touchés). */
 export function registerWave(home, given) {
@@ -71,13 +143,13 @@ export function registerWave(home, given) {
     writeFileSync(`${file}.tmp`, JSON.stringify(w));
     renameSync(`${file}.tmp`, file);
 }
-/** Met à jour la liste des dépôts tenus par la vague (un dépôt libéré en cours de vague n'y figure plus). */
-export function updateWaveRepos(home, pid, repos) {
+/** Met à jour la liste des dépôts tenus par la vague (un dépôt libéré en cours de vague n'y figure plus) et, quand elle la donne, le nombre de lots qu'elle joue à la fois. */
+export function updateWaveRepos(home, pid, repos, lanes) {
     const file = join(wavesDir(home), `${pid}.json`);
     const w = readWave(file);
     if (!w)
         return;
-    writeFileSync(`${file}.tmp`, JSON.stringify({ ...w, repos }));
+    writeFileSync(`${file}.tmp`, JSON.stringify({ ...w, repos, ...(lanes === undefined ? {} : { lanes }) }));
     renameSync(`${file}.tmp`, file);
 }
 export function unregisterWave(home, pid) {
@@ -98,6 +170,16 @@ export function liveSlots(home) {
 const MAX_SLOT_INDEX = 64;
 /** Intervalle des rappels d'attente dans le journal. */
 const WAIT_REPORT_MS = 60_000;
+/** L'attente d'un créneau a été interrompue par `abandon` (L332) : aucun créneau n'a été pris, la session ne part pas. */
+export class SlotAbandoned extends Error {
+    reason;
+    /** Renseigné par `runSession` quand une session précédente de l'étape a déjà tourné : sa sortie et ses jetons ne se perdent pas. */
+    after;
+    constructor(reason) {
+        super(`attente de créneau abandonnée : ${reason}`);
+        this.reason = reason;
+    }
+}
 /**
  * Attend que le nombre de sessions vivantes, TOUTES vagues confondues et quel que soit l'index de leur créneau,
  * soit sous `cap` (le plafond de cette vague), puis prend le premier créneau libre (un pid mort est repris) et
@@ -108,6 +190,10 @@ const WAIT_REPORT_MS = 60_000;
  *
  * `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,
+ * puis à chaque tour ; une raison en retour interrompt l'attente par `SlotAbandoned`, sans prendre de créneau (L332 : `--drop` et
+ * `--stop-after-current` ne laissent pas un lot en attente). Un créneau libre est toujours pris, même si une demande est déjà posée :
+ * 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) {
     mkdirSync(slotsDir(home), { recursive: true });
@@ -116,7 +202,14 @@ export async function acquireSlot(home, cap, opts) {
     let reportedAt = null;
     const pollMs = opts.pollMs ?? 2000;
     const live = opts.slots ?? liveSlots; // injectable : les tests simulent une vague qui prend un créneau entre les deux comptées
+    const checkAbandon = () => {
+        const why = opts.abandon?.();
+        if (why)
+            throw new SlotAbandoned(why);
+    };
     for (;;) {
+        if (reportedAt !== null)
+            checkAbandon(); // pas à la première tentative : un créneau libre est pris même si une demande est posée
         if (live(home).length < cap) {
             for (let k = 0; k < MAX_SLOT_INDEX; k++) {
                 const file = join(slotsDir(home), `slot-${k}.lock`);
@@ -132,6 +225,8 @@ export async function acquireSlot(home, cap, opts) {
                 break;
             }
         }
+        if (reportedAt === null)
+            checkAbandon(); // la première tentative a échoué : l'attente commence, la demande déjà posée l'interrompt sans attendre un tour
         if (reportedAt === null || now() - reportedAt >= (opts.reportMs ?? WAIT_REPORT_MS)) {
             reportedAt = now();
             opts.onWait?.(live(home), reportedAt - t0);
@@ -139,26 +234,63 @@ export async function acquireSlot(home, cap, opts) {
         await new Promise((r) => setTimeout(r, pollMs + Math.random() * pollMs * 0.25));
     }
 }
-/** .git commun du dépôt `dir` (partagé par ses worktrees) ; null si `dir` n'est pas un dépôt. */
+/** .git commun du dépôt `dir` (partagé par ses worktrees), chemin réel (un lien symbolique vers le dépôt désigne le même) ; null si `dir` n'est pas un dépôt. */
 const commonDir = (dir) => {
     try {
-        return gitCommonDir(dir);
+        return realpathSync(gitCommonDir(dir));
     }
     catch {
         return null;
     }
 };
-/** Lots de la vague `pid` qui travaillent encore dans `repo` (en cours, en file ou suspendus) ; null si l'état de la vague est illisible. */
-export function openLotsIn(home, pid, repo) {
+/** Lots de la vague `pid` qui travaillent dans `repo` (ou l'un de ses worktrees), finis ou non ; null si l'état de la vague est illisible. */
+export function waveLotsIn(home, pid, repo) {
     try {
         const w = liveWaves(home).find((x) => x.pid === pid);
         const store = w && RunStore.find(w.cwd, w.wave);
         if (!store)
             return null;
         const mine = commonDir(repo);
-        return store.lots().filter((l) => !lotFinished(l) && lotRepoPaths(l).some((r) => r === repo || (mine !== null && commonDir(r) === mine))).map((l) => lotKey(l.project, l.lot));
+        return store.lots().filter((l) => lotRepoPaths(l).some((r) => r === repo || (mine !== null && commonDir(r) === mine)));
     }
     catch {
         return null;
     }
 }
+/** Lots de la vague `pid` qui travaillent encore dans `repo` (en cours, en file ou suspendus) ; null si l'état de la vague est illisible. */
+export function openLotsIn(home, pid, repo) {
+    return waveLotsIn(home, pid, repo)?.filter((l) => !lotFinished(l)).map((l) => lotKey(l.project, l.lot)) ?? null;
+}
+/**
+ * Vagues non terminées (`done` exclu : interrompues, suspendues, ou vivantes) lancées depuis `launchDir` qui gardent ouvert (état non terminal : question, suspendu, en file, en cours...)
+ * au moins un lot DU MÊME DÉPÔT que `repo` pour lequel `doing(lot)` est vrai (L238, `doing` : le lot est encore en cours au plan de ce dépôt). Un `--resume` rejouera ces lots sur ce dépôt :
+ * un rescellé commité entre-temps leur serait rendu comme « premier commit fautif ». Un lot livré au plan (vieille vague abandonnée) ou absent du plan ne compte jamais.
+ * Le dépôt d'un lot est celui de son projet (`lot.repo`), pas ses dépôts voisins : l'id d'un lot est propre au plan de son projet.
+ */
+export function openWavesIn(launchDir, repo, doing, live = []) {
+    const base = RunStore.runsDir(launchDir);
+    if (!existsSync(base))
+        return [];
+    const mine = commonDir(repo);
+    const out = [];
+    for (const id of readdirSync(base).sort()) {
+        try {
+            const store = RunStore.find(launchDir, id);
+            if (!store || store.readWave()?.status === 'done')
+                continue;
+            const open = store
+                .lots()
+                .filter((l) => !lotFinished(l) && (l.repo === repo || (mine !== null && commonDir(l.repo) === mine)))
+                .map((l) => ({ in: doing(l), key: lotKey(l.project, l.lot), status: l.status }));
+            const lots = open.filter((l) => l.in).map(({ key, status }) => ({ key, status }));
+            const others = open.filter((l) => !l.in).map(({ key, status }) => ({ key, status }));
+            const alive = live.find((w) => w.wave === id && w.cwd === launchDir);
+            if (lots.length)
+                out.push({ wave: id, launchDir, live: !!alive, ...(alive ? { pid: alive.pid } : {}), lots, others });
+        }
+        catch {
+            // état illisible : une vague qu'on ne sait pas lire ne bloque pas un rescellé du lead
+        }
+    }
+    return out;
+}

package/dist/orchestrate/result.js

@@ -51,7 +51,7 @@ export function parseSession(stdout, opts) {
 }
 /** Le message d'une session arrêtée par la limite d'usage (quota) ; l'heure de remise suit « | » quand elle est donnée. */
 export function isQuotaMessage(text) {
-    return /usage limit|limit reached|rate limit|quota/i.test(text);
+    return /usage limit|limit reached|hit your .{0,20}limit|rate limit|quota/i.test(text);
 }
 /** Heure de remise (epoch s) lue dans « …limit reached|1759600000 », sinon null. */
 export function quotaReset(text) {

package/dist/orchestrate/snapshot.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, realpathSync, symlinkSync } from 'node:fs';
+import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readlinkSync, realpathSync, rmSync, symlinkSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { join, sep } from 'node:path';
 import { createInterface } from 'node:readline';
@@ -74,6 +74,34 @@ export function takeSnapshot(waveDir, packageRoot) {
     }
     return tool;
 }
+/**
+ * L330 : `<vague>/tool/node_modules` vise le `node_modules` de la copie qui a lancé la vague ; la purge de `npm run service`
+ * retire cette copie quand elle sort des versions gardées, et le lien reste pendu (la reprise planterait sur `yaml`).
+ * Si le lien ne se résout plus, on le refait vers le `node_modules` du paquet courant (la copie en service) et on le dit
+ * (message rendu) ; s'il est irréparable, `SnapshotRefusal` : un refus clair, pas une trace de pile. Rien à faire : undefined.
+ */
+export function repairSnapshotModules(waveDir, packageRoot) {
+    const link = join(toolDirOf(waveDir), 'node_modules');
+    if (existsSync(join(link, 'yaml', 'package.json')))
+        return undefined;
+    let was = 'absent';
+    try {
+        was = readlinkSync(link);
+    }
+    catch {
+        /* pas un lien (ou rien) : on le remplace quand même */
+    }
+    let modules;
+    try {
+        modules = resolveModulesDir(packageRoot);
+    }
+    catch (e) {
+        throw new SnapshotRefusal(`le node_modules de l'instantané de la vague (${was}) ne se résout plus et celui du paquet courant non plus, reprise impossible : ${e instanceof Error ? e.message : e}`);
+    }
+    rmSync(link, { recursive: true, force: true });
+    symlinkSync(modules, link, 'dir');
+    return `instantané : node_modules (${was}) ne se résolvait plus, la copie qui l'avait lancé a été retirée de la mise en service ; relié à ${modules}`;
+}
 export const snapshotExists = (waveDir) => existsSync(join(toolDirOf(waveDir), 'bin', 'cadence.js'));
 /**
  * La vague lit-elle `control.log` (`--drop`, `--stop-after-current`, L79) ? Elle tourne sur son instantané : une vague lancée
@@ -103,6 +131,20 @@ export function waveReadsLotBudget(waveDir) {
         return false;
     }
 }
+/**
+ * L'instantané de la vague connaît-il `--resume --integrate` (L279) ? Un instantané plus ancien refuserait l'option comme inconnue.
+ * Sans instantané : rien à relire, on suppose que oui.
+ */
+export function waveReadsIntegrate(waveDir) {
+    if (!snapshotExists(waveDir))
+        return true;
+    try {
+        return readFileSync(join(toolDirOf(waveDir), 'dist', 'orchestrate', 'command.js'), 'utf8').includes('abandonCommits');
+    }
+    catch {
+        return false;
+    }
+}
 /** Relance réelle : un processus node sur la copie, signaux transmis, code de sortie rendu. */
 export function spawnReexec(toolDir, argv, env, sink) {
     return new Promise((resolve, reject) => {
@@ -125,3 +167,14 @@ export function spawnReexec(toolDir, argv, env, sink) {
         });
     });
 }
+/** L'instantané de la vague connaît-il `--resume --replay` (L279, reprise d'un lot rendu sur une écriture de plan refusée) ? Sans instantané : on suppose que oui. */
+export function waveReadsReplay(waveDir) {
+    if (!snapshotExists(waveDir))
+        return true;
+    try {
+        return readFileSync(join(toolDirOf(waveDir), 'dist', 'orchestrate', 'command.js'), 'utf8').includes("'--replay'");
+    }
+    catch {
+        return false;
+    }
+}

package/dist/orchestrate/spec.js

@@ -1,7 +1,7 @@
 import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { parse } from 'yaml';
+import { isMap, isNode, isScalar, isSeq, parse, parseDocument, stringify } from 'yaml';
 import { acceptationFile } from './accept.js';
 import { checkFiche, fichesDuDossier, LARGEURS } from '../spec.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
@@ -75,13 +75,97 @@ export function ficheReady(repo, fiche, lot, parts = { screen: true, back: false
         return false;
     }
 }
-/** Consigne de reprise après la réponse du lead à des hypothèses coûteuses : la règle confirmée n'est plus une hypothèse. */
-export function answeredText(asked, answer) {
+/** Début de la ligne qui contient l'offset. */
+const lineStart = (text, at) => text.lastIndexOf('\n', at - 1) + 1;
+/** Fin de la ligne qui contient l'offset, saut de ligne compris (ou la fin du texte). */
+const lineEnd = (text, at) => {
+    if (at > 0 && text[at - 1] === '\n')
+        return at; // un scalaire bloc finit déjà en début de ligne
+    const nl = text.indexOf('\n', at);
+    return nl === -1 ? text.length : nl + 1;
+};
+/**
+ * Passe en `sourcee` les règles `hypothese` nommées (L297) : `source` dit d'où vient la réponse, `si_faux` disparaît. Seules les lignes `statut`,
+ * `source` et `si_faux` de ces règles sont éditées dans le texte (L302) : le reste de la fiche — ordre, commentaires, style de flux `[R2]` — est conservé
+ * à l'octet près, ce qu'une réécriture du document (`doc.toString`) ne garantit pas. Une règle écrite en style de flux (`{id: R1, …}`) n'est pas éditée : erreur.
+ * Rend les ids effectivement changés ; une règle absente ou déjà sourcée n'est pas touchée.
+ */
+export function sourceRules(repo, fiche, ids, source) {
+    const file = join(repo, fiche);
+    const text = readFileSync(file, 'utf8');
+    const regles = parseDocument(text).get('regles');
+    if (!isSeq(regles))
+        return [];
+    const changed = [];
+    const edits = [];
+    const sourceValue = stringify(source).trimEnd();
+    for (const r of regles.items) {
+        if (!isMap(r))
+            continue;
+        const id = String(r.get('id'));
+        if (!ids.includes(id) || r.get('statut') !== 'hypothese')
+            continue;
+        if (r.flow)
+            throw new Error(`${id} est écrite en style de flux (${fiche}) : à passer en sourcée à la main`);
+        const pair = (key) => r.items.find((p) => isScalar(p.key) && p.key.value === key);
+        const statut = pair('statut');
+        const valueEnd = (p) => (isNode(p.value) && p.value.range ? p.value.range[1] : p.key.range[1]);
+        if (!statut || !isNode(statut.value) || !statut.value.range || !isNode(statut.key) || !statut.key.range)
+            continue;
+        edits.push({ start: statut.value.range[0], end: statut.value.range[1], text: 'sourcee' });
+        const src = pair('source');
+        if (src && isNode(src.value) && src.value.range)
+            edits.push({ start: src.value.range[0], end: src.value.range[1], text: sourceValue });
+        else {
+            const at = lineEnd(text, valueEnd(statut));
+            const indent = ' '.repeat(statut.key.range[0] - lineStart(text, statut.key.range[0]));
+            edits.push({ start: at, end: at, text: `${at > 0 && text[at - 1] !== '\n' ? '\n' : ''}${indent}source: ${sourceValue}\n` });
+        }
+        const siFaux = pair('si_faux');
+        if (siFaux && isNode(siFaux.key) && siFaux.key.range)
+            edits.push({ start: lineStart(text, siFaux.key.range[0]), end: lineEnd(text, valueEnd(siFaux)), text: '' });
+        changed.push(id);
+    }
+    if (!changed.length)
+        return changed;
+    let out = text;
+    for (const e of edits.sort((x, y) => y.start - x.start || y.end - x.end))
+        out = out.slice(0, e.start) + e.text + out.slice(e.end);
+    writeFileSync(file, out);
+    return changed;
+}
+/**
+ * La réponse du lead corrige-t-elle la règle (la supprime, la change, la remplace) au lieu de la confirmer ? Une lecture prudente (L302) : au moindre
+ * mot de correction ou de refus, la règle n'est pas passée en `sourcee` telle quelle, la session spec reprise l'applique. Se tromper dans ce sens
+ * ne coûte qu'une session ; l'autre sens source une règle que le lead vient de refuser.
+ */
+export function answerAltersRule(answer) {
+    return /(?<![\p{L}])(non|no|pas|supprim\p{L}*|retir\p{L}*|enl[eè]v\p{L}*|abandonn\p{L}*|chang\p{L}*|modifi\p{L}*|remplac\p{L}*|corrig\p{L}*|plut[oô]t|à la place|sauf|remove|delet\p{L}*|drop|change|replace\p{L}*|instead|rather|except)(?![\p{L}])/iu.test(answer);
+}
+/** Les règles nommées que la fiche donne déjà pour sourcées par la réponse du lead (ce que `sourceRules` a posé). */
+export function ruleIdsSourcedByLead(repo, fiche, ids) {
+    try {
+        const doc = parse(readFileSync(join(repo, fiche), 'utf8'));
+        return list(isObj(doc) ? doc.regles : []).filter((r) => ids.includes(String(r.id)) && r.statut === 'sourcee' && String(r.source).startsWith(LEAD_SOURCE)).map((r) => String(r.id));
+    }
+    catch {
+        return [];
+    }
+}
+/** Début de la source d'une règle tranchée par le lead : `réponse du lead, <date>, vague <id>`. */
+export const LEAD_SOURCE = 'réponse du lead';
+/**
+ * Consigne de reprise après la réponse du lead à des hypothèses coûteuses. Les règles que le programme a déjà passées en `sourcee` (`sourced`) ne sont plus à
+ * réécrire que si le lead les a corrigées ; les autres, l'agent les passe lui-même.
+ */
+export function answeredText(asked, answer, sourced = []) {
     return [
         'The program asked the lead about expensive-to-undo hypotheses of your sheet:',
         ...asked.map((q) => `- ${q}`),
         `Answer from the lead: ${answer}`,
-        'Apply it to the sheet: a rule the lead confirms becomes `statut: sourcee` with `source: réponse du lead` (no `si_faux`); a rule the lead corrects is rewritten as they say (`sourcee`, same source). Do not leave it as `hypothese`, or the program asks the same question again.',
+        sourced.length
+            ? `The program already set ${sourced.join(', ')} to \`statut: sourcee\` with the lead's answer as its \`source\` (no \`si_faux\`). Touch the sheet only if the lead corrected a rule: rewrite its \`enonce\` as they say and keep the \`sourcee\` status and the \`source\`. Do not turn it back into a \`hypothese\`.`
+            : 'Apply it to the sheet: a rule the lead confirms becomes `statut: sourcee` with `source: réponse du lead` (no `si_faux`); a rule the lead corrects is rewritten as they say (`sourcee`, same source). Do not leave it as `hypothese`, or the program asks the same question again.',
     ].join('\n');
 }
 /** Fichiers suivis par git sous un dossier (chemins relatifs au dépôt). */

package/dist/orchestrate/state.js

@@ -1,6 +1,12 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join, relative } from 'node:path';
 import { gitCommonDir, gitRoot } from '../git.js';
+/** Début de l'avertissement d'un rapport de précheck illisible (Sonnet) : le journal le garde, `cadence perf` s'en sert pour ne pas compter ce lot « non » (L293). */
+/** Avertissement d'un rapport du précheck local illisible : l'étape reste `ok`, le lot se replie sur Sonnet (L322, lu par `cadence perf` pour compter l'échec du local). */
+export const LOCAL_PRECHECK_UNREADABLE = 'contrôle préalable : rapport du modèle local illisible';
+export const PRECHECK_UNREADABLE = 'contrôle préalable illisible, implémentation lancée';
 export function newLot(o) {
     return { ...o, status: 'queued', pass: 0, next: null, steps: [], constats: [], verdict: null, uxVerdict: null, questions: [], choix: [], answers: [], proposals: [], warnings: [], outcome: null };
 }
@@ -12,6 +18,8 @@ export const lotRepoPaths = (l) => [l.repo, ...(l.repos ?? []).map((r) => r.path
 export const neighbourDirs = (l) => (l.repos ?? []).map((r) => r.path);
 export const lotKey = (project, lot) => `${project}:${lot}`;
 /** Nom de dossier d'un lot dans la vague : le « / » d'un id de sous-tâche (`Q4/accueil-4-ux12`) ou d'un projet imbriqué (`groupe/gamma`) devient « __ » ; sans « / » le nom est inchangé. */
+/** Racine des TMPDIR de session : `os.tmpdir()`, ou `/tmp` quand celui-ci est trop long pour laisser 60 caractères sous la limite de 107 des sockets Unix. */
+const shortTmpBase = () => (join(tmpdir(), 'cadence-xxxxxxxx').length + 60 < 108 ? tmpdir() : '/tmp');
 export const lotSlug = (project, lot) => `${project.split('/').join('__')}--${lot.split('/').join('__')}`;
 const lotFile = (project, lot) => `${lotSlug(project, lot)}.json`;
 function atomicWrite(file, data) {
@@ -55,22 +63,25 @@ export class RunStore {
     static runsDir(launchDir) {
         return join(launchDir, '.cadence', 'runs');
     }
-    /** La dernière vague lancée (par date de lancement : un identifiant libre comme `ol-gains-1` ne se range pas par ordre alphabétique) ; avec `unfinished`, la dernière qui n'est pas terminée. */
-    static last(launchDir, opts = {}) {
+    /** Les vagues du dossier, la plus récente d'abord (par date de lancement : un identifiant libre comme `ol-gains-1` ne se range pas par ordre alphabétique). */
+    static all(launchDir) {
         const base = RunStore.runsDir(launchDir);
         if (!existsSync(base))
-            return null;
-        const stores = readdirSync(base)
+            return [];
+        return readdirSync(base)
             .filter((n) => existsSync(join(base, n, 'wave.json')))
             .map((id) => new RunStore(launchDir, id))
             .map((store) => ({ store, wave: store.readWave() }))
             // lancement le plus récent d'abord ; à date égale (ou illisible), l'identifiant le plus grand
             .sort((a, b) => (b.wave?.created ?? '').localeCompare(a.wave?.created ?? '') || b.store.id.localeCompare(a.store.id));
-        for (const { store, wave } of stores) {
-            if (!opts.unfinished || wave?.status !== 'done')
-                return store;
-        }
-        return null;
+    }
+    /** La dernière vague lancée. */
+    static last(launchDir) {
+        return RunStore.all(launchDir)[0]?.store ?? null;
+    }
+    /** Les vagues qui ne sont pas terminées (une vague illisible compte : elle n'est pas `done`), la plus récente d'abord (L309). */
+    static unfinished(launchDir) {
+        return RunStore.all(launchDir).filter((x) => x.wave?.status !== 'done').map((x) => x.store);
     }
     static find(launchDir, id) {
         return existsSync(join(RunStore.runsDir(launchDir), id, 'wave.json')) ? new RunStore(launchDir, id) : null;
@@ -80,6 +91,28 @@ export class RunStore {
         mkdirSync(d, { recursive: true });
         return d;
     }
+    /**
+     * Dossier temporaire des sessions d'un lot (L243) : `<tmpdir>/cadence-<hash court du dossier du lot>`, hors du dépôt et hors de la vague, jamais suivi par git.
+     * Il est COURT à dessein : Chrome (Playwright MCP) range ses sockets Unix sous `TMPDIR` et refuse au-delà de 107 caractères
+     * (sous `.cadence/runs/<vague>/<projet>--<lot>/tmp`, L242, la revue UX échouait « Socket path too long »).
+     * Un lien `<lotDir>/tmp` y renvoie, pour le retrouver depuis le dossier de la vague.
+     */
+    tmpDir(project, lot) {
+        const lotDir = this.lotDir(project, lot);
+        const d = join(shortTmpBase(), `cadence-${createHash('sha1').update(lotDir).digest('hex').slice(0, 8)}`);
+        mkdirSync(d, { recursive: true });
+        const link = join(lotDir, 'tmp');
+        rmSync(link, { recursive: true, force: true });
+        symlinkSync(d, link);
+        return d;
+    }
+    /** Supprime le dossier temporaire du lot et son lien (fin de lot) ; sans effet s'ils n'existent pas. */
+    removeTmpDir(project, lot) {
+        const link = join(this.lotDir(project, lot), 'tmp');
+        if (lstatSync(link, { throwIfNoEntry: false })?.isSymbolicLink())
+            rmSync(readlinkSync(link), { recursive: true, force: true });
+        rmSync(link, { recursive: true, force: true });
+    }
     writeWave(w) {
         atomicWrite(join(this.dir, 'wave.json'), w);
     }
@@ -131,17 +164,25 @@ export class RunStore {
         appendFileSync(join(this.dir, 'journal.log'), `${new Date().toISOString()} ${line}\n`);
     }
 }
-/** Ajoute `.cadence/` à `.git/info/exclude` quand le dossier de lancement est dans un dépôt : l'état ne salit jamais un arbre. */
+/**
+ * Ajoute `.cadence/runs/` (états de vague) et `.cadence/corrections.json` (cache de `cadence corrections`) à `.git/info/exclude`
+ * quand le dossier de lancement est dans un dépôt : l'état ne salit jamais un arbre. Le reste de `.cadence/` (le plan, ses notes)
+ * est versionné. L'ancienne ligne `/.cadence/`, écrite par une version précédente, est remplacée : elle cacherait aussi le plan.
+ */
 export function excludeState(launchDir) {
     const root = gitRoot(launchDir);
     if (!root)
         return;
-    const rel = relative(root, join(launchDir, '.cadence')).split('\\').join('/');
-    const pattern = `/${rel}/`;
+    const base = `/${relative(root, join(launchDir, '.cadence')).split('\\').join('/')}/`;
+    const wanted = [`${base}runs/`, `${base}corrections.json`];
     const file = join(gitCommonDir(launchDir), 'info', 'exclude');
     mkdirSync(join(gitCommonDir(launchDir), 'info'), { recursive: true });
     const text = existsSync(file) ? readFileSync(file, 'utf8') : '';
-    if (text.split('\n').includes(pattern))
+    const lines = text.split('\n');
+    const missing = wanted.filter((w) => !lines.includes(w));
+    if (!lines.includes(base) && missing.length === 0)
         return;
-    appendFileSync(file, `${text === '' || text.endsWith('\n') ? '' : '\n'}${pattern}\n`);
+    const kept = lines.filter((l) => l !== base);
+    const body = kept.join('\n');
+    writeFileSync(file, `${body}${body === '' || body.endsWith('\n') ? '' : '\n'}${missing.map((m) => `${m}\n`).join('')}`);
 }