@sylad/cadence 0.8.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';
 }
@@ -249,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;
@@ -322,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('/');
@@ -376,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'),
@@ -399,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) => {
@@ -411,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 ?? ''),
@@ -418,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

@@ -48,8 +48,22 @@ function signal(pid, sig) {
         return false; // déjà mort
     }
 }
-/** Tous les processus visibles : /proc sous Linux (starttime, champ 22 de stat), `ps` ailleurs (lstart). */
-function readProcs() {
+/** 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 {
@@ -72,13 +86,12 @@ function readProcs() {
         }
     }
     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 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;
 /**
@@ -90,21 +103,92 @@ export const TRACK_INTERVAL_MS = 200;
  * intervalle) et ce que cadence n'a pas le droit de tuer (sudo).
  */
 export class TreeTracker {
+    root;
+    read;
+    onUnavailable;
+    onBlindKill;
     known = new Map();
     timer;
-    constructor(root) {
-        const info = readProcs().get(root);
+    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 = readProcs()) {
+    scan(procs = this.snapshot()) {
         for (let grew = true; grew;) {
             grew = false;
             for (const [pid, info] of procs) {
@@ -144,6 +228,18 @@ export class TreeTracker {
         }
         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),
@@ -152,7 +248,10 @@ export class TreeTracker {
     async end(graceMs) {
         this.stop();
         const deadline = Date.now() + graceMs;
-        while (this.alive().length > 0) {
+        // 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,6 +107,7 @@ 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 ?? []);
@@ -125,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}`));
@@ -133,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "A small, repo-native working method: a versioned plan linked to your commits, a changelog with screenshots, session rituals and deliveries proven by their effect.",
   "license": "MIT",
   "author": "Sylvain Ladoire",
@@ -14,6 +14,7 @@
     "dist",
     "skills",
     "agents",
+    "templates",
     ".claude-plugin",
     "README.md",
     "LICENSE"
@@ -35,5 +36,9 @@
     "@types/node": "^20.14.0",
     "typescript": "^5.5.0",
     "vitest": "^2.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sylad/cadence.git"
   }
 }

package/skills/lead/SKILL.md

@@ -34,26 +34,46 @@ progress, then drift that blocks a delivery, then ready quick wins. **Stop and w
 
 ## 2. Delegation
 
-For each chosen lot, the lead runs `cd <project> && raf start <lot>`, then gives a subagent this brief
-(fill in the brackets, keep the rest verbatim):
-
-> Work in `<absolute path of the project>` on lot `<id>` — "<title>" — of its plan
-> (`docs/plan/raf.yaml`, or the file named by `plan:` in `cadence.yaml`; read the lot, its notes and sub-tasks, and the project's CLAUDE.md first).
-> Goal: <what done looks like, from the human's words>.
-> Rules: test first; commit each sub-part as soon as its tests pass, with explicit paths (never
-> `git add -A` or `commit -a`), and a message that cites the lot (`feat(<id>): …`); run the project's
-> full test suite and build before reporting; do not push, deliver, run `raf done`, `raf ux` or
-> `raf review`.
-> If something is ambiguous or needs a decision, stop and report the question instead of guessing.
-> Report: commits (sha + subject), tests and build results with their numbers, what you could not
-> verify, open questions.
+The default way to delegate is **`cadence orchestrate`** (section 2b): a program, not a conversation, that runs
+one fresh short session per step. When the lead delegates by hand, the brief is the template
+`templates/orchestrate/implement.md` of the cadence package — the single source, tested; `cadence
+orchestrate --dry-run <project>:<lot>` writes it rendered for the lot. The lead runs
+`cd <project> && raf start <lot>`, fills `{{chemin}}`, `{{lot}}`, `{{titre}}` and `{{objectif}}` (what done
+looks like, from the human's words), and keeps the rest verbatim.
 
 A lot that adds or changes a screen is `visible`: after the implementation, have the
 `ux-reviewer` agent review it (give it the URL or the way to run the app) and bring its verdict and
 proposed sub-tasks back to the human.
 
+### 2b. A wave through `cadence orchestrate`
+
+Once the human has chosen the lots, the lead runs, **in the background** (it is notified at the end; no
+silent wait, no polling loop — `cadence orchestrate --status` shows where the wave is):
+
+```sh
+cadence orchestrate <project>:<lot> <project>:<lot>@haiku … [--budget 2M]
+```
+
+`cadence orchestrate --dry-run …` first when a precondition is in doubt. The program, not the lead, runs
+for each lot a fresh short session per step — implementation (Sonnet), UX review if the lot is `visible`
+and the project declares how to see its app (`orchestrate.ux` in `cadence.yaml`), code review last
+(Opus, the `code-reviewer` agent), a correction in a new session if the review is not compliant (two
+passes at most) — and records `raf review` itself when the code review is compliant. The state is in
+`.cadence/runs/<wave>/`, not in this conversation. `@haiku` only when the human writes it, for a
+mechanical lot. Exit code: 0 all ready · 1 some lots handed back · 2 refused before acting · 3 wave
+suspended (budget or usage limit; `--resume --budget …` continues).
+
+What the orchestrator does **not** do, and stays with the lead: choose the lots (with the human), bring the
+questions back (`--resume --answer <project>:<lot> "…"`), look at the UX reviewer's captures and record
+`raf ux` (the orchestrator reports its verdict, it never records it), re-verify (section 3, point 2),
+`raf done`, push and deliver. Minor findings and proposed sub-tasks come back in the table: adding them to
+the plan is the lead's decision. If an orchestrated wave is running in a repository, do not commit there
+and do not deliver it (`cadence deliver` refuses).
+
 ## 3. Check
 
+0. After an orchestrated wave the review is already done, by a fresh session: read the table, then go to
+   point 2. For a lot delegated by hand:
 1. The `code-reviewer` agent, as a fresh subagent (most capable model), reviews the lot. Give it
    the absolute path of the project and the lot id, **not** the author's report: it reads the diff
    itself from the commits that cite the lot, runs the checks, and returns real defects only,