@sylad/cadence 1.7.0 → 1.9.0

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,10 @@
-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). */
+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 +16,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) {
@@ -80,6 +86,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 +159,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('')}`);
 }

package/dist/orchestrate/table.js

@@ -1,10 +1,11 @@
 import { lotWork } from '../audit.js';
 import { planLoader } from '../config.js';
-import { isAncestor } from '../git.js';
+import { gitRoot, isAncestor } from '../git.js';
+import { repoWork } from '../repos.js';
 import { quotaReset } from './result.js';
 const k = (n) => `${Math.round(n / 1000)} k`;
 const m = (n) => `${(n / 1_000_000).toFixed(1).replace('.', ',')} M`;
-const LABEL = {
+export const LABEL = {
     queued: 'en attente',
     implementing: 'implémentation',
     reviewing: 'revue',
@@ -93,6 +94,62 @@ function deliverable(lots, ancestor, fromGit) {
     }
     return out;
 }
+/**
+ * Sha abrégés des commits de `l` dans `repo` que git lui attribue — dans le dépôt de son projet (commits qui citent le lot) ou, quand `repo` est
+ * l'un de ses dépôts voisins (clé `repos:`, L62), dans ce voisin (`repoWork` : commits qui citent le lot, dans sa période, et sa chaîne `cite:`).
+ * Contrairement à `gitCommitsOf`, une lecture impossible LÈVE : plan du projet illisible ou qui ne connaît pas le lot, dépôt qui n'est plus un dépôt
+ * git. « Aucun commit » et « commits illisibles » ne se confondent pas ici : la garde de `deliver --sha` refuse le second.
+ */
+export function gitCommitsIn(l, repo) {
+    const plan = planLoader(l.repo)();
+    if (!plan.lots().some((x) => x.id === l.lot))
+        throw new Error(`le plan de ${l.repo} ne connaît pas le lot ${l.lot}`);
+    const neighbour = l.repo === repo ? undefined : (l.repos ?? []).find((r) => r.path === repo);
+    const where = neighbour ? neighbour.path : l.repo;
+    if (!gitRoot(where))
+        throw new Error(`${where} n'est pas un dépôt git`);
+    const work = neighbour ? repoWork(plan, neighbour, l.lot) : lotWork(plan, l.repo, l.lot);
+    return work.map((c) => c.sha.slice(0, 7)).reverse();
+}
+/** Sha des commits que les étapes de `l` ont notés dans `repo` : entrées `<sha> <sujet>` pour son dépôt, `[rel] <sha> <sujet>` pour un voisin. */
+function stepCommits(l, repo) {
+    const entries = l.steps.flatMap((s) => s.commits ?? []);
+    const prefixes = l.repo === repo ? [] : (l.repos ?? []).filter((r) => r.path === repo).map((r) => `[${r.rel}] `);
+    if (prefixes.length === 0)
+        return entries.filter((c) => !c.startsWith('[')).map((c) => c.split(' ')[0]);
+    return entries.flatMap((c) => prefixes.filter((p) => c.startsWith(p)).map((p) => c.slice(p.length).split(' ')[0]));
+}
+/**
+ * Livrer au fil de l'eau (L277) : les lots de la vague qui empêchent de livrer `sha` dans `repo` — ceux qui ne sont pas prêts (en cours, en file,
+ * en question, suspendus, rendus, échoués) et dont un commit est dans l'histoire de `sha`. `blocking` vide ET `unreadable` vide : tous les commits de
+ * `sha` qui citent un lot de la vague citent des lots prêts, revus (« prêt » est l'état d'un lot dont la revue est conforme) ; `sha` est
+ * « livrable jusqu'à » de la vague. Un lot sans commit ne bloque rien.
+ *
+ * Les commits d'un lot pas prêt sont l'union de ce que git lui attribue (`read`) et de ce que ses étapes ont noté : les entrées d'étape ne sont
+ * écrites qu'à la fin d'une session au rapport valide, git voit tout de suite le commit d'une session en cours, coupée par le quota ou échouée,
+ * dans son dépôt comme dans un voisin. Un lot dont les commits n'ont pu être lus (`read` lève) et dont aucun commit déjà connu ne bloque est
+ * `unreadable` : on ne laisse passer que ce qu'on a pu vérifier.
+ */
+export function blockingLots(lots, repo, sha, ancestor = isAncestor, read = gitCommitsIn) {
+    const guard = { blocking: [], unreadable: [] };
+    for (const l of lots) {
+        if (l.status === 'ready')
+            continue;
+        let found = [];
+        let readable = true;
+        try {
+            found = read(l, repo);
+        }
+        catch {
+            readable = false;
+        }
+        if ([...found, ...stepCommits(l, repo)].some((c) => ancestor(repo, c, sha)))
+            guard.blocking.push(l);
+        else if (!readable)
+            guard.unreadable.push(l);
+    }
+    return guard;
+}
 /** Tests déjà rouges au départ listés un par un dans le tableau ; au-delà, un compte. */
 const BASELINE_LISTED = 30;
 /** Le tableau de fin de vague (ou de `--status`), une ligne par lot puis le total et les questions. */
@@ -117,6 +174,8 @@ export function renderTable(wave, lots, deps = {}) {
         out.push(`${d.ready.project}:${d.ready.lot} — livrable jusqu'à ${d.sha} (dernier commit de ${d.ready.lot}, sous ${d.under.lot} ${d.under.status === 'handed-back' || d.under.status === 'failed' ? 'rendu' : LABEL[d.under.status]}) : git push origin ${d.sha}:main && cadence deliver --sha ${d.sha}`);
     }
     for (const l of lots) {
+        if (l.goal)
+            out.push(`${l.project}:${l.lot} — objectif donné : ${l.goal}`);
         if (l.uxNote)
             out.push(`${l.project}:${l.lot} — ${l.uxNote}`);
         if (l.uxCaptures)

package/dist/orchestrate/timeouts.js

@@ -0,0 +1,40 @@
+/** Estimate (en jours) que le délai de base `timeouts.work` couvre : un lot jusqu'à un quart de jour. */
+export const BASE_ESTIMATE = 0.25;
+/** Majoration d'un lot à fiche (étape spec, écran ou `spec: true`) : la session lit la fiche et écrit un test par règle. */
+export const FICHE_FACTOR = 1.5;
+/** Plafond du délai proportionné, en multiples du délai de base. */
+export const MAX_FACTOR = 4;
+/** Prolongation accordée à chaque échéance où la session a commité depuis la dernière. */
+export const EXTENSION_MS = 15 * 60_000;
+/** Nombre de prolongations au plus : 2 h de plus après le délai proportionné, la session qui commite sans fin finit par être coupée. */
+export const MAX_EXTENSIONS = 8;
+/**
+ * Délai d'une étape d'écriture (L298) : le délai configuré (`timeouts.implement`, 45 min par défaut) vaut pour un lot de 0,25 j ;
+ * il croît avec l'estimate (0,5 j : le double), d'un tiers en plus de moitié pour un lot à fiche, sans dépasser 4 fois le délai de base.
+ */
+export function workTimeoutMs(baseMs, estimate, fiche) {
+    const scale = Math.max(1, (estimate ?? BASE_ESTIMATE) / BASE_ESTIMATE) * (fiche ? FICHE_FACTOR : 1);
+    return Math.round(Math.min(scale, MAX_FACTOR) * baseMs);
+}
+const isTest = (f) => /(^|\/)(tests?|__tests__)\//.test(f) || /\.(test|spec)\.[a-z]+$/.test(f);
+/** Fichiers listés au plus dans le message : au-delà, le nombre seul. */
+const LISTED = 8;
+/**
+ * Phrase du tableau pour une étape d'écriture coupée à l'échéance (L298) : commits conservés, travail NON commité
+ * (fichiers, dont les tests, lignes). `numstat` : sortie de `git diff --numstat HEAD` ; les fichiers non suivis n'y ont pas de lignes.
+ */
+export function cutReport(o) {
+    const lines = o.numstat
+        .split('\n')
+        .map((l) => l.split('\t'))
+        .filter((p) => p.length >= 3)
+        .reduce((n, p) => n + (Number(p[0]) || 0), 0);
+    const kept = o.commits === 0 ? 'aucun commit' : `${o.commits} commit${o.commits > 1 ? 's' : ''} conservé${o.commits > 1 ? 's' : ''}`;
+    const head = `coupé au délai de ${o.minutes} min : ${kept}`;
+    if (o.files.length === 0)
+        return `${head}, rien de non commité`;
+    const tests = o.files.filter(isTest);
+    const names = o.files.length > LISTED ? `${o.files.slice(0, LISTED).join(', ')}, …` : o.files.join(', ');
+    const t = tests.length ? `, dont ${tests.length} de test (${tests.length > LISTED ? `${tests.slice(0, LISTED).join(', ')}, …` : tests.join(', ')})` : ', aucun de test';
+    return `${head} ; travail NON commité : ${o.files.length} fichier${o.files.length > 1 ? 's' : ''} (${names})${t}${lines ? `, ${lines} lignes ajoutées` : ''} — laissé dans le dépôt, à commiter ou à reprendre par le lead`;
+}