@sylad/cadence 0.7.0 → 0.9.0

package/dist/clean.js

@@ -0,0 +1,225 @@
+import { lstatSync, readdirSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { diffDays, toDay } from './dates.js';
+export const CLEAN_DAYS = 7;
+/** Absence ordinaire (rien à cet endroit), à distinguer d'une lecture refusée. */
+const missing = (e) => {
+    const code = e.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+};
+/** `*` ne remplace que des caractères d'un nom : un motif ne traverse jamais un `/`. */
+const segmentRe = (seg) => new RegExp(`^${seg.split('*').map((s) => s.replace(/[.+?^${}()|[\]\\]/g, '\\$&')).join('[^/]*')}$`);
+/**
+ * Chemins qui correspondent au motif. Chaque niveau est lu par readdir, noms écrits en entier compris :
+ * un dossier qu'on ne peut pas lister ne livre rien (et est noté illisible, sauf s'il n'existe pas).
+ * Comme le shell, un nom en « . » n'est atteint que par un segment de motif qui commence par « . ».
+ * Contrairement au shell, on ne descend jamais dans un lien symbolique attrapé par un segment à `*` :
+ * `tmp/*` peut rendre le lien `tmp/lien` lui-même, mais un segment suivant ne lit jamais ce qu'il désigne.
+ * Cela vaut pour tout ce qui suit un `*`, segments écrits en entier compris (dans `tmp/<étoile>/out`, `out` ne suit pas) :
+ * seuls les segments écrits en entier AVANT le premier `*` suivent un lien, comme `cd` — celui qui les écrit
+ * désigne cet endroit-là.
+ */
+function expand(pattern, root, unreadable) {
+    const full = pattern === '~' || pattern.startsWith('~/') ? join(homedir(), pattern.slice(1)) : pattern;
+    const parts = resolve(root, full).split('/').filter((p) => p !== '');
+    let found = ['/'];
+    let wild = false;
+    for (const part of parts) {
+        const re = segmentRe(part);
+        const next = [];
+        for (const base of found) {
+            let names;
+            try {
+                if (wild && lstatSync(base).isSymbolicLink())
+                    continue;
+                names = readdirSync(base);
+            }
+            catch (e) {
+                if (!missing(e))
+                    unreadable.add(base);
+                continue;
+            }
+            for (const n of names)
+                if (re.test(n) && (part.startsWith('.') || !n.startsWith('.')))
+                    next.push(join(base, n));
+        }
+        found = next;
+        wild = wild || part.includes('*');
+    }
+    return found;
+}
+/**
+ * Vrai si les noms d'un dossier en font un dossier git aux yeux de git lui-même — HEAD avec objects
+ * et refs (dépôt nu, miroir, `--separate-git-dir`, `.git`), ou HEAD avec commondir (administration
+ * d'un arbre de travail). Le type des entrées n'est pas vérifié : dans le doute, on protège.
+ */
+const gitDirNames = (has) => has('HEAD') && ((has('objects') && has('refs')) || has('commondir'));
+/**
+ * Vrai si le dossier réel de ce chemin, ou l'un de ses ancêtres jusqu'à `/`, est un dossier git
+ * (voir `gitDirNames`) ; `null` si on ne peut pas le savoir (chemin introuvable, lecture refusée).
+ */
+function insideGitDir(path) {
+    let dir;
+    try {
+        dir = realpathSync(dirname(path));
+    }
+    catch {
+        return null;
+    }
+    for (let d = dir;; d = dirname(d)) {
+        let unknown = false;
+        const has = (n) => {
+            try {
+                lstatSync(join(d, n));
+                return true;
+            }
+            catch (e) {
+                if (!missing(e))
+                    unknown = true;
+                return false;
+            }
+        };
+        if (gitDirNames(has))
+            return true;
+        if (unknown)
+            return null;
+        if (d === dirname(d))
+            return false;
+    }
+}
+/**
+ * Dernier changement d'un élément : le plus récent de son mtime et de son ctime. Le mtime se fixe
+ * (`tar xf`, `cp -a`, `rsync -a` gardent celui de la source) ; le ctime, lui, vaut toujours l'arrivée
+ * de l'élément ici.
+ */
+const lastChange = (st) => Math.max(st.mtimeMs, st.ctimeMs);
+/**
+ * Date de modification la plus récente (ms) d'un chemin et, pour un dossier, de tout son contenu
+ * (liens non suivis). `null` quand on ne peut pas l'affirmer périmé : un dépôt git est rencontré
+ * (une entrée `.git`, dossier ou fichier, ou un dossier git reconnu à son contenu), ou une lecture échoue — ce chemin est alors noté illisible.
+ */
+function measure(path, unreadable) {
+    let st;
+    try {
+        st = lstatSync(path);
+    }
+    catch {
+        unreadable.add(path);
+        return null;
+    }
+    if (!st.isDirectory())
+        return lastChange(st);
+    let names;
+    try {
+        names = readdirSync(path);
+    }
+    catch {
+        unreadable.add(path);
+        return null;
+    }
+    if (names.includes('.git') || gitDirNames((n) => names.includes(n)))
+        return null;
+    let newest = lastChange(st);
+    for (const n of names) {
+        const m = measure(join(path, n), unreadable);
+        if (m === null)
+            return null;
+        if (m > newest)
+            newest = m;
+    }
+    return newest;
+}
+/** Vrai si un dossier ancêtre (ou le dossier lui-même) porte une entrée `.git` ; `null` si on ne peut pas le savoir. */
+function underGit(dir) {
+    for (let d = dir;; d = dirname(d)) {
+        try {
+            lstatSync(join(d, '.git'));
+            return true;
+        }
+        catch (e) {
+            if (!missing(e))
+                return null;
+        }
+        if (d === dirname(d))
+            return false;
+    }
+}
+/** Environnement sans variables GIT_* : un GIT_DIR hérité (hook) ferait répondre un autre dépôt. */
+const gitEnv = () => Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.startsWith('GIT_')));
+/**
+ * Suivi git du chemin (ou d'un fichier dessous), demandé à git depuis le dossier du chemin, où qu'il soit :
+ * `'tracked'`, `'untracked'`, ou `null` si la réponse n'a pas pu être obtenue (dossier introuvable,
+ * `.git` présent mais git en échec — dépôt invalide, propriétaire douteux, git absent).
+ */
+function gitTracking(path) {
+    let dir;
+    try {
+        dir = realpathSync(dirname(path));
+    }
+    catch {
+        return null;
+    }
+    const inRepo = underGit(dir);
+    if (inRepo !== true)
+        return inRepo === false ? 'untracked' : null;
+    const r = spawnSync('git', ['--literal-pathspecs', 'ls-files', '-z', '--', basename(path)], {
+        cwd: dir,
+        encoding: 'utf8',
+        env: gitEnv(),
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    if (r.status !== 0)
+        return null;
+    return r.stdout === '' ? 'untracked' : 'tracked';
+}
+/** Vrai si ce chemin est la racine ou l'un de ses ancêtres : le proposer reviendrait à proposer le dépôt. */
+const holdsRoot = (path, root) => {
+    const r = relative(path, resolve(root));
+    return !(r === '..' || r.startsWith('../'));
+};
+/**
+ * Parcourt les motifs et rend les éléments périmés (plus de `days` jours) qu'on peut proposer de
+ * supprimer, ainsi que ceux qu'on n'a pas pu mesurer. Ne supprime rien et ne lève pas sur une
+ * lecture refusée.
+ */
+export function scanStale(root, patterns, days, today) {
+    const unreadable = new Set();
+    const done = new Set();
+    const stale = [];
+    for (const pattern of patterns) {
+        for (const path of expand(pattern, root, unreadable)) {
+            if (done.has(path))
+                continue;
+            done.add(path);
+            if (holdsRoot(path, root) || path.split('/').includes('.git'))
+                continue;
+            const inGit = insideGitDir(path);
+            if (inGit === null)
+                unreadable.add(path);
+            if (inGit !== false)
+                continue;
+            const newest = measure(path, unreadable);
+            if (newest === null)
+                continue;
+            const age = diffDays(toDay(new Date(newest)), today);
+            if (age <= days)
+                continue;
+            const git = gitTracking(path);
+            if (git === null)
+                unreadable.add(path);
+            if (git !== 'untracked')
+                continue;
+            stale.push({ path, age });
+        }
+    }
+    return {
+        stale: stale.sort((a, b) => b.age - a.age || a.path.localeCompare(b.path)),
+        unreadable: [...unreadable].sort(),
+    };
+}
+/** Éléments périmés à proposer (voir `scanStale`), du plus vieux au plus récent. Ne supprime rien. */
+export function staleFiles(root, patterns, days, today) {
+    return scanStale(root, patterns, days, today).stale;
+}

package/dist/cli.js

@@ -6,22 +6,28 @@ import { audit, exemptPlanOnly, isPlanOnly, lotWork, nextUp, planCommits, unrevi
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
 import { deliver, parseDeliverConfig, realDeps } from './deliver.js';
+import { effectLines, realCheckDeps, verifyCommand } from './verify.js';
 import { ganttData, renderGantt } from './gantt.js';
-import { gitRoot, readCommits } from './git.js';
+import { gitRoot, headSha, readCommits, resolveCommit } from './git.js';
 import { installHook } from './hook.js';
-import { linkCommits } from './link.js';
+import { citedRefs, linkCommits } from './link.js';
 import { buildNews, loadEntries, newEntry, newsData, newsIssues, stampEntries } from './news.js';
 import { Plan, RafError, STATUSES } from './plan.js';
+import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
+import { orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
+import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
 import { sessionClose, sessionStart } from './session.js';
-import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
+import { clearNext, lastDelivery, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
 const HELP = `raf — plan « reste à faire » versionné dans le dépôt, relié aux commits
 
   raf init [--project nom] [--prefix L] [--no-hook]
-  raf add "titre" [--estimate j] [--quickwin] [--visible] [--after L2,L4] [--parent L3]
+  raf add "titre" [--estimate j] [--quickwin] [--visible] [--public "titre public"] [--every jours] [--after L2,L4] [--parent L3]
+  raf public <id> "titre public" | --clear   titre du lot dans le langage du public (pages Nouveautés et Plan)
   raf start <id>        raf done <id> [--force]        raf drop <id> [--reason texte]
   raf note <id> "texte"
+  raf did <id> ["texte"]   un lot récurrent (--every) a été refait : le « dû depuis N j » repart de aujourd'hui
   raf ux enable         revue UX obligatoire avant « done » pour les lots --visible
   raf ux <id> "verdict" enregistre la revue d'ergonomie du lot (agent ux-reviewer)
   raf review enable     revue de code obligatoire avant « done » pour les lots qui ont des commits
@@ -32,10 +38,15 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf check [--since date] [--idle 7]   (défaut : date « since » du plan) code 1 s'il y a des écarts
   raf gantt [-o docs/plan/gantt.html]
   raf hook install
+  cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom]   une session claude neuve par étape ; --status [vague] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"]
+  cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
 Un commit appartient à un lot quand son message cite l'identifiant : « feat(L3): … », « L3/t1 ».
-Un commit qui ne touche que le plan (et les fichiers déclarés sous plan.files dans cadence.yaml, un plan
+Quand la portée du sujet cite des lots — « feat(L3): … », « chore(L31,L32): … » — elle seule décide : une
+mention en passage (« page équipe (L27) »), une plage (« L28–L31 », « L45 à L48 ») ou le corps n'y comptent pas.
+Sans portée citant un lot, tout le message est lu : « fix: L3 corrigé », « L3/t1 ».
+Un commit qui ne touche que le plan, la clé plan: de cadence.yaml (deliver/session sont du travail) (et les fichiers déclarés sous plan.files, un plan
 publié par exemple) n'a pas à en citer, et ne compte pas pour les lots qu'il cite ; le sujet n'y change rien.
 Un lot --visible attend une entrée Nouveautés (docs/nouveautes/, --dir) avec capture ; raf check le vérifie.
 Un texte qui commence par « - » se passe après « -- » : raf note L1 -- "-5 %".
@@ -44,6 +55,10 @@ autre outil se lit sans migration (correspondance des champs, voir le README) et
 Options communes : --file chemin (ou RAF_FILE), RAF_TODAY=AAAA-MM-JJ pour figer la date.`;
 export function run(argv, io) {
     try {
+        // orchestrate a ses propres options (--status et --resume prennent une valeur facultative, --answer en prend deux).
+        if (argv[0] === 'orchestrate') {
+            return orchestrate(argv.slice(1), io, realOrchestrateDeps(io.env)).catch((e) => failure(e, io));
+        }
         const result = dispatch(argv, io);
         return result instanceof Promise ? result.catch((e) => failure(e, io)) : result;
     }
@@ -74,6 +89,8 @@ function dispatch(argv, io) {
             estimate: { type: 'string' },
             quickwin: { type: 'boolean' },
             visible: { type: 'boolean' },
+            public: { type: 'string' },
+            every: { type: 'string' },
             dir: { type: 'string' },
             title: { type: 'string' },
             after: { type: 'string' },
@@ -87,6 +104,7 @@ function dispatch(argv, io) {
             config: { type: 'string' },
             'dry-run': { type: 'boolean' },
             sha: { type: 'string' },
+            retry: { type: 'string' },
             clear: { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
         },
@@ -106,8 +124,12 @@ function dispatch(argv, io) {
     const installing = command === 'skills' || (command === 'hook' && rest[0] === 'install');
     const planConfig = installing ? null : readPlanConfig(configPath);
     const planPath = resolve(io.cwd, values.file ?? io.env.RAF_FILE ?? resolve(root, planConfig?.path ?? 'docs/plan/raf.yaml'));
-    const loadPlan = () => Plan.load(planPath, planConfig?.settings);
+    const loadPlan = () => Plan.load(planPath, { ...planConfig?.settings, config: configPath });
     const newsDir = resolve(io.cwd, values.dir ?? join(root, 'docs/nouveautes'));
+    // Une session d'orchestration ne ferme pas un lot, n'enregistre pas de verdict à la place du lead et ne livre pas.
+    if (io.env.CADENCE_ORCHESTRATED && (command === 'done' || command === 'ux' || command === 'review' || command === 'deliver')) {
+        throw new RafError(`${command} refusé pendant une vague orchestrée (${io.env.CADENCE_ORCHESTRATED}) : c'est le travail du lead`);
+    }
     const need = (n, usage) => {
         if (rest.length < n)
             throw new RafError(`usage : raf ${usage}`);
@@ -127,6 +149,10 @@ function dispatch(argv, io) {
             const plan = loadPlan();
             let id;
             if (values.parent) {
+                if (values.public !== undefined)
+                    throw new RafError('--public se pose sur un lot, pas sur une sous-tâche');
+                if (values.every !== undefined)
+                    throw new RafError('--every se pose sur un lot, pas sur une sous-tâche');
                 id = plan.addTask(values.parent, rest.join(' '));
             }
             else {
@@ -134,7 +160,10 @@ function dispatch(argv, io) {
                 if (estimate !== undefined && !(estimate > 0))
                     throw new RafError(`estimation invalide : ${values.estimate}`);
                 const after = values.after ? values.after.split(',').map((s) => s.trim()).filter(Boolean) : undefined;
-                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, after });
+                const every = values.every === undefined ? undefined : Number(values.every);
+                if (every !== undefined && !(Number.isInteger(every) && every > 0))
+                    throw new RafError(`périodicité invalide : ${values.every} (un nombre entier de jours)`);
+                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, public: values.public, every, after });
             }
             plan.save();
             io.out(id);
@@ -168,6 +197,23 @@ function dispatch(argv, io) {
             plan.save();
             return 0;
         }
+        case 'did': {
+            need(1, 'did <id> ["texte"]');
+            const plan = loadPlan();
+            plan.did(rest[0], today, rest.slice(1).join(' '));
+            plan.save();
+            io.out(`${rest[0]} refait le ${today}`);
+            return 0;
+        }
+        case 'public': {
+            need(values.clear ? 1 : 2, 'public <id> "titre public" | public <id> --clear');
+            if (values.clear && rest.length > 1)
+                throw new RafError('--clear n\'attend pas de titre');
+            const plan = loadPlan();
+            plan.setPublic(rest[0], values.clear ? null : rest.slice(1).join(' '));
+            plan.save();
+            return 0;
+        }
         case 'ux':
         case 'review':
             return gate(command, rest, loadPlan, root, today, io);
@@ -223,19 +269,31 @@ function dispatch(argv, io) {
                 return 0;
             }
             if (rest[0] === 'post-commit')
-                return postCommit(existsSync(planPath) ? loadPlan : null, newsDir, root, io);
+                return postCommit(existsSync(planPath) ? loadPlan : null, newsDir, root, today, io);
             throw new RafError('usage : raf hook install|post-commit');
         }
         case 'session': {
             if (!gitRoot(io.cwd))
                 throw new RafError('session : à lancer dans un dépôt git');
             // « next » n'écrit que les notes : la commande du projet ne se joue qu'à la reprise et à la clôture.
-            const facts = rest[0] === 'start' || rest[0] === 'close' ? readSessionConfig(configPath)[rest[0]] : undefined;
-            return session(rest, { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, out: io.out, facts }, values);
+            const sconf = rest[0] === 'start' || rest[0] === 'close' ? readSessionConfig(configPath) : {};
+            const facts = rest[0] === 'start' || rest[0] === 'close' ? sconf[rest[0]] : undefined;
+            const clean = rest[0] === 'close' && sconf.clean ? { patterns: sconf.clean, days: sconf.cleanDays } : undefined;
+            const sctx = { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, out: io.out, facts, clean };
+            if (rest[0] !== 'start')
+                return session(rest, sctx, values);
+            // La reprise rejoue les vérifications d'effet (un essai, borné) : un effet rouge d'hier se lit avec les faits du matin.
+            const effects = morningEffects(configPath, root);
+            if (effects === null)
+                return session(rest, sctx, values);
+            return Promise.resolve(effects).then((lines) => session(rest, { ...sctx, effects: lines }, values));
         }
         case 'deliver': {
             if (!gitRoot(io.cwd))
                 throw new RafError('deliver : à lancer dans un dépôt git');
+            const orchestrating = activeLock(join(sharedStateDir(root), REPO_LOCK));
+            if (orchestrating)
+                throw new RafError(`deliver : orchestration en cours (vague ${orchestrating.wave}, pid ${orchestrating.pid}) — livrer une fois la vague finie`);
             if (!existsSync(configPath))
                 throw new RafError(`pas de configuration de livraison : ${configPath} (voir « cadence.yaml » dans le README)`);
             const config = parseDeliverConfig(readFileSync(configPath, 'utf8'), configPath);
@@ -243,6 +301,20 @@ function dispatch(argv, io) {
             const ctx = { root, state: sharedStateDir(root), plan, config, today, dryRun: !!values['dry-run'], sha: values.sha, args: rest, out: io.out, err: io.err };
             return deliver(ctx, realDeps(root));
         }
+        case 'verify': {
+            if (!gitRoot(io.cwd))
+                throw new RafError('verify : à lancer dans un dépôt git');
+            if (!existsSync(configPath))
+                throw new RafError(`pas de configuration : ${configPath} (voir « cadence.yaml » dans le README)`);
+            const retry = values.retry === undefined ? 0 : Number(values.retry);
+            if (!Number.isFinite(retry) || retry < 0)
+                throw new RafError(`--retry invalide : ${values.retry} (secondes, 0 ou plus)`);
+            const config = parseDeliverConfig(readFileSync(configPath, 'utf8'), configPath);
+            const sha = values.sha ? (resolveCommit(root, values.sha) ?? '') : (lastDelivery(sharedStateDir(root)) ?? headSha(root) ?? '');
+            if (values.sha && !sha)
+                throw new RafError(`--sha ${values.sha} : commit introuvable`);
+            return verifyCommand({ config, sha, retry, out: io.out }, realCheckDeps(root));
+        }
         case 'skills': {
             if (rest[0] !== 'install')
                 throw new RafError('usage : cadence skills install [--dir .claude] [--force]');
@@ -323,6 +395,12 @@ function now(plan, root, newsDir, today, io) {
         io.out(`  … et ${ready.length - 5} autre(s)`);
     if (blocked.length)
         io.out(`  en attente de dépendances : ${blocked.map((l) => l.id).join(', ')}`);
+    const recurring = recurringByDue(lots, today);
+    if (recurring.length) {
+        io.out('\nRécurrent');
+        for (const l of recurring)
+            io.out(`  ${l.id}  ${l.title}  (tous les ${l.every} j, ${dueLine(l, today)})`);
+    }
     const done = lots
         .filter((l) => l.status === 'done' && l.finished)
         .sort((a, b) => (b.finished > a.finished ? 1 : -1))
@@ -337,7 +415,7 @@ function now(plan, root, newsDir, today, io) {
         io.out(`\n${issues.length} écart(s) entre le plan et l'historique — raf check`);
     return 0;
 }
-function postCommit(load, newsDir, root, io) {
+function postCommit(load, newsDir, root, today, io) {
     if (!load)
         return 0;
     try {
@@ -345,7 +423,7 @@ function postCommit(load, newsDir, root, io) {
         const head = readCommits(root, { range: '-1' })[0];
         if (!head)
             return 0;
-        const refs = plan.refs(`${head.subject}\n${head.body}`);
+        const refs = citedRefs(head, plan.refs);
         if (refs.length === 0) {
             const planOnly = exemptPlanOnly({ byLot: new Map(), orphans: [head], unknown: [] }, plan, root).orphans.length === 0;
             if (!planOnly && !/^Merge\b/.test(head.subject)) {
@@ -359,6 +437,8 @@ function postCommit(load, newsDir, root, io) {
             const lot = lots.get(r.lot);
             if (!lot)
                 io.err(`raf: ${r.lot} n'existe pas dans le plan`);
+            else if (isRecurring(lot))
+                io.err(`raf: ${r.lot} est récurrent (${dueLine(lot, today)})${plan.readonly ? '' : ` — raf did ${r.lot}`}`);
             else if (lot.status === 'todo' && !planning)
                 io.err(`raf: ${r.lot} est encore todo${plan.readonly ? '' : ` — raf start ${r.lot}`}`);
             else
@@ -422,6 +502,27 @@ function news([sub, ...args], plan, dir, today, values, io) {
             throw new RafError('usage : cadence news new|list|check|stamp|build');
     }
 }
+/**
+ * Reprise : lignes d'effets à rejouer, ou null quand il n'y a rien à vérifier (sans cadence.yaml, sans deliver,
+ * script sans verify) — la reprise reste alors synchrone. Ne lève jamais.
+ */
+function morningEffects(configPath, root) {
+    if (!existsSync(configPath))
+        return null;
+    const text = readFileSync(configPath, 'utf8');
+    if (!/^deliver\s*:/m.test(text))
+        return null;
+    try {
+        const config = parseDeliverConfig(text, configPath);
+        if (config.verify.length === 0)
+            return null;
+        const sha = lastDelivery(sharedStateDir(root)) ?? headSha(root) ?? '';
+        return effectLines(config, sha, realCheckDeps(root, { quiet: true }));
+    }
+    catch (e) {
+        return [`✗ ${e.message}`];
+    }
+}
 function session([sub, ...args], ctx, values) {
     switch (sub) {
         case 'start': {

package/dist/config.js

@@ -93,14 +93,90 @@ export function readSessionConfig(file) {
     if (s == null)
         return {};
     if (!isObject(s))
-        throw new RafError(`${file} : session doit être un objet { start, close }`);
+        throw new RafError(`${file} : session doit être un objet { start, close, clean, cleanDays }`);
     const config = {};
     for (const [k, v] of Object.entries(s)) {
-        if (k !== 'start' && k !== 'close')
-            throw new RafError(`${file} : session.${k} inconnu (attendu : start, close)`);
-        if (typeof v !== 'string' || !v.trim())
-            throw new RafError(`${file} : session.${k} : commande non vide attendue`);
-        config[k] = v.trim();
+        if (k === 'clean') {
+            if (!Array.isArray(v) || v.some((p) => typeof p !== 'string' || !p.trim()))
+                throw new RafError(`${file} : session.clean : liste de motifs non vides attendue`);
+            config.clean = v.map((p) => p.trim());
+        }
+        else if (k === 'cleanDays') {
+            if (typeof v !== 'number' || !Number.isInteger(v) || v < 1)
+                throw new RafError(`${file} : session.cleanDays : nombre entier de jours (≥ 1) attendu`);
+            config.cleanDays = v;
+        }
+        else if (k === 'start' || k === 'close') {
+            if (typeof v !== 'string' || !v.trim())
+                throw new RafError(`${file} : session.${k} : commande non vide attendue`);
+            config[k] = v.trim();
+        }
+        else
+            throw new RafError(`${file} : session.${k} inconnu (attendu : start, close, clean, cleanDays)`);
+    }
+    return config;
+}
+const ORCH_KEYS = ['start', 'verdict', 'test', 'ux', 'permissionMode', 'addDirs', 'timeouts'];
+/** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
+export function readOrchestrateConfig(file) {
+    const config = { permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
+    if (!existsSync(file))
+        return config;
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const o = raw?.orchestrate;
+    if (o == null)
+        return config;
+    const bad = (what) => new RafError(`${file} : orchestrate.${what}`);
+    if (!isObject(o))
+        throw new RafError(`${file} : orchestrate doit être un objet`);
+    for (const k of Object.keys(o))
+        if (!ORCH_KEYS.includes(k))
+            throw bad(`${k} inconnu (attendu : ${ORCH_KEYS.join(', ')})`);
+    for (const k of ['start', 'verdict', 'test']) {
+        if (o[k] == null)
+            continue;
+        if (typeof o[k] !== 'string' || !o[k].trim())
+            throw bad(`${k} : commande non vide attendue`);
+        config[k] = o[k].trim();
+    }
+    if (o.ux != null) {
+        if (typeof o.ux === 'string' && o.ux.trim())
+            config.ux = /^https?:\/\//.test(o.ux.trim()) ? { url: o.ux.trim() } : { command: o.ux.trim() };
+        else if (isObject(o.ux) && (o.ux.url != null || o.ux.command != null)) {
+            for (const k of Object.keys(o.ux))
+                if (k !== 'url' && k !== 'command')
+                    throw bad(`ux.${k} inconnu (attendu : url, command)`);
+            config.ux = {};
+            for (const k of ['url', 'command'])
+                if (o.ux[k] != null)
+                    config.ux[k] = String(o.ux[k]);
+        }
+        else
+            throw bad('ux : une URL, une commande, ou { url, command }');
+    }
+    if (o.permissionMode != null) {
+        if (typeof o.permissionMode !== 'string' || !o.permissionMode.trim())
+            throw bad('permissionMode : texte non vide attendu');
+        config.permissionMode = o.permissionMode.trim();
+    }
+    if (o.addDirs != null)
+        config.addDirs = list(o.addDirs);
+    if (o.timeouts != null) {
+        if (!isObject(o.timeouts))
+            throw bad('timeouts doit être un objet { implement, review } (minutes)');
+        for (const [k, v] of Object.entries(o.timeouts)) {
+            if (k !== 'implement' && k !== 'review')
+                throw bad(`timeouts.${k} inconnu (attendu : implement, review)`);
+            if (typeof v !== 'number' || !(v > 0))
+                throw bad(`timeouts.${k} : nombre de minutes positif attendu`);
+            config.timeouts[k === 'implement' ? 'work' : 'review'] = v * 60_000;
+        }
     }
     return config;
 }