@sylad/cadence 0.7.0 → 0.9.0

package/dist/orchestrate/state.js

@@ -0,0 +1,93 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { gitCommonDir, gitRoot } from '../git.js';
+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 };
+}
+export const lotKey = (project, lot) => `${project}:${lot}`;
+const lotFile = (project, lot) => `${project}--${lot}.json`;
+function atomicWrite(file, data) {
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`);
+    renameSync(tmp, file);
+}
+/** `.cadence/runs/<vague>/` du dossier de lancement. */
+export class RunStore {
+    launchDir;
+    id;
+    dir;
+    constructor(launchDir, id) {
+        this.launchDir = launchDir;
+        this.id = id;
+        this.dir = join(launchDir, '.cadence', 'runs', id);
+        mkdirSync(this.dir, { recursive: true });
+    }
+    static runsDir(launchDir) {
+        return join(launchDir, '.cadence', 'runs');
+    }
+    /** La dernière vague (par identifiant) ; avec `unfinished`, la dernière qui n'est pas terminée. */
+    static last(launchDir, opts = {}) {
+        const base = RunStore.runsDir(launchDir);
+        if (!existsSync(base))
+            return null;
+        const ids = readdirSync(base).filter((n) => existsSync(join(base, n, 'wave.json'))).sort().reverse();
+        for (const id of ids) {
+            const store = new RunStore(launchDir, id);
+            if (!opts.unfinished || store.readWave()?.status !== 'done')
+                return store;
+        }
+        return null;
+    }
+    static find(launchDir, id) {
+        return existsSync(join(RunStore.runsDir(launchDir), id, 'wave.json')) ? new RunStore(launchDir, id) : null;
+    }
+    lotDir(project, lot) {
+        const d = join(this.dir, `${project}--${lot}`);
+        mkdirSync(d, { recursive: true });
+        return d;
+    }
+    writeWave(w) {
+        atomicWrite(join(this.dir, 'wave.json'), w);
+    }
+    readWave() {
+        const f = join(this.dir, 'wave.json');
+        return existsSync(f) ? JSON.parse(readFileSync(f, 'utf8')) : null;
+    }
+    writeLot(l) {
+        atomicWrite(join(this.dir, lotFile(l.project, l.lot)), l);
+    }
+    readLot(project, lot) {
+        const f = join(this.dir, lotFile(project, lot));
+        return existsSync(f) ? JSON.parse(readFileSync(f, 'utf8')) : null;
+    }
+    /** Les lots de la vague, dans l'ordre donné au lancement (`wave.lots`) : une reprise rejoue les dépendances avant les dépendants. */
+    lots() {
+        const all = readdirSync(this.dir)
+            .filter((n) => n.endsWith('.json') && n !== 'wave.json')
+            .sort()
+            .map((n) => JSON.parse(readFileSync(join(this.dir, n), 'utf8')));
+        const order = this.readWave()?.lots ?? [];
+        const rank = (l) => {
+            const i = order.indexOf(lotKey(l.project, l.lot));
+            return i < 0 ? order.length : i;
+        };
+        return all.map((l, i) => ({ l, i })).sort((a, b) => rank(a.l) - rank(b.l) || a.i - b.i).map((x) => x.l);
+    }
+    journal(line) {
+        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. */
+export function excludeState(launchDir) {
+    const root = gitRoot(launchDir);
+    if (!root)
+        return;
+    const rel = relative(root, join(launchDir, '.cadence')).split('\\').join('/');
+    const pattern = `/${rel}/`;
+    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))
+        return;
+    appendFileSync(file, `${text === '' || text.endsWith('\n') ? '' : '\n'}${pattern}\n`);
+}

package/dist/orchestrate/table.js

@@ -0,0 +1,73 @@
+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 = {
+    queued: 'en attente',
+    implementing: 'implémentation',
+    reviewing: 'revue',
+    fixing: 'correction',
+    question: 'question',
+    ready: 'prêt à livrer',
+    'handed-back': 'rendu au lead',
+    failed: 'échec',
+    suspended: 'suspendu',
+};
+function review(l) {
+    if (!l.code)
+        return '—';
+    const fixes = l.pass === 0 ? '' : ` après ${l.pass} correction${l.pass > 1 ? 's' : ''}`;
+    if (l.status === 'ready')
+        return `conforme${fixes}`;
+    return `non conforme (${l.code.bloquants} bloquant, ${l.code.majeurs} majeur)`;
+}
+function ux(l) {
+    if (!l.visible)
+        return '—';
+    if (l.ux)
+        return l.ux.conforme ? 'conforme (à enregistrer par le lead)' : `non conforme (${l.ux.bloquants + l.ux.majeurs})`;
+    return 'à faire par le lead';
+}
+const commits = (l) => new Set(l.steps.flatMap((s) => s.commits ?? [])).size;
+const counted = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
+const minutes = (l) => Math.round(l.steps.reduce((n, s) => n + (s.ended ? Date.parse(s.ended) - Date.parse(s.started) : 0), 0) / 60_000);
+/** Le tableau de fin de vague (ou de `--status`), une ligne par lot puis le total et les questions. */
+export function renderTable(wave, lots) {
+    const rows = lots.map((l) => [`${l.project}:${l.lot}`, LABEL[l.status], String(l.pass), review(l), ux(l), String(commits(l)), k(counted(l)), `${minutes(l)} min`]);
+    const head = ['lot', 'état', 'passes', 'revue', 'UX', 'commits', 'tokens', 'durée'];
+    const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+    const line = (r) => r.map((c, i) => c.padEnd(widths[i])).join('  ').trimEnd();
+    const out = [line(head), ...rows.map(line)];
+    const by = (s) => lots.filter((l) => l.status === s).length;
+    const tail = [`${by('ready')} prêt(s)`, by('question') ? `${by('question')} question(s)` : '', by('handed-back') + by('failed') ? `${by('handed-back') + by('failed')} rendu(s) au lead` : '', by('suspended') ? `${by('suspended')} suspendu(s)` : ''].filter(Boolean);
+    out.push(`vague ${wave.id} : ${k(wave.consumed)} / ${m(wave.budget)} comptés (lecture de cache ${m(wave.cacheRead)}) — ${tail.join(', ')} — ${wave.status}`);
+    for (const l of lots.filter((x) => x.status === 'question')) {
+        out.push(`question : ${l.project}:${l.lot} — « ${l.questions.join(' / ')} » (cadence orchestrate --resume --answer ${l.project}:${l.lot} "…")`);
+    }
+    for (const l of lots.filter((x) => x.status === 'handed-back' || x.status === 'failed' || x.status === 'suspended')) {
+        out.push(`${l.project}:${l.lot} — ${l.outcome ?? LABEL[l.status]}`);
+        for (const c of l.status === 'handed-back' ? l.constats : [])
+            out.push(`    · [${c.gravite}] ${c.fichier ? `${c.fichier}${c.ligne ? `:${c.ligne}` : ''} — ` : ''}${c.texte.split('\n')[0]}`);
+    }
+    for (const l of lots) {
+        if (l.uxNote)
+            out.push(`${l.project}:${l.lot} — ${l.uxNote}`);
+        for (const w of l.warnings)
+            out.push(`${l.project}:${l.lot} — ⚠ ${w}`);
+        for (const x of l.choix ?? [])
+            out.push(`${l.project}:${l.lot} — choix fait : ${x}`);
+        for (const p of l.proposals)
+            out.push(`${l.project}:${l.lot} — proposé : ${p}`);
+        if (l.uxVerdict && l.visible)
+            out.push(`${l.project}:${l.lot} — verdict UX pour « raf ux » : ${l.uxVerdict}`);
+    }
+    return out;
+}
+const two = (n) => String(n).padStart(2, '0');
+/** Le message de quota lisible : sans l'horodatage brut après « | », avec l'heure de remise locale quand il la donne. */
+export function quotaText(message) {
+    const reset = quotaReset(message);
+    const text = message.trim().replace(/\|\d{9,}\s*$/, '').trim();
+    if (!reset)
+        return text;
+    return `${text} — remise le ${reset.getFullYear()}-${two(reset.getMonth() + 1)}-${two(reset.getDate())} à ${two(reset.getHours())}:${two(reset.getMinutes())}`;
+}

package/dist/plan.js

@@ -5,7 +5,7 @@ import { isDay, toDay } from './dates.js';
 export const STATUSES = ['todo', 'doing', 'done', 'dropped'];
 export class RafError extends Error {
 }
-export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'after', 'created', 'started', 'finished', 'notes', 'parent'];
+export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'parent'];
 export function isOpen(status) {
     return status === 'todo' || status === 'doing';
 }
@@ -122,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 ?? [];
@@ -245,11 +249,20 @@ export class Plan {
         const re = new RegExp(`^${escapeRe(this.prefix)}(\\d+)$`);
         const max = Math.max(0, ...[...known].map((id) => Number(re.exec(id)?.[1] ?? 0)));
         const id = `${this.prefix}${max + 1}`;
-        const entry = { id, title, status: 'todo', estimate: opts.estimate ?? 1 };
+        const pub = opts.public === undefined ? undefined : cleanPublic(opts.public);
+        if (opts.every !== undefined && !(Number.isInteger(opts.every) && opts.every > 0)) {
+            throw new RafError(`périodicité invalide : ${opts.every} (un nombre entier de jours, 1 au moins)`);
+        }
+        const entry = { id, title };
+        if (pub !== undefined)
+            entry.public = pub;
+        Object.assign(entry, { status: 'todo', estimate: opts.estimate ?? 1 });
         if (opts.quickwin)
             entry.quickwin = true;
         if (opts.visible)
             entry.visible = true;
+        if (opts.every !== undefined)
+            entry.every = opts.every;
         if (opts.after?.length)
             entry.after = opts.after;
         entry.created = today;
@@ -318,6 +331,38 @@ export class Plan {
         if (status === 'done' || status === 'dropped')
             node.set('finished', today);
     }
+    /** Pose, remplace (texte) ou efface (null) le titre public d'un lot ; la clé suit `title`. */
+    setPublic(ref, text) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`le titre public se pose sur un lot, pas une sous-tâche : ${ref}`);
+        const node = this.lotNode(ref);
+        if (text === null) {
+            node.delete('public');
+            return;
+        }
+        const value = cleanPublic(text);
+        if (node.has('public')) {
+            node.set('public', value);
+            return;
+        }
+        const at = node.items.findIndex((p) => String(p.key?.value ?? p.key) === 'title');
+        node.items.splice(at + 1, 0, this.doc.createPair('public', value));
+    }
+    /** Un lot récurrent a été refait : `last` passe à aujourd'hui, avec une note si `text` est donné. */
+    did(ref, today, text) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`la périodicité se pose sur un lot, pas une sous-tâche : ${ref}`);
+        const lot = this.lot(ref);
+        if (lot.every === undefined)
+            throw new RafError(`${ref} n'est pas récurrent — raf add --every <jours> pour en créer un`);
+        if (!isOpen(lot.status))
+            throw new RafError(`${ref} est ${lot.status}`);
+        this.lotNode(ref).set('last', today);
+        if (text?.trim())
+            this.note(ref, text.trim(), today);
+    }
     note(ref, text, today) {
         this.writable();
         const [lotId, taskId] = ref.split('/');
@@ -372,6 +417,9 @@ function foreignLots(raw, format) {
             estimate: typeof effort === 'string' ? format.estimates[effort] : effort,
             quickwin: pick('quickwin'),
             visible: pick('visible'),
+            public: pick('public'),
+            every: pick('every'),
+            last: day('last'),
             after: pick('after'),
             created: day('created'),
             started: day('started'),
@@ -395,6 +443,13 @@ function foreignLots(raw, format) {
     }
     return lots;
 }
+/** Un titre public vide ne dirait rien au public : refusé plutôt qu'écrit. */
+function cleanPublic(text) {
+    const t = text.trim();
+    if (t === '')
+        throw new RafError('titre public vide — raf public <id> "titre" (ou --clear pour l\'effacer)');
+    return t;
+}
 function normalizeLot(raw, problems = []) {
     const status = STATUSES.includes(raw.status) ? raw.status : 'todo';
     const asDay = (field) => {
@@ -407,6 +462,7 @@ function normalizeLot(raw, problems = []) {
         return undefined;
     };
     const after = raw.after == null ? [] : Array.isArray(raw.after) ? raw.after.map(String) : [String(raw.after)];
+    const last = asDay('last');
     return {
         id: String(raw.id),
         title: String(raw.title ?? ''),
@@ -414,6 +470,9 @@ function normalizeLot(raw, problems = []) {
         estimate: typeof raw.estimate === 'number' && raw.estimate > 0 ? raw.estimate : 1,
         quickwin: raw.quickwin === true,
         visible: raw.visible === true,
+        ...(typeof raw.public === 'string' && raw.public.trim() !== '' ? { public: raw.public.trim() } : {}),
+        ...(Number.isInteger(raw.every) && raw.every > 0 ? { every: raw.every } : {}),
+        ...(last ? { last } : {}),
         after,
         created: asDay('created'),
         started: asDay('started'),

package/dist/proc.js

@@ -0,0 +1,260 @@
+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
+    }
+}
+/** Processus vus par `ps` (macOS, sans /proc) ; null si `ps` échoue — l'appelant garde alors son dernier relevé. */
+export function readPsProcs(run = execFileSync) {
+    const procs = new Map();
+    try {
+        for (const line of run('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') });
+        }
+    }
+    catch {
+        return null;
+    }
+    return procs;
+}
+/** Tous les processus visibles : /proc sous Linux (starttime, champ 22 de stat), `ps` ailleurs (lstart) ; null si illisibles. */
+export 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 {
+        return readPsProcs();
+    }
+    return procs;
+}
+/** Âge au-delà duquel un relevé de secours (le relevé suivant a échoué) n'est plus cru : un pid y a pu être repris. */
+export const MAX_SNAPSHOT_AGE_MS = 1_000;
+/** 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 {
+    root;
+    read;
+    onUnavailable;
+    onBlindKill;
+    known = new Map();
+    timer;
+    last = new Map();
+    lastAt = 0;
+    /** Racine jamais relevée (ps en échec dès la construction) : kill() se rabat sur son groupe et sur elle. */
+    rootUnknown = false;
+    /** Le dernier relevé a échoué (ps durablement en panne) : l'arbre n'est plus connu, même repli au kill. */
+    degraded = false;
+    /** La commande racine est sortie : son pid peut être repris, il n'est plus ni adopté ni signalé. */
+    rootGone = false;
+    unavailableSaid = false;
+    /**
+     * `read` : le relevé des processus (injectable pour les tests) ; son échec laisse le dernier relevé en place.
+     * `onUnavailable` : appelé une seule fois, au premier échec du relevé (le kill est alors dégradé).
+     * `onBlindKill` : appelé au moment où kill() se rabat sur la racine faute de relevé (des descendants ont pu survivre).
+     */
+    constructor(root, read = readProcs, onUnavailable = () => { }, onBlindKill = () => { }) {
+        this.root = root;
+        this.read = read;
+        this.onUnavailable = onUnavailable;
+        this.onBlindKill = onBlindKill;
+        const info = this.snapshot().get(root);
+        if (info)
+            this.known.set(root, info.start);
+        else
+            this.rootUnknown = true;
+        this.timer = setInterval(() => this.scan(), TRACK_INTERVAL_MS);
+        this.timer.unref();
+    }
+    /**
+     * Dernier relevé réussi : un échec de lecture (ps absent ou en erreur) ne plante pas cadence depuis le timer
+     * et ne fait pas croire que tout est mort. Mais au-delà de MAX_SNAPSHOT_AGE_MS le relevé est périmé : un pid
+     * suivi a pu être repris par un autre processus, qu'on ne signalerait pas à tort — mieux vaut ne rien signaler.
+     */
+    snapshot() {
+        let fresh = null;
+        try {
+            fresh = this.read();
+        }
+        catch {
+            // relevé en échec
+        }
+        if (!fresh && !this.unavailableSaid) {
+            this.unavailableSaid = true;
+            try {
+                this.onUnavailable();
+            }
+            catch {
+                // un message raté ne doit rien casser
+            }
+        }
+        const now = Date.now();
+        this.degraded = !fresh;
+        if (fresh) {
+            this.last = fresh;
+            this.lastAt = now;
+            const root = fresh.get(this.root);
+            if (this.rootUnknown && root) {
+                this.known.set(this.root, root.start); // ps est revenu : la racine est enfin relevée
+                this.rootUnknown = false;
+            }
+        }
+        else if (now - this.lastAt > MAX_SNAPSHOT_AGE_MS) {
+            this.last = new Map();
+        }
+        return this.last;
+    }
+    /** La commande racine est sortie (reste de l'arbre éventuellement vivant) : plus d'adoption tardive ni de repli sur son pid. */
+    rootExited() {
+        this.rootGone = true;
+        this.rootUnknown = false; // plus de racine à adopter tardivement
+    }
+    /** Rien de fiable sur l'arbre : racine jamais relevée, ou relevé en échec en ce moment. */
+    get blind() {
+        return this.rootUnknown || this.degraded;
+    }
+    /** 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 = this.snapshot()) {
+        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');
+        // Sans relevé (jamais, ou plus), les descendants sont inconnus : seule la commande racine est tuée. kill(-racine) vise
+        // son groupe, mais sh n'en mène aucun (la commande reste dans le groupe de cadence, L19) : sans effet, les descendants survivent.
+        if (this.blind && !this.rootGone) {
+            try {
+                this.onBlindKill();
+            }
+            catch {
+                // un message raté ne doit rien casser
+            }
+            signal(-this.root, 'SIGKILL');
+            signal(this.root, '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;
+        // Racine jamais relevée : on ne voit rien de l'arbre, seule la racine (notre enfant, son pid ne se réutilise
+        // pas tant qu'elle n'est pas réaperçue) dit si quelque chose tourne encore — et le kill à l'échéance se
+        // replie sur elle et son groupe.
+        while (this.alive().length > 0 || (this.blind && !this.rootGone && signal(this.root, 0))) {
+            if (Date.now() >= deadline)
+                return this.kill();
+            await new Promise((r) => setTimeout(r, 50));
+        }
+    }
+}

package/dist/recurring.js

@@ -0,0 +1,19 @@
+import { diffDays } from './dates.js';
+export function isRecurring(lot) {
+    return lot.every !== undefined && (lot.status === 'todo' || lot.status === 'doing');
+}
+/** Retard en jours sur l'échéance (`last`, sinon `created`, sinon `started`, + `every`) : négatif tant qu'elle n'est pas là. */
+export function dueDays(lot, today) {
+    const from = lot.last ?? lot.created ?? lot.started ?? today;
+    return diffDays(from, today) - (lot.every ?? 0);
+}
+export function dueLine(lot, today) {
+    const late = dueDays(lot, today);
+    if (late > 0)
+        return `dû depuis ${late} j`;
+    return late === 0 ? "dû aujourd'hui" : `prochain dans ${-late} j`;
+}
+/** Les lots récurrents ouverts, du plus en retard au moins en retard — partagé par raf now et session start. */
+export function recurringByDue(lots, today) {
+    return lots.filter(isRecurring).sort((a, b) => dueDays(b, today) - dueDays(a, today));
+}

package/dist/schedule.js

@@ -1,9 +1,12 @@
 import { endAfterWorkdays, maxDay, workdayAt, workdaysThrough } from './dates.js';
+import { isRecurring } from './recurring.js';
 /**
  * One lane of work: finished lots use their real dates, lots in progress run to
  * max(estimate, today), lots to do follow in file order after their dependencies.
  */
-export function schedule(lots, commitsByLot, today) {
+export function schedule(all, commitsByLot, today) {
+    // Un lot récurrent ne se termine pas : il n'a pas de place dans la file.
+    const lots = all.filter((l) => !isRecurring(l));
     const bars = new Map();
     const firstCommit = (id) => commitsByLot.get(id)?.at(-1)?.day;
     const lastCommit = (id) => commitsByLot.get(id)?.[0]?.day;

package/dist/session.js

@@ -1,4 +1,6 @@
 import { spawnSync } from 'node:child_process';
+import { CLEAN_DAYS, scanStale } from './clean.js';
+import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { audit, exemptPlanOnly, nextUp, planCommits } from './audit.js';
 import { diffDays, maxDay } from './dates.js';
 import { repoStatus } from './git.js';
@@ -105,8 +107,10 @@ export function sessionStart(ctx, opts) {
     if (recent.orphans.length)
         done.push(`${recent.orphans.length} commit(s) sans lot`);
     section(out, `Fait depuis ${opts.since}`, done);
+    section(out, 'Récurrent', recurringByDue(lots, today).map((l) => `${l.id}  ${l.title} — ${dueLine(l, today)}`));
     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' })),
@@ -124,7 +128,7 @@ export function sessionClose(ctx, opts) {
         commits.push(`${recent.orphans.length} commit(s) sans lot :`, ...recent.orphans.map((c) => `  ${short(c)}`));
     }
     section(out, 'Commits de la période', commits.length ? commits : ['(aucun)']);
-    const quiet = plan.lots().filter((l) => l.status === 'doing' && !recent.byLot.has(l.id));
+    const quiet = plan.lots().filter((l) => l.status === 'doing' && !isRecurring(l) && !recent.byLot.has(l.id));
     section(out, 'Lots en cours', quiet.map((l) => `${l.id}  ${l.title} — aucun commit sur la période : ${plan.readonly ? "le fermer ou l'annoter avec l'outil du projet" : 'raf done ou raf note'}`));
     const issues = audit(plan, ctx.root, ctx.newsDir, today);
     section(out, 'Écarts (raf check)', issues.map((i) => `✗ ${i.message}`));
@@ -132,6 +136,19 @@ export function sessionClose(ctx, opts) {
     const lock = lockStatus(ctx.shared);
     section(out, 'Dépôt', [repo.line, ...(lock ? [lock.line] : [])]);
     section(out, 'Faits propres au projet', projectFacts(ctx, opts.since));
+    // Une proposition, pas une condition : rien n'est supprimé ici, le skill demande l'accord. Le
+    // nettoyage ne change jamais le verdict et ne fait jamais tomber la clôture.
+    if (ctx.clean?.patterns.length) {
+        const days = ctx.clean.days ?? CLEAN_DAYS;
+        try {
+            const { stale, unreadable } = scanStale(ctx.root, ctx.clean.patterns, days, today);
+            section(out, `Nettoyage proposé (${stale.length} élément(s) plus vieux de ${days} j)`, stale.map((s) => `${s.path} — ${s.age} j`));
+            section(out, `Nettoyage : ${unreadable.length} élément(s) illisible(s), jamais proposé(s)`, unreadable);
+        }
+        catch (e) {
+            section(out, "Nettoyage : parcours interrompu, rien n'est proposé", [e instanceof Error ? e.message : String(e)]);
+        }
+    }
     const open = issues.length + repo.open + (lock?.live ? 1 : 0);
     out(open === 0 ? '\n✓ prêt à fermer' : `\n✗ pas fermé : ${open} point(s)`);
     return open === 0 ? 0 : 1;