@sylad/cadence 0.8.0 → 0.10.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,23 +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 { defaultTarget, effectLines, realCheckDeps, verifyCommand } from './verify.js';
 import { ganttData, renderGantt } from './gantt.js';
-import { gitRoot, headSha, readCommits, resolveCommit } from './git.js';
+import { gitRoot, readCommits, resolveCommit } from './git.js';
 import { installHook } from './hook.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, lastDelivery, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
+import { clearNext, 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
@@ -33,6 +38,7 @@ 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 … »)
 
@@ -49,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;
     }
@@ -79,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' },
@@ -114,6 +126,10 @@ function dispatch(argv, io) {
     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, 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}`);
@@ -133,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 {
@@ -140,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);
@@ -174,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);
@@ -229,15 +269,17 @@ 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;
-            const sctx = { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, out: io.out, facts };
+            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.
@@ -249,6 +291,9 @@ function dispatch(argv, io) {
         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);
@@ -265,10 +310,10 @@ function dispatch(argv, io) {
             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)
+            const target = values.sha ? { sha: resolveCommit(root, values.sha) ?? '', note: null } : defaultTarget(root, config);
+            if (values.sha && !target.sha)
                 throw new RafError(`--sha ${values.sha} : commit introuvable`);
-            return verifyCommand({ config, sha, retry, out: io.out }, realCheckDeps(root));
+            return verifyCommand({ config, sha: target.sha, note: target.note, retry, out: io.out }, realCheckDeps(root));
         }
         case 'skills': {
             if (rest[0] !== 'install')
@@ -350,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))
@@ -364,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 {
@@ -386,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
@@ -463,8 +516,8 @@ function morningEffects(configPath, root) {
         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 }));
+        const target = defaultTarget(root, config);
+        return effectLines(config, target.sha, realCheckDeps(root, { quiet: true }), target.note);
     }
     catch (e) {
         return [`✗ ${e.message}`];

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;
 }

package/dist/deliver.js

@@ -1,7 +1,7 @@
 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 { onTermination, readProcs, 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';
@@ -95,8 +95,8 @@ export function parseDeliverConfig(text, file) {
         deployTimeout: seconds('deployTimeout', 1800),
     };
 }
-/** Dépendances réelles : sh, gh, fetch, horloge. */
-export function realDeps(root) {
+/** Dépendances réelles : sh, gh, fetch, horloge. `read` : le relevé des processus du suivi (injectable pour les tests). */
+export function realDeps(root, read = readProcs) {
     const gh = (args) => {
         try {
             return execFileSync('gh', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: GH_TIMEOUT });
@@ -131,7 +131,7 @@ export function realDeps(root) {
             // 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);
+            const tree = new TreeTracker(pid, read, () => process.stderr.write('deliver : relevé des processus indisponible — le kill n\'est dégradé que tant que le relevé échoue : seule la commande racine sera tuée, ses descendants survivront\n'), () => process.stderr.write('deliver : kill replié sur la commande racine faute de relevé des processus — des descendants ont pu survivre\n'));
             // 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;
@@ -143,6 +143,7 @@ export function realDeps(root) {
             }, Math.max(1_000, timeoutMs));
             child.once('exit', (code, signal) => {
                 clearTimeout(timer);
+                tree.rootExited(); // son pid peut être repris : plus d'adoption tardive de la racine pendant la grâce
                 const result = timedOut ? TIMED_OUT : signal ? 128 + (constants.signals[signal] ?? 0) : (code ?? 1);
                 const settle = () => {
                     tree.stop();

package/dist/git.js

@@ -88,6 +88,35 @@ export function repoStatus(cwd) {
         ahead,
     };
 }
+/** Branche amont suivie (« origin/main ») et son sha tel que connu localement (sans réseau), null sans amont. */
+export function upstreamHead(cwd) {
+    const ref = tryGit(cwd, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']);
+    const sha = ref ? tryGit(cwd, ['rev-parse', '--verify', '-q', '@{u}']) : null;
+    return ref && sha ? { ref, sha } : null;
+}
+/**
+ * L'amont suivi est-il la branche de production du dépôt distant ? Lu sans réseau : `refs/remotes/<remote>/HEAD`
+ * (origin/HEAD, posé par clone ou `git remote set-head`). Absent (dépôt créé par init + push) : repli sur les
+ * noms usuels, main puis master.
+ */
+export function upstreamIsDefaultBranch(cwd, upstreamRef) {
+    // Le remote vient de la config de la branche, pas d'une coupe de `@{u}` au premier « / » : un remote peut contenir un
+    // « / » (gh/origin) et un amont local (branche locale suivie) a pour remote « . » — jamais la branche de production.
+    const branch = tryGit(cwd, ['symbolic-ref', '-q', '--short', 'HEAD']);
+    if (!branch)
+        return false;
+    const remote = tryGit(cwd, ['config', '--get', `branch.${branch}.remote`]);
+    const merge = tryGit(cwd, ['config', '--get', `branch.${branch}.merge`]);
+    if (!remote || remote === '.' || !merge)
+        return false;
+    const upstreamBranch = merge.replace(/^refs\/heads\//, '');
+    if (upstreamRef !== `${remote}/${upstreamBranch}`)
+        return false;
+    const head = tryGit(cwd, ['symbolic-ref', '-q', '--short', `refs/remotes/${remote}/HEAD`]);
+    if (head)
+        return head === upstreamRef;
+    return upstreamBranch === 'main' || upstreamBranch === 'master';
+}
 /** Le commit est-il contenu dans une branche distante connue localement ? */
 export function onRemote(cwd, sha) {
     return (tryGit(cwd, ['branch', '-r', '--contains', sha]) ?? '').length > 0;

package/dist/orchestrate/briefs.js

@@ -0,0 +1,52 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { RafError } from '../plan.js';
+/** Gabarits livrés avec le paquet (à la racine, à côté de dist/ et src/). */
+export const TEMPLATES_DIR = fileURLToPath(new URL('../../templates/orchestrate', import.meta.url));
+const FILES = {
+    implement: 'implement.md',
+    fix: 'fix.md',
+    'fix-minors': 'fix-minors.md',
+    review: 'review.md',
+    ux: 'ux.md',
+    'review-small': 'review-small.md',
+    'review-recheck': 'review-recheck.md',
+};
+/** Lit tous les gabarits du dossier. Un gabarit absent est une erreur, avant que quoi que ce soit ne parte. */
+export function loadTemplates(dir = TEMPLATES_DIR) {
+    const out = {};
+    for (const [name, file] of Object.entries(FILES)) {
+        try {
+            out[name] = readFileSync(join(dir, file), 'utf8');
+        }
+        catch (e) {
+            throw new RafError(`gabarit ${file} illisible dans ${dir} : ${e.message}`);
+        }
+    }
+    return out;
+}
+/**
+ * Rend le gabarit d'une étape par substitution de `{{nom}}`. Un nom sans valeur est une erreur.
+ * `source` : un instantané (`loadTemplates`, ce que fait une vague) ou un dossier lu à l'appel.
+ */
+export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
+    const text = typeof source === 'string' ? loadTemplates(source)[kind] : source[kind];
+    const out = text.replace(/\{\{(\w+)\}\}/g, (_m, name) => {
+        const v = vars[name];
+        if (v === undefined)
+            throw new RafError(`gabarit ${FILES[kind]} : valeur manquante pour {{${name}}}`);
+        return v;
+    });
+    // Un marqueur vide ne laisse pas de trou : lignes vides en double ramenées à une.
+    return `${out.replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim()}\n`;
+}
+/** `{{objectif}}` : le titre du lot, ses notes et ses sous-tâches — Sylvain n'écrit rien d'autre. */
+export function objective(lot) {
+    const lines = [`${lot.title}`];
+    if (lot.notes.length)
+        lines.push('', 'Notes of the lot (decisions included):', ...lot.notes.map((n) => `- ${n.date}: ${n.text}`));
+    if (lot.tasks.length)
+        lines.push('', 'Sub-tasks:', ...lot.tasks.map((t) => `- ${t.id} [${t.status}] ${t.title}`));
+    return lines.join('\n');
+}