@sylad/cadence 0.6.0 → 0.8.0

package/dist/deliver.js

@@ -1,11 +1,16 @@
-import { execFileSync, spawnSync } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
+import { constants } from 'node:os';
 import { parse } from 'yaml';
+import { onTermination, SIGNAL_GRACE_MS, TreeTracker } from './proc.js';
+import { isPlanOnly } from './audit.js';
 import { headSha, isAncestor, onRemote, readCommits, repoStatus, resolveCommit } from './git.js';
+import { citedRefs } from './link.js';
 import { RafError } from './plan.js';
 import { appendDelivery, lastDelivery, lockAlive, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
 const POLL_CI = 15_000;
 const CI_APPEAR = 300_000;
-const POLL_VERIFY = 10_000;
+/** Intervalle de réessai d'une vérification : celui de deliver ET de `cadence verify --retry`. */
+export const POLL_VERIFY = 10_000;
 const CI_OK = new Set(['success', 'skipped', 'neutral']);
 const GH_TIMEOUT = 60_000;
 export const TIMED_OUT = 124;
@@ -106,18 +111,50 @@ export function realDeps(root) {
         }
     };
     return {
-        exec: (cmd, env, timeoutMs) => {
-            const r = spawnSync('sh', ['-c', cmd], {
+        exec: (cmd, env, timeoutMs) => new Promise((resolve) => {
+            const child = spawn('sh', ['-c', cmd], {
                 cwd: root,
                 env: { ...process.env, ...env },
                 stdio: ['ignore', 'inherit', 'inherit'],
-                timeout: Math.max(1_000, timeoutMs),
-                killSignal: 'SIGKILL',
+                // PAS de groupe détaché : la commande reste dans le groupe de premier plan et la session de cadence.
+                // Ctrl-C et le raccrochage l'atteignent avec cadence, et /dev/tty reste là pour ssh, sudo, pinentry.
             });
-            if (r.error?.code === 'ETIMEDOUT' || r.signal)
-                return TIMED_OUT;
-            return r.status ?? 1;
-        },
+            const pid = child.pid;
+            if (pid === undefined) {
+                child.once('error', () => resolve(127));
+                return;
+            }
+            // L'arbre de la commande est suivi pendant toute son exécution (relevé périodique, pid + heure de
+            // démarrage) : un enfant dont le parent meurt reste connu. Au délai, ou si cadence est tué (Ctrl-C,
+            // SIGTERM, raccrochage), TOUS les processus suivis encore vivants meurent avant que cadence ne rende la
+            // main ou ne meure — sh fait un fork par commande, et un descendant survivant livrerait encore pendant
+            // qu'une seconde livraison prend le verrou libéré ou périmé. Ctrl-C et raccrochage : l'arbre a déjà
+            // reçu le signal du terminal, un court délai de grâce laisse finir ses trap (et git son index.lock)
+            // avant le kill ; SIGTERM (à cadence seul) et le délai : kill immédiat.
+            const tree = new TreeTracker(pid);
+            // Terminaison en cours : exec ne rend pas la main avant qu'elle ne soit finie — sinon deliver libère
+            // le verrou pendant la grâce, alors que des descendants tournent encore.
+            let ending = null;
+            const forget = onTermination((sig) => (ending = sig === 'SIGTERM' ? Promise.resolve(tree.kill()) : tree.end(SIGNAL_GRACE_MS)));
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                tree.kill();
+            }, Math.max(1_000, timeoutMs));
+            child.once('exit', (code, signal) => {
+                clearTimeout(timer);
+                const result = timedOut ? TIMED_OUT : signal ? 128 + (constants.signals[signal] ?? 0) : (code ?? 1);
+                const settle = () => {
+                    tree.stop();
+                    forget();
+                    resolve(result);
+                };
+                if (ending)
+                    void ending.then(settle);
+                else
+                    settle();
+            });
+        }),
         gh: (sha) => JSON.parse(gh(['run', 'list', '--commit', sha, '--json', 'name,status,conclusion'])),
         ghReady: () => {
             try {
@@ -128,8 +165,8 @@ export function realDeps(root) {
                 return e.message;
             }
         },
-        fetch: async (url) => {
-            const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(20_000) });
+        fetch: async (url, timeoutMs = 20_000) => {
+            const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(Math.max(1_000, Math.min(20_000, timeoutMs))) });
             return { status: res.status, text: await res.text() };
         },
         sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
@@ -143,7 +180,7 @@ function substitute(text, sha) {
 function shellQuote(arg) {
     return /^[A-Za-z0-9_@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`;
 }
-function describeCheck(c, sha) {
+export function describeCheck(c, sha) {
     if (c.command !== undefined)
         return c.command;
     return `GET ${substitute(c.url, sha)} → ${c.status ?? 200}${c.contains === undefined ? '' : `, contient « ${substitute(c.contains, sha)} »`}`;
@@ -217,7 +254,7 @@ export async function deliver(ctx, deps) {
         out(`Livraison de ${env.CADENCE_SHORT} (${branch})`);
         if (script !== null) {
             out(`→ script du projet : ${script}`);
-            const code = deps.exec(script, env, config.deployTimeout * 1000);
+            const code = await deps.exec(script, env, config.deployTimeout * 1000);
             if (code !== 0)
                 return fail(`script de livraison en échec (${codeText(code)}) : ${script}`);
         }
@@ -227,7 +264,7 @@ export async function deliver(ctx, deps) {
                 return fail(ci);
             for (const [i, cmd] of config.deploy.entries()) {
                 out(`→ déploiement ${i + 1}/${config.deploy.length} : ${cmd}`);
-                const code = deps.exec(cmd, env, config.deployTimeout * 1000);
+                const code = await deps.exec(cmd, env, config.deployTimeout * 1000);
                 if (code !== 0)
                     return fail(`déploiement en échec (${codeText(code)}) : ${cmd}`);
             }
@@ -261,7 +298,7 @@ async function waitCi(ctx, deps, sha, env) {
         return null;
     if (typeof ci === 'object') {
         ctx.out(`→ CI : ${ci.command}`);
-        const code = deps.exec(ci.command, env, ciTimeout * 1000);
+        const code = await deps.exec(ci.command, env, ciTimeout * 1000);
         return code === 0 ? null : `CI en échec (${codeText(code)}) : ${ci.command}`;
     }
     ctx.out(`→ CI : attente des runs GitHub de ${sha.slice(0, 7)}`);
@@ -306,13 +343,14 @@ async function waitCi(ctx, deps, sha, env) {
         await deps.sleep(POLL_CI);
     }
 }
-async function tryCheck(c, deps, sha, env, budgetMs) {
+/** Un essai d'une vérification : cause de l'échec, ou null. Partagé par deliver et `cadence verify`. */
+export async function tryCheck(c, deps, sha, env, budgetMs) {
     if (c.command !== undefined) {
-        const code = deps.exec(c.command, env, budgetMs);
+        const code = await deps.exec(c.command, env, budgetMs);
         return code === 0 ? null : codeText(code);
     }
     try {
-        const res = await deps.fetch(substitute(c.url, sha));
+        const res = await deps.fetch(substitute(c.url, sha), budgetMs);
         const want = c.status ?? 200;
         if (res.status !== want)
             return `statut ${res.status} (attendu ${want})`;
@@ -324,36 +362,56 @@ async function tryCheck(c, deps, sha, env, budgetMs) {
         return `erreur réseau : ${e.message}`;
     }
 }
+/**
+ * UNE boucle de réessai, pour deliver et pour `cadence verify` : essaie, puis réessaie toutes les POLL_VERIFY
+ * tant que `until` n'est pas atteint. `attemptMs()` donne le délai de chaque essai. Rend la dernière cause
+ * d'échec, ou null dès que l'effet est celui attendu.
+ */
+export async function retryCheck(c, deps, sha, env, until, attemptMs) {
+    for (;;) {
+        const reason = await tryCheck(c, deps, sha, env, attemptMs());
+        if (reason === null)
+            return null;
+        const left = until - deps.now();
+        if (left <= 0)
+            return reason;
+        // jamais au-delà du délai : une commande tuée « à l'échéance » peut rendre la main un rien avant elle
+        await deps.sleep(Math.min(POLL_VERIFY, left));
+    }
+}
 /** Chaque vérification est réessayée jusqu'au délai commun ; message d'échec ou null. */
 async function verifyAll(ctx, deps, sha, env) {
     const deadline = deps.now() + ctx.config.verifyTimeout * 1000;
     for (const [i, c] of ctx.config.verify.entries()) {
         const label = describeCheck(c, sha);
         ctx.out(`→ vérification ${i + 1}/${ctx.config.verify.length} : ${label}`);
-        for (;;) {
-            const reason = await tryCheck(c, deps, sha, env, deadline - deps.now());
-            if (reason === null)
-                break;
-            const left = deadline - deps.now();
-            if (left <= 0)
-                return `vérification en échec après ${ctx.config.verifyTimeout} s : ${label} — ${reason}`;
-            // jamais au-delà du délai : une commande tuée « à l'échéance » peut rendre la main un rien avant elle
-            await deps.sleep(Math.min(POLL_VERIFY, left));
-        }
+        const reason = await retryCheck(c, deps, sha, env, deadline, () => deadline - deps.now());
+        if (reason !== null)
+            return `vérification en échec après ${ctx.config.verifyTimeout} s : ${label} — ${reason}`;
     }
     return null;
 }
-/** Ligne des lots cités depuis la livraison précédente, ou null (première livraison, rien de cité). */
+/**
+ * Ligne des lots cités depuis la livraison précédente, ou null (première livraison, rien de cité).
+ *
+ * Plan en lecture seule : seuls les lots EN COURS sont annoncés. Ses identifiants sont de forme libre, et
+ * un message cite volontiers un numéro qui en a la forme (réserve « R1 » d'une revue) ou un lot clos
+ * nommé pour le contexte — les annoncer « livrés » ferait fermer à tort. L'état est celui du départ de
+ * la livraison : le plan a été lu avant que le script du projet ne ferme lui-même les lots qu'il livre.
+ */
 function deliveredLots(ctx, prev, sha) {
     if (!ctx.plan || !prev || prev === sha)
         return null;
     if (!isAncestor(ctx.root, prev, sha)) {
         return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
     }
-    const known = new Set(ctx.plan.lots().map((l) => l.id));
+    const lots = ctx.plan.lots();
+    const known = new Set((ctx.plan.readonly ? lots.filter((l) => l.status === 'doing') : lots).map((l) => l.id));
     const ids = new Set();
     for (const c of readCommits(ctx.root, { range: `${prev}..${sha}` })) {
-        for (const r of ctx.plan.refs(`${c.subject}\n${c.body}`))
+        if (isPlanOnly(c.sha, ctx.plan, ctx.root))
+            continue; // entretien du plan : ne livre rien, même s'il cite des lots
+        for (const r of citedRefs(c, ctx.plan.refs))
             if (known.has(r.lot))
                 ids.add(r.lot);
     }

package/dist/git.js

@@ -45,9 +45,19 @@ export function hooksDir(cwd) {
     const dir = resolve(cwd, git(cwd, ['rev-parse', '--git-path', 'hooks']).trim());
     return basename(dir) === '_' && basename(dirname(dir)) === '.husky' ? dirname(dir) : dir;
 }
-/** Fichiers modifiés par un commit, relatifs à la racine du dépôt. */
+/** Fichiers modifiés par un commit, relatifs à la racine du dépôt (noms accentués ou à espaces compris). */
 export function changedFiles(cwd, sha) {
-    return git(cwd, ['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', sha]).split('\n').filter(Boolean);
+    // -z : noms séparés par NUL, jamais échappés ; quotepath=off en plus pour les sorties qui citeraient quand même.
+    return git(cwd, ['-c', 'core.quotepath=off', 'diff-tree', '--root', '--no-commit-id', '--name-only', '-r', '-z', sha]).split('\0').filter(Boolean);
+}
+/** Contenu d'un fichier à un commit (`<sha>^` pour l'état d'avant) ; null s'il n'existe pas à ce commit. */
+export function fileAt(cwd, rev, file) {
+    try {
+        return git(cwd, ['show', `${rev}:${file}`]);
+    }
+    catch {
+        return null;
+    }
 }
 function tryGit(cwd, args) {
     try {

package/dist/link.js

@@ -1,6 +1,20 @@
 export function isMerge(c) {
     return /^Merge\b/.test(c.subject);
 }
+/** Portée d'un sujet « type(L24,L25)! : … » ; null sans parenthèses. */
+function scopeOf(subject) {
+    return /^[\w-]+\(([^)]*)\)!?\s*:/.exec(subject)?.[1] ?? null;
+}
+/**
+ * Références qui décident à quels lots appartient un commit : celles de la portée « type(L24) » quand elle
+ * en cite ; sinon, celles du message entier. Les mentions en passage (« page équipe (L27) »), les plages
+ * (« L28–L31 ») et le corps du message ne comptent donc pas dès que la portée désigne les lots.
+ */
+export function citedRefs(c, refsOf) {
+    const scope = scopeOf(c.subject);
+    const scoped = scope === null ? [] : refsOf(scope);
+    return scoped.length > 0 ? scoped : refsOf(`${c.subject}\n${c.body}`);
+}
 /** `refs` lit les références d'un message : `plan.refs`. */
 export function linkCommits(lots, commits, refsOf) {
     const ids = new Set(lots.map((l) => l.id));
@@ -9,7 +23,7 @@ export function linkCommits(lots, commits, refsOf) {
     const orphans = [];
     const unknown = [];
     for (const c of commits) {
-        const refs = refsOf(`${c.subject}\n${c.body}`);
+        const refs = citedRefs(c, refsOf);
         if (refs.length === 0) {
             if (!isMerge(c))
                 orphans.push(c);

package/dist/news.js

@@ -16,8 +16,52 @@ function validStamp(s) {
     return (!Number.isNaN(Date.parse(s.replace(' ', 'T'))) && day.getUTCMonth() === mo - 1 && day.getUTCDate() === d && h < 24 && mi < 60 && sec < 60);
 }
 const list = (v) => (v == null ? [] : Array.isArray(v) ? v.map(String) : [String(v)]);
+const CAPTURE_KEYS = ['file', 'alt'];
+const CAPTURE_SHAPE = '{ file: chemin, alt: "texte alternatif" }';
+/**
+ * Captures de l'en-tête : un chemin, ou `{ file, alt }` quand l'entrée dit ce que l'image montre.
+ * Les chemins restent une liste de chaînes (ce que lit déjà le JSON publié), les textes les suivent un à un.
+ */
+function readCaptures(raw, problems) {
+    const captures = [];
+    const alts = [];
+    for (const [i, item] of (raw == null ? [] : Array.isArray(raw) ? raw : [raw]).entries()) {
+        let file;
+        let alt = '';
+        if (typeof item === 'string' || typeof item === 'number') {
+            file = String(item);
+        }
+        else if (item && typeof item === 'object' && !Array.isArray(item)) {
+            const map = item;
+            if (map.file == null || String(map.file).trim() === '') {
+                problems.push(`capture n° ${i + 1} : fichier absent — ${CAPTURE_SHAPE}`);
+                continue;
+            }
+            file = String(map.file);
+            // Une ligne : le texte part tel quel dans un attribut alt.
+            alt = map.alt == null ? '' : String(map.alt).replace(/\s+/g, ' ').trim();
+            for (const k of Object.keys(map)) {
+                if (!CAPTURE_KEYS.includes(k))
+                    problems.push(`capture ${file} : clé inconnue « ${k} » (attendu : ${CAPTURE_KEYS.join(', ')})`);
+            }
+        }
+        else {
+            problems.push(`capture n° ${i + 1} illisible : un chemin ou ${CAPTURE_SHAPE}`);
+            continue;
+        }
+        // Copiées telles quelles sous le dossier de build : un chemin qui sort du dossier écrirait ailleurs.
+        if (isAbsolute(file) || file.split(/[\\/]/).includes('..'))
+            problems.push(`capture hors du dossier des Nouveautés : ${file}`);
+        // Noms sages : utilisables tels quels dans une URL, et seulement des images.
+        else if (!CAPTURE.test(file))
+            problems.push(`capture ${file} : image .png, .jpg, .webp ou .gif, nom en lettres, chiffres, « . _ - / »`);
+        captures.push(file);
+        alts.push(alt);
+    }
+    return { captures, alts };
+}
 export function parseEntry(file, text) {
-    const entry = { file, slug: basename(file).replace(/\.md$/, ''), title: '', date: '', lots: [], captures: [], body: '', problems: [] };
+    const entry = { file, slug: basename(file).replace(/\.md$/, ''), title: '', date: '', lots: [], captures: [], alts: [], body: '', problems: [] };
     const m = FRONT.exec(text.replace(/^\uFEFF/, '')); // BOM des éditeurs Windows
     if (!m) {
         entry.problems.push('en-tête YAML absent (--- … ---)');
@@ -48,18 +92,10 @@ export function parseEntry(file, text) {
             entry.created = created.replace(' ', 'T');
     }
     entry.lots = list(head.lots);
-    entry.captures = list(head.captures);
     if (head.nocapture != null && String(head.nocapture).trim())
         entry.nocapture = String(head.nocapture).trim();
     entry.body = m[2].trim();
-    for (const c of entry.captures) {
-        // Copiées telles quelles sous le dossier de build : un chemin qui sort du dossier écrirait ailleurs.
-        if (isAbsolute(c) || c.split(/[\\/]/).includes('..'))
-            entry.problems.push(`capture hors du dossier des Nouveautés : ${c}`);
-        // Noms sages : utilisables tels quels dans une URL, et seulement des images.
-        else if (!CAPTURE.test(c))
-            entry.problems.push(`capture ${c} : image .png, .jpg, .webp ou .gif, nom en lettres, chiffres, « . _ - / »`);
-    }
+    Object.assign(entry, readCaptures(head.captures, entry.problems));
     if (!entry.title)
         entry.problems.push('title vide');
     if (!isDay(entry.date))
@@ -136,7 +172,7 @@ export function newEntry(dir, lots, rawTitle, today, now) {
     if (existsSync(path))
         throw new RafError(`${path} existe déjà`);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(path, `---\ntitle: ${stringify(title).trimEnd()}\ndate: ${today}\ncreated: ${toStamp(now)}\nlots: [${lots.join(', ')}]\ncaptures: []\n# nocapture: raison, quand une capture n'a pas de sens\n---\nCe qui change pour l'utilisateur.\n`);
+    writeFileSync(path, `---\ntitle: ${stringify(title).trimEnd()}\ndate: ${today}\ncreated: ${toStamp(now)}\nlots: [${lots.join(', ')}]\ncaptures: []\n# une capture peut dire ce qu'elle montre : captures: [${CAPTURE_SHAPE.replace('chemin', 'captures/x.png')}]\n# nocapture: raison, quand une capture n'a pas de sens\n---\nCe qui change pour l'utilisateur.\n`);
     return path;
 }
 /**
@@ -210,7 +246,16 @@ export function newsData(project, entries, generated) {
     return {
         project,
         generated,
-        entries: entries.map((e) => ({ slug: e.slug, title: e.title, date: e.date, lots: e.lots, captures: e.captures, html: renderMarkdown(e.body) })),
+        entries: entries.map((e) => ({
+            slug: e.slug,
+            title: e.title,
+            date: e.date,
+            lots: e.lots,
+            captures: e.captures,
+            // Clé ajoutée seulement quand elle dit quelque chose : une entrée sans texte garde sa forme d'avant.
+            ...(e.alts.some(Boolean) ? { alts: e.alts } : {}),
+            html: renderMarkdown(e.body),
+        })),
     };
 }
 /** Écrit nouveautes.json, index.html et copie les captures sous `out`. */
@@ -237,7 +282,7 @@ function renderNewsPage(data) {
   <h2>${escapeText(e.title)}</h2>
   <p class="meta"><time datetime="${e.date}">${e.date}</time> · ${e.lots.map(escapeText).join(', ')}</p>
   ${e.html}
-  ${e.captures.map((c) => `<a href="${escapeText(c)}"><img src="${escapeText(c)}" alt="Capture : ${escapeText(e.title)}" loading="lazy"></a>`).join('\n  ')}
+  ${e.captures.map((c, i) => `<a href="${escapeText(c)}"><img src="${escapeText(c)}" alt="${escapeText(e.alts?.[i] || `Capture : ${e.title}`)}" loading="lazy"></a>`).join('\n  ')}
 </article>`)
         .join('\n');
     return `<!doctype html>

package/dist/plan.js

@@ -12,9 +12,15 @@ export function isOpen(status) {
 function escapeRe(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Ce qui ne peut pas suivre un identifiant cité : un point suivi d'un caractère de mot — « L1.4 » n'est
+ * pas le lot L1, « NC2.4 » n'est pas NC2 — alors que le point qui finit une phrase (« voir L1. ») passe.
+ * Même garde pour le format de raf et pour les identifiants d'un plan en lecture seule.
+ */
+const DOTTED = '\\.\\w';
 /** Matches `L3` or `L3/t1` as whole words. Group 1 = lot id, group 2 = task id. */
 export function refPattern(prefix) {
-    return new RegExp(`(?<![\\w/])(${escapeRe(prefix)}\\d+)(?:/(t\\d+))?(?![\\w])`, 'g');
+    return new RegExp(`(?<![\\w/])(${escapeRe(prefix)}\\d+)(?:/(t\\d+))?(?!\\w|${DOTTED})`, 'g');
 }
 export function extractRefs(text, prefix) {
     return [...text.matchAll(refPattern(prefix))].map((m) => ({ lot: m[1], task: m[2] }));
@@ -116,6 +122,10 @@ export class Plan {
         }
         return { patterns, invalid };
     }
+    /** Fichier de configuration lu pour ce plan, null quand on n'en connaît pas (cadence.yaml à la racine alors). */
+    get configFile() {
+        return this.settings.config ?? null;
+    }
     /** Fichiers tenus avec le plan, relatifs à la racine du dépôt. */
     get files() {
         return this.settings.files ?? [];
@@ -149,7 +159,7 @@ export class Plan {
                 ids: new Set(ids),
                 tasks: new Set(lots.flatMap((l) => l.tasks.map((t) => `${l.id}/${t.id}`))),
                 refs: ids.length
-                    ? new RegExp(`(?<![\\w/.-])(${ids.map(escapeRe).join('|')})(?:/([\\w-]+(?:\\.[\\w-]+)*))?(?![\\w-]|\\.\\w)`, 'g')
+                    ? new RegExp(`(?<![\\w/.-])(${ids.map(escapeRe).join('|')})(?:/([\\w-]+(?:\\.[\\w-]+)*))?(?![\\w-]|${DOTTED})`, 'g')
                     : null,
             };
         }
@@ -431,7 +441,11 @@ function asVerdict(raw) {
     if (!raw || typeof raw !== 'object')
         return undefined;
     const v = raw;
-    const verdict = { date: String(v.date ?? ''), verdict: String(v.verdict ?? '') };
+    // Écrit à la main sans verdict (clé absente, vide ou blanche) : rien n'a été dit de la revue, la porte
+    // reste fermée — comme `raf ux` et `raf review` refusent d'enregistrer un verdict vide.
+    if (String(v.verdict ?? '').trim() === '')
+        return undefined;
+    const verdict = { date: String(v.date ?? ''), verdict: String(v.verdict) };
     // Champ présent mais vide : relu « jusqu'à rien », comme un verdict noté sans commit.
     if ('commit' in v)
         verdict.commit = v.commit == null || String(v.commit).trim() === '' ? null : String(v.commit).trim();

package/dist/proc.js

@@ -0,0 +1,161 @@
+import { execFileSync } from 'node:child_process';
+import { readdirSync, readFileSync } from 'node:fs';
+/**
+ * Signaux qui terminent cadence pendant qu'une commande tourne : chaque commande en cours inscrit son
+ * nettoyage, cadence l'exécute avant de sortir — tué par le même signal, comme sans nettoyage.
+ */
+const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+const cleanups = new Set();
+let dying = false;
+/**
+ * Délai de grâce après Ctrl-C ou raccrochage : l'arbre de la commande a déjà reçu le signal du terminal,
+ * ses `trap` et le nettoyage de git (index.lock) ont ce temps pour finir avant le kill.
+ */
+export const SIGNAL_GRACE_MS = 2_000;
+async function onSignal(sig) {
+    if (dying)
+        return; // un second signal pendant le nettoyage n'interrompt rien
+    dying = true;
+    await Promise.all([...cleanups].map((f) => f(sig)));
+    cleanups.clear();
+    for (const s of SIGNALS)
+        process.removeListener(s, onSignal);
+    process.kill(process.pid, sig);
+}
+/**
+ * Inscrit un nettoyage à faire si cadence reçoit Ctrl-C, SIGTERM ou le raccrochage ; rend son retrait.
+ * Le nettoyage peut être asynchrone : cadence l'attend avant de mourir du signal.
+ */
+export function onTermination(cleanup) {
+    if (cleanups.size === 0)
+        for (const s of SIGNALS)
+            process.on(s, onSignal);
+    cleanups.add(cleanup);
+    return () => {
+        if (dying || !cleanups.delete(cleanup))
+            return;
+        if (cleanups.size === 0)
+            for (const s of SIGNALS)
+                process.removeListener(s, onSignal);
+    };
+}
+function signal(pid, sig) {
+    try {
+        process.kill(pid, sig);
+        return true;
+    }
+    catch {
+        return false; // déjà mort
+    }
+}
+/** Tous les processus visibles : /proc sous Linux (starttime, champ 22 de stat), `ps` ailleurs (lstart). */
+function readProcs() {
+    const procs = new Map();
+    let names = null;
+    try {
+        names = readdirSync('/proc').filter((n) => /^\d+$/.test(n));
+    }
+    catch {
+        // pas de /proc (macOS) : ps
+    }
+    if (names) {
+        for (const n of names) {
+            try {
+                const stat = readFileSync(`/proc/${n}/stat`, 'utf8');
+                // « pid (comm) état ppid … starttime … » — comm peut contenir espaces et parenthèses
+                const f = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+                procs.set(Number(n), { ppid: Number(f[1]), start: f[19], zombie: f[0] === 'Z' });
+            }
+            catch {
+                // sorti entre-temps
+            }
+        }
+    }
+    else {
+        for (const line of execFileSync('ps', ['-A', '-o', 'pid=,ppid=,stat=,lstart='], { encoding: 'utf8' }).trim().split('\n')) {
+            const [pid, ppid, stat, ...lstart] = line.trim().split(/\s+/);
+            procs.set(Number(pid), { ppid: Number(ppid), start: lstart.join(' '), zombie: stat.startsWith('Z') });
+        }
+    }
+    return procs;
+}
+/** Intervalle du relevé des descendants d'une commande de deliver pendant qu'elle tourne. */
+export const TRACK_INTERVAL_MS = 200;
+/**
+ * Suivi continu de l'arbre d'une commande : toutes les TRACK_INTERVAL_MS, ses descendants sont relevés et
+ * chacun est retenu avec son heure de démarrage. Un processus vu une fois reste suivi même si son parent
+ * meurt (rattaché à init, il n'est plus sous la racine) — ses propres enfants aussi. Un pid suivi n'est
+ * signalé que si son heure de démarrage est toujours la même : jamais un pid réutilisé par un autre.
+ * Échappe seulement ce qui quitte l'arbre entre deux relevés (fork puis mort du parent en moins d'un
+ * intervalle) et ce que cadence n'a pas le droit de tuer (sudo).
+ */
+export class TreeTracker {
+    known = new Map();
+    timer;
+    constructor(root) {
+        const info = readProcs().get(root);
+        if (info)
+            this.known.set(root, info.start);
+        this.timer = setInterval(() => this.scan(), TRACK_INTERVAL_MS);
+        this.timer.unref();
+    }
+    /** Arrête le relevé périodique (la commande est finie, ou son arbre est tué). */
+    stop() {
+        clearInterval(this.timer);
+    }
+    /** Relève les nouveaux descendants des processus suivis encore vivants ; rend le relevé. */
+    scan(procs = readProcs()) {
+        for (let grew = true; grew;) {
+            grew = false;
+            for (const [pid, info] of procs) {
+                if (this.known.has(pid) || !this.isTracked(info.ppid, procs))
+                    continue;
+                this.known.set(pid, info.start);
+                grew = true;
+            }
+        }
+        return procs;
+    }
+    /** Processus suivis encore vivants (même heure de démarrage, pas zombies). */
+    alive(procs = this.scan()) {
+        return [...this.known.keys()].filter((pid) => this.isTracked(pid, procs) && !procs.get(pid).zombie);
+    }
+    isTracked(pid, procs) {
+        const start = this.known.get(pid);
+        return start !== undefined && procs.get(pid)?.start === start;
+    }
+    /**
+     * Tue tous les processus suivis encore vivants et TOUS leurs descendants actuels, sans en laisser filer un :
+     * chacun est d'abord arrêté (SIGSTOP) — plus aucun fork, et plus aucun enfant rattaché à init par la mort
+     * de son parent —, l'arbre est relu jusqu'à ce qu'il ne s'y ajoute plus rien, puis tout est tué (SIGKILL).
+     */
+    kill() {
+        this.stop();
+        const seen = new Set([process.pid]);
+        const stopped = [];
+        for (let fresh = this.alive(); fresh.length > 0;) {
+            for (const pid of fresh) {
+                seen.add(pid); // essayé une fois : mort entre-temps ou hors d'atteinte (sudo), il ne revient pas
+                if (signal(pid, 'SIGSTOP'))
+                    stopped.push(pid);
+            }
+            const procs = this.scan();
+            fresh = this.alive(procs).filter((pid) => !seen.has(pid));
+        }
+        for (const pid of stopped)
+            signal(pid, 'SIGKILL');
+    }
+    /**
+     * Laisse à l'ensemble suivi jusqu'à `graceMs` pour finir de lui-même (il a déjà reçu le signal du terminal),
+     * puis tue ce qui reste. Rend la main dès que plus aucun processus suivi n'est vivant.
+     */
+    async end(graceMs) {
+        this.stop();
+        const deadline = Date.now() + graceMs;
+        while (this.alive().length > 0) {
+            if (Date.now() >= deadline)
+                return this.kill();
+            await new Promise((r) => setTimeout(r, 50));
+        }
+    }
+}

package/dist/session.js

@@ -107,6 +107,7 @@ export function sessionStart(ctx, opts) {
     section(out, `Fait depuis ${opts.since}`, done);
     section(out, 'Écarts (raf check)', audit(plan, ctx.root, ctx.newsDir, today).map((i) => `✗ ${i.message}`));
     section(out, 'Dépôt', [repoLine(ctx.root).line]);
+    section(out, 'Effets en production (cadence verify)', ctx.effects ?? []);
     section(out, 'Faits propres au projet', projectFacts(ctx, opts.since));
     const proposals = [
         ...doing.map((l) => ({ l, why: 'en cours' })),

package/dist/state.js

@@ -21,14 +21,17 @@ export function readNext(dir) {
     const lines = rest.map((l) => l.replace(/^- /, '')).filter(Boolean);
     return { date: head.replace(/^# /, '').trim(), lines };
 }
-/** Remplace les notes pour la prochaine session ; sans ligne, les efface. */
+/** Remplace les notes pour la prochaine session. Ne les efface jamais : c'est `clearNext`, demandé exprès. */
 export function writeNext(dir, date, lines) {
-    const file = join(dir, 'next.md');
-    if (lines.length === 0) {
-        rmSync(file, { force: true });
-        return;
-    }
-    writeFileSync(file, `# ${date}\n${lines.map((l) => `- ${l.replace(/\n/g, ' ')}`).join('\n')}\n`);
+    if (lines.length === 0)
+        throw new Error('writeNext : aucune ligne');
+    writeFileSync(join(dir, 'next.md'), `# ${date}\n${lines.map((l) => `- ${l.replace(/\n/g, ' ')}`).join('\n')}\n`);
+}
+/** Efface les notes pour la prochaine session ; rend celles qui s'y trouvaient, null s'il n'y en avait pas. */
+export function clearNext(dir) {
+    const previous = readNext(dir);
+    rmSync(join(dir, 'next.md'), { force: true });
+    return previous;
 }
 export function lockPath(dir) {
     return join(dir, 'deliver.lock');