@sylad/cadence 1.40.0 → 1.42.1

package/dist/cli/gates.js

@@ -0,0 +1,234 @@
+// Les portes : raf ux / raf review, et les trois hooks git (pre-commit, post-commit, pre-push) (L488, sorti de cli.ts).
+import { existsSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { readHookConfig, readOrchestrateConfig } from '../config.js';
+import { repoShas, resolveLotRepos } from '../repos.js';
+import { exemptPlanOnly, isPlanOnly, lotWork, ownFiles } from '../audit.js';
+import { PLAN_ACTIONS } from '../plan-commit.js';
+import { printUncommittedPlan } from '../plan-uncommitted.js';
+import { matchesHead, readCommits, stage, stagedFiles, syncIndexWithHead } from '../git.js';
+import { installHook, pendingCommitMessage, REFUSED } from '../hook.js';
+import { gateRefusal, pushRefusal, UNGATED_ENV } from '../push-guard.js';
+import { citedRefs } from '../link.js';
+import { loadEntries } from '../news.js';
+import { RafError } from '../plan.js';
+import { dueLine, isRecurring } from '../recurring.js';
+import { TITLE_MAX, truncate } from '../lead.js';
+import { waveHolding } from '../repo-busy.js';
+import { cadenceHome, waveLotsIn } from '../orchestrate/registry.js';
+import { localLotOf } from '../local-task.js';
+import { planFileIn, touchedLot } from './context.js';
+const GATES = {
+    ux: { on: 'revue UX obligatoire pour les lots visibles', already: 'revue UX déjà active', action: PLAN_ACTIONS.uxRecorded },
+    review: { on: 'revue de code obligatoire pour les lots à commits', already: 'revue de code déjà active', action: PLAN_ACTIONS.reviewRecorded },
+};
+/** « raf ux … » et « raf review … » ont la même forme : activer la porte, ou noter le verdict d'un lot. */
+function gate(kind, rest, loadPlan, root, today, io, opts) {
+    if (rest.length < 1)
+        throw new RafError(`usage : raf ${kind} enable | ${kind} <lot> "verdict"`);
+    const plan = loadPlan();
+    if (rest[0] === 'enable') {
+        const changed = kind === 'ux' ? plan.enableUx(today) : plan.enableReview(today);
+        plan.save();
+        io.out(changed ? `${GATES[kind].on} à partir du ${today}` : `${GATES[kind].already} depuis le ${kind === 'ux' ? plan.uxSince : plan.reviewSince}`);
+        return 0;
+    }
+    if (rest.length < 2)
+        throw new RafError(`usage : raf ${kind} <lot> "verdict"`);
+    // Le plan refuse lui-même une sous-tâche, un verdict vide, un lot inconnu.
+    const verdict = rest.slice(1).join(' ');
+    if (kind === 'ux')
+        plan.recordUx(rest[0], verdict, today);
+    // Le verdict vaut jusqu'au dernier commit compté du lot ; un plan en lecture seule refuse sans lire git.
+    else {
+        // Les dépôts voisins du lot : un dépôt qu'on ne peut pas lire ferait enregistrer un verdict sur un sha non lu.
+        const neighbours = plan.readonly || rest[0].includes('/') ? undefined : resolveLotRepos(root, plan.lots().find((l) => l.id === rest[0]) ?? {});
+        if (neighbours?.problems.length)
+            throw new RafError(`${neighbours.problems.join(' ; ')} — la revue de code relit aussi les dépôts du lot`);
+        plan.recordReview(rest[0], verdict, today, plan.readonly ? null : (lotWork(plan, root, rest[0])[0]?.sha ?? null), neighbours?.repos.length ? repoShas(plan, neighbours.repos, rest[0]) : undefined);
+    }
+    plan.save();
+    touchedLot(plan, rest[0], opts.verbose, io);
+    // Comme `raf done` (L371) : le plan et la copie publiée que `plan.onWrite` vient de régénérer partent dans le même commit (L509).
+    printUncommittedPlan(io.out, plan, root, rest[0], opts.commit, GATES[kind].action);
+    return 0;
+}
+/** Un titre de lot n'est jamais rendu en entier par défaut (L453) : ~300 caractères répétés à chaque commande, chaque commit de plan. */
+function shortTitle(title, verbose) {
+    return verbose ? title : truncate(title, TITLE_MAX);
+}
+/**
+ * Pre-commit : un commit qui cite un lot encore todo. `warn` (défaut) : rien ici, le post-commit avertit ; `refuse` :
+ * échoue (REFUSED) avec « raf start <id> » ; `start` : démarre le lot et met le plan dans l'index, donc dans CE commit,
+ * mais seulement si le plan est identique à HEAD : sinon rien n'est démarré (message, puis avertissement du post-commit).
+ * Ne rend REFUSED que pour un refus : toute autre panne laisse le commit passer. Sans message lisible (éditeur), rien.
+ */
+function preCommit(load, mode, root, today, io) {
+    if (!load || !mode || mode === 'warn')
+        return 0;
+    try {
+        const message = pendingCommitMessage(io.env);
+        if (message === null)
+            return 0;
+        const plan = load();
+        const [subject = '', ...body] = message.split('\n');
+        const refs = citedRefs({ sha: '', day: today, subject, body: body.join('\n').trim() }, plan.refs);
+        const staged = stagedFiles(root);
+        const own = ownFiles(plan, root);
+        // Entretien du plan : tous les fichiers du commit sont ceux du plan (la configuration seule ne compte pas).
+        if (staged.length > 0 && staged.every((f) => own.has(f) && f !== relative(root, plan.configFile ?? join(root, 'cadence.yaml'))))
+            return 0;
+        const todo = [...new Set(refs.map((r) => r.lot))].filter((id) => {
+            const lot = plan.lots().find((l) => l.id === id);
+            return lot?.status === 'todo' && !isRecurring(lot);
+        });
+        if (todo.length === 0)
+            return 0;
+        if (mode === 'refuse') {
+            for (const id of todo)
+                io.err(`raf: ${id} est encore todo — commit refusé (hook.autostart: refuse)${plan.readonly ? '' : ` : raf start ${id}`} (--no-verify pour passer outre)`);
+            return REFUSED;
+        }
+        if (plan.readonly)
+            return 0;
+        const file = relative(root, plan.path);
+        // Un plan déjà modifié (stagé ou non) : le restager emporterait ces modifications dans ce commit, ou, sur un
+        // commit partiel, les perdrait. On ne démarre rien ; le post-commit avertit comme en mode warn.
+        if (!matchesHead(root, file)) {
+            io.err(`raf: plan modifié non commité : démarrage automatique sauté (hook.autostart: start), raf start ${todo.join(' ')} à la main`);
+            return 0;
+        }
+        for (const id of todo)
+            plan.setStatus(id, 'doing', today, {});
+        try {
+            plan.save();
+        }
+        catch (e) {
+            if (!(e instanceof RafError))
+                throw e;
+            // plan.onWrite en échec (L346) : le plan est resté tel quel, le commit part sans lui et le dit.
+            io.err(`raf: démarrage automatique refusé : ${e.message} ; raf start ${todo.join(' ')} à la main`);
+            return 0;
+        }
+        for (const id of todo)
+            io.err(`raf: ${id} était todo — raf start ${id} fait par le hook, plan inclus dans ce commit`);
+        stage(root, file);
+        for (const f of plan.produced)
+            stage(root, f);
+    }
+    catch {
+        // Un hook ne doit jamais gêner un commit, hors refus.
+    }
+    return 0;
+}
+function postCommit(load, newsDir, root, today, io, mode, verbose) {
+    if (!load)
+        return 0;
+    try {
+        const plan = load();
+        if (mode === 'start' && !plan.readonly)
+            syncIndexWithHead(root, relative(root, plan.path));
+        const head = readCommits(root, { range: '-1' })[0];
+        if (!head)
+            return 0;
+        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)) {
+                io.err('raf: commit sans lot — citer un identifiant la prochaine fois (raf now)');
+            }
+            return 0;
+        }
+        const lots = new Map(plan.lots().map((l) => [l.id, l]));
+        const planning = isPlanOnly(head.sha, plan, root);
+        for (const r of refs) {
+            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
+                io.err(`raf: ${r.lot} (${lot.status}) ${shortTitle(lot.title, verbose)}`);
+        }
+        const entries = loadEntries(newsDir);
+        for (const id of new Set(refs.map((r) => r.lot))) {
+            if (lots.get(id)?.visible && !entries.some((e) => e.lots.includes(id)))
+                io.err(`raf: ${id} est visible : cadence news new ${id}`);
+        }
+    }
+    catch {
+        // Un hook ne doit jamais gêner un commit.
+    }
+    return 0;
+}
+/**
+ * `raf hook pre-push` (L405), appelé par le hook que la vague pose : refuse (code 3) un push qui emporte un commit d'un lot pas prêt de la vague vivante
+ * du dépôt, ou dont un lot pas prêt a des commits illisibles (la garde de `deliver --sha`). Puis (L426), quand le projet déclare une porte, refuse un push dont
+ * le sha de tête n'a pas de verdict vert de `cadence verify --gate` (`CADENCE_PUSH_UNGATED=1` passe outre, et le dit) ; un commit qui ne change que le plan reprend le verdict de son parent (L432). Sans vague qui tient le dépôt, ou avec un état de vague illisible
+ * (avertissement), la première garde ne gêne jamais un push ; une config illisible laisse passer la seconde.
+ */
+function prePush(root, io, remoteName, configPath, planFile) {
+    let input = '';
+    try {
+        input = io.stdin ? io.stdin() : readFileSync(0, 'utf8');
+    }
+    catch {
+        return 0;
+    }
+    const holding = waveHolding(root);
+    // Une tâche locale du lead (L519) tient le dépôt comme une vague, mais n'a pas de lots de vague : rien à vérifier pour la première garde, et pas de faux « état illisible ».
+    if (holding && !localLotOf(holding.wave)) {
+        const lots = waveLotsIn(cadenceHome(), holding.pid, root);
+        if (lots === null) {
+            io.err(`raf: vague ${holding.wave} : état illisible, push non vérifié`);
+        }
+        else {
+            const refusal = pushRefusal(root, holding.wave, lots, input, remoteName || undefined);
+            if (refusal) {
+                io.err(`raf: ${refusal}`);
+                return REFUSED;
+            }
+        }
+    }
+    // La porte du projet (L426) : une config illisible ne gêne pas un push, comme un état de vague illisible.
+    let gate = false;
+    try {
+        const config = readOrchestrateConfig(configPath);
+        gate = Boolean(config.test || config.build);
+    }
+    catch {
+        return 0;
+    }
+    const refusal = gateRefusal(root, gate, input, planFile);
+    if (!refusal)
+        return 0;
+    if (io.env[UNGATED_ENV] === '1') {
+        io.err(`raf: ${refusal.replace(/^push refusé/, 'push passé outre')} — ${UNGATED_ENV}=1 est posée`);
+        return 0;
+    }
+    io.err(`raf: ${refusal}`);
+    return REFUSED;
+}
+/** raf hook install|pre-commit|post-commit|pre-push. */
+export function cmdHook(c) {
+    const { rest, values, io, today, root, configPath, planPath, loadPlan, newsDir } = c;
+    if (rest[0] === 'install') {
+        const { path, changed } = installHook(io.cwd);
+        io.out(changed ? `hook installé : ${path}` : `hook déjà présent : ${path}`);
+        return 0;
+    }
+    if (rest[0] === 'post-commit')
+        return postCommit(existsSync(planPath) ? loadPlan : null, newsDir, root, today, io, readHookConfig(configPath).autostart, !!values.verbose);
+    if (rest[0] === 'pre-commit')
+        return preCommit(existsSync(planPath) ? loadPlan : null, readHookConfig(configPath).autostart, root, today, io);
+    if (rest[0] === 'pre-push')
+        return prePush(root, io, rest[1], configPath, planFileIn(root, planPath));
+    throw new RafError('usage : raf hook install|pre-commit|post-commit|pre-push');
+}
+/** raf ux|review : active la porte, ou note le verdict d'un lot. */
+export function cmdGate(c) {
+    const { command, rest, values, io, today, root, planConfig, loadPlan } = c;
+    return gate(command, rest, loadPlan, root, today, io, { verbose: !!values.verbose, commit: planConfig?.commit });
+}

package/dist/cli/lead-commands.js

@@ -0,0 +1,161 @@
+// Les commandes du lead : lead tour|priority|hold|release, config set (L488, sorti de cli.ts).
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { gitRoot } from '../git.js';
+import { RafError } from '../plan.js';
+import { configSet } from '../config-set.js';
+import { movePriority } from '../priority.js';
+import { findProjects, isProject, leadTour, readDepth, readLeadUx, tourFreeLine, tourLine, tourNoTestLines, tourWorktreeLines } from '../lead.js';
+import { tourMemoryLines } from '../memory-index.js';
+import { localOverdueLines } from '../local-task.js';
+import { configuredCap, expiredHoldLines, slotsLine } from '../orchestrate/command.js';
+import { addHold, cadenceHome, releaseHold } from '../orchestrate/registry.js';
+import { perfHeader } from '../perf.js';
+import { readPerf } from './stats-commands.js';
+/** Les racines git des projets du tour (la clé `depth:` du dossier, un seul niveau si elle est illisible : le tour a déjà sa ligne d'erreur). */
+function tourRoots(parent, depth) {
+    let levels = depth;
+    if (levels === undefined) {
+        try {
+            levels = readDepth(parent);
+        }
+        catch {
+            levels = 1;
+        }
+    }
+    const dirs = findProjects(parent, levels);
+    return (dirs.length === 0 && isProject(parent) ? [parent] : dirs).map((d) => gitRoot(d) ?? d);
+}
+/** Durée par défaut (minutes) d'une session du lead inscrite par `lead hold` : de quoi finir un correctif ou une revue, pas de quoi oublier la réservation toute la journée. */
+const HOLD_TTL_MINUTES = 60;
+/** Longueur maximale de l'étiquette encodée : un nom de fichier tient en 255 octets, `.json.tmp` en prend 9. */
+const HOLD_LABEL_MAX = 200;
+/** `cadence lead priority <projet> --before|--after <projet> [dossier]` (L449) : range un projet dans la liste `priority:` du cadence.yaml du dossier (celui du tour), sans modèle ni commit. */
+function leadPriority(rest, before, after, depth, io) {
+    const usage = 'usage : cadence lead priority <projet> --before|--after <projet> [dossier] [--depth n]';
+    if (rest.length < 2 || rest.length > 3 || (before === undefined) === (after === undefined))
+        throw new RafError(usage);
+    const place = before !== undefined ? 'before' : 'after';
+    const levels = depth === undefined ? undefined : Number(depth);
+    if (levels !== undefined && !(Number.isInteger(levels) && levels >= 1))
+        throw new RafError(`--depth invalide : ${depth} (un entier ≥ 1)`);
+    const parent = resolve(io.cwd, rest[2] ?? '.');
+    if (!existsSync(parent))
+        throw new RafError(`lead priority : dossier introuvable : ${parent}`);
+    const target = (before ?? after);
+    const moved = movePriority(parent, rest[1], place, target, levels);
+    io.out(moved.changed ? `${rest[1]} placé ${place === 'before' ? 'avant' : 'après'} ${target} dans priority: de ${join(parent, 'cadence.yaml')} (ordre : ${moved.order.join(' > ')}) — le fichier est modifié, à commiter` : `${rest[1]} est déjà ${place === 'before' ? 'avant' : 'après'} ${target} : rien à changer`);
+    return 0;
+}
+/** `cadence lead hold <étiquette> [--ttl minutes]` / `lead release <étiquette>` (L255) : inscrit, ou rend, une session lancée à la main par le lead, qui compte dans les créneaux libres. */
+function leadHold(rest, ttl, io, today) {
+    const [verb, label] = rest;
+    const usage = verb === 'hold' ? 'usage : cadence lead hold <étiquette> [--ttl minutes]' : 'usage : cadence lead release <étiquette>';
+    if (rest.length !== 2 || !label.trim())
+        throw new RafError(usage);
+    if (verb === 'release') {
+        if (ttl !== undefined)
+            throw new RafError(`--ttl ne va qu'avec lead hold (${usage})`);
+        io.out(releaseHold(cadenceHome(), label) ? `session « ${label} » rendue` : `aucune session « ${label} » inscrite`);
+        // ce que la libération laisse (L416) : les créneaux, les lots prêts qui peuvent les prendre, et un ⚠ tant qu'un créneau reste vide
+        const { line, free } = slotsLine(configuredCap(io.env), io.now());
+        io.out(line);
+        const ready = tourFreeLine(leadTour(resolve(io.cwd), today));
+        if (ready)
+            io.out(ready);
+        if (free > 0)
+            io.out(`⚠ ${free} ${free === 1 ? 'créneau libre' : 'créneaux libres'} sur ${configuredCap(io.env)} : lancer un lot prêt ou une session, un créneau vide ne sert à rien`);
+        return 0;
+    }
+    // le nom de fichier encode l'étiquette (6 octets par lettre accentuée) : au-delà, le système de fichiers refuse (ENAMETOOLONG)
+    if (encodeURIComponent(label).length > HOLD_LABEL_MAX)
+        throw new RafError(`étiquette trop longue (${usage})`);
+    const minutes = ttl === undefined ? HOLD_TTL_MINUTES : Number(ttl);
+    if (!(Number.isInteger(minutes) && minutes >= 1))
+        throw new RafError(`--ttl invalide : ${ttl} (un nombre entier de minutes ≥ 1)`);
+    addHold(cadenceHome(), label, minutes, io.now());
+    io.out(`session « ${label} » inscrite pour ${minutes} min : elle compte dans les créneaux libres (cadence lead release « ${label} » à sa fin)`);
+    return 0;
+}
+/** Poser une clé dans le cadence.yaml de chaque projet du dossier (L342) : ne lit ni le plan ni le cadence.yaml du dossier courant. */
+export function cmdConfig(c) {
+    const { rest, values, io, today } = c;
+    if (rest[0] !== 'set' || rest.length !== 3)
+        throw new RafError('usage : cadence config set <clé> <valeur> --all [--dry-run] [--depth n]');
+    if (!values.all)
+        throw new RafError('config set demande --all : la commande s\'applique aux projets du dossier courant (lancer la commande dans le projet visé pour un seul)');
+    if (values.depth !== undefined && !(Number.isInteger(Number(values.depth)) && Number(values.depth) >= 1))
+        throw new RafError(`--depth invalide : ${values.depth} (un entier ≥ 1)`);
+    const parent = resolve(io.cwd);
+    const result = configSet(parent, rest[1], rest[2], { dryRun: values['dry-run'], depth: values.depth === undefined ? readDepth(parent) : Number(values.depth) }, today);
+    for (const l of result.lines)
+        io.out(l);
+    return result.code;
+}
+/** cadence lead tour|priority|hold|release. Le tour parcourt les sous-dossiers (ou, sans sous-projet, prend le dossier lui-même s'il est un projet) : il ne lit pas le plan du dossier courant. */
+export function cmdLead(c) {
+    const { rest, values, io, today } = c;
+    if (rest[0] === 'hold' || rest[0] === 'release')
+        return leadHold(rest, values.ttl, io, today);
+    if (rest[0] === 'priority')
+        return leadPriority(rest, values.before, values.after, values.depth, io);
+    if (values.ttl !== undefined)
+        throw new RafError('--ttl ne va qu\'avec lead hold');
+    if (rest[0] !== 'tour' || rest.length > 2)
+        throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--depth n] [--json] | lead priority <projet> --before|--after <projet> [dossier] | lead hold <étiquette> [--ttl minutes] | lead release <étiquette>');
+    const idle = values.idle === undefined ? undefined : Number(values.idle);
+    if (idle !== undefined && !(Number.isInteger(idle) && idle >= 0))
+        throw new RafError(`--idle invalide : ${values.idle}`);
+    const depth = values.depth === undefined ? undefined : Number(values.depth);
+    if (depth !== undefined && !(Number.isInteger(depth) && depth >= 1))
+        throw new RafError(`--depth invalide : ${values.depth} (un entier ≥ 1)`);
+    const parent = resolve(io.cwd, rest[1] ?? '.');
+    if (!existsSync(parent))
+        throw new RafError(`lead tour : dossier introuvable : ${parent}`);
+    const rows = leadTour(parent, today, idle, depth);
+    if (values.json)
+        io.out(JSON.stringify(rows, null, 2));
+    else if (rows.length === 0)
+        io.out(`aucun projet sous ${parent} (.cadence/raf.yaml, docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
+    else {
+        // L'en-tête perf (L227) : un ⚠ par ligne avant les projets ; un dossier que perf ne lit pas n'en donne pas, et ses avertissements ne sont pas repris.
+        try {
+            for (const l of perfHeader(readPerf(parent, today, undefined, () => { })))
+                io.out(l);
+        }
+        catch {
+            // pas de .cadence/runs, grille de prix mal formée, journaux ou plans illisibles : le tour ne change pas
+        }
+        for (const r of rows)
+            io.out(tourLine(r));
+        // les worktrees de lot que des vagues ont conservés : aucun n'est oublié en silence (L279, R19)
+        // … puis l'index MEMORY.md du dossier, s'il pèse trop (L442) : le lead propose le regroupement, rien n'est écrit
+        for (const l of [...tourWorktreeLines(rows, io.now().getTime()), ...tourMemoryLines(io.env, parent)])
+            io.out(l);
+        // un projet sans orchestrate.test : la vague ne lancera pas la suite (L327)
+        for (const l of tourNoTestLines(rows))
+            io.out(l);
+        // les créneaux libres viennent du registre, le lead les lit au lieu de les calculer (L141)
+        // toujours imprimés, même sans vague ni session du lead (L416) : un créneau vide se lit, il ne se déduit pas d'une ligne absente
+        io.out(slotsLine(configuredCap(io.env), io.now()).line);
+        // en face des créneaux libres, les lots prêts dont aucune ressource n'est prise (L252)
+        const free = tourFreeLine(rows);
+        if (free)
+            io.out(free);
+        // une session du lead dont le TTL est échu (L278) : rien ne l'arrête, le tour la signale (hors --json, comme les créneaux)
+        // … et une tâche locale (L519) au-delà de son délai : le dépôt reste verrouillé, le tour le dit au lieu de le libérer en silence
+        for (const l of [...expiredHoldLines(io.now()), ...localOverdueLines(tourRoots(parent, depth), io.now())])
+            io.out(l);
+        // le réglage lead.ux du cadence.yaml du dossier (L197) : le lead lit ici qui pose le verdict UX, au lieu d'ouvrir le fichier
+        try {
+            if (readLeadUx(parent) === 'lead')
+                io.out('verdict UX : lead (le lead pose raf ux d\'après le rapport du ux-reviewer et les captures ; l\'humain n\'est consulté qu\'en cas de doute)');
+        }
+        catch (e) {
+            // un cadence.yaml illisible a déjà sa ligne d'erreur en tête de tour
+            if (/lead\.ux/.test(e.message))
+                io.out(`cadence.yaml · ✗ erreur : ${e.message.replace(/^.*cadence\.yaml : /, '')}`);
+        }
+    }
+    return 0;
+}

package/dist/cli/lot-commands.js

@@ -0,0 +1,257 @@
+// Les commandes qui écrivent le plan, un lot à la fois (L488, sorti de cli.ts).
+import { relative, resolve } from 'node:path';
+import { refuseRedAcceptation } from '../raf-close-checks.js';
+import { statusCommand } from '../raf-status.js';
+import { PLAN_LEGACY } from '../config.js';
+import { audit, isNonConformingVerdict, lotWork, planCommits, unreviewedWork } from '../audit.js';
+import { short } from '../check.js';
+import { isDay } from '../dates.js';
+import { PLAN_ACTIONS } from '../plan-commit.js';
+import { printUncommittedPlan } from '../plan-uncommitted.js';
+import { resolveCommit } from '../git.js';
+import { loadEntries } from '../news.js';
+import { addLot } from '../cli-add.js';
+import { RafError, SCREENS } from '../plan.js';
+import { warnIntegrating, warnWaveWorking, waveHolding } from '../repo-busy.js';
+import { knownLot, touchedLot } from './context.js';
+/** raf add "titre" : ajoute un lot ou une sous-tâche. */
+export function cmdAdd(c) {
+    const { rest, values, io, today, root, loadPlan, refuseLongTitle, need } = c;
+    need(1, 'add "titre"');
+    const plan = loadPlan();
+    const id = addLot(plan, values, rest.join(' '), today, refuseLongTitle);
+    plan.save();
+    io.out(id);
+    warnIntegrating(root, io.err);
+    warnWaveWorking(root, io.env, io.err);
+    return 0;
+}
+/** raf start|done|drop <id> : pose le statut du lot, sous les refus de la porte de revue, de l'acceptation et du titre public. */
+export function cmdSetStatus(c) {
+    const { rest, values, io, today, root, configPath, planConfig, loadPlan, newsDir, refuseLongTitle, need, command } = c;
+    need(1, `${command} <id>`);
+    const plan = loadPlan();
+    const status = command === 'start' ? 'doing' : command === 'done' ? 'done' : 'dropped';
+    // Le titre public part au site : un titre au-delà de la limite déclarée y ferait échouer le build.
+    if (status === 'done' && !rest[0].includes('/')) {
+        const lot = plan.lots().find((l) => l.id === rest[0]);
+        // Sans public: d'un lot visible, le site reprend le titre de sa Nouveauté la plus récente.
+        const pub = lot?.public ?? (lot?.visible ? loadEntries(newsDir).find((e) => e.lots.includes(lot.id))?.title : undefined);
+        if (pub)
+            refuseLongTitle(pub, lot?.public ? '' : ' — titre de la Nouveauté reprise par le site : corriger l\'entrée ou poser raf public');
+    }
+    // Le plan ne lit pas git : lui dire combien de commits du lot sa revue ne couvre pas quand elle est exigée.
+    if (status === 'done' && !rest[0].includes('/'))
+        refuseRedAcceptation(root, configPath, rest[0], !!values.force, io.err);
+    const unreviewed = status === 'done' && plan.reviewSince && !plan.readonly && !values.force ? unreviewedWork(plan, root, rest[0]) : 0;
+    const verdict = status === 'done' && !rest[0].includes('/') ? plan.lots().find((l) => l.id === rest[0])?.review?.verdict : undefined;
+    const nonConforming = verdict !== undefined && isNonConformingVerdict(verdict);
+    plan.setStatus(rest[0], status, today, { force: values.force, unreviewed, nonConforming });
+    if (command === 'drop' && values.reason)
+        plan.note(rest[0], `abandonné : ${values.reason}`, today);
+    plan.save();
+    io.out(`${rest[0]} → ${status}`);
+    if (status === 'done') {
+        warnIntegrating(root, io.err);
+        warnWaveWorking(root, io.env, io.err);
+    }
+    touchedLot(plan, rest[0], values.verbose, io);
+    if (status === 'done' && !rest[0].includes('/')) {
+        const lot = plan.lot(rest[0]);
+        if (lot.visible && !loadEntries(newsDir).some((e) => e.lots.includes(lot.id))) {
+            io.out(`${lot.id} est visible : écrire l'entrée : cadence news new ${lot.id}`);
+        }
+        printUncommittedPlan(io.out, plan, root, lot.id, planConfig?.commit);
+    }
+    return 0;
+}
+/** raf archive : déplace les lots clos vers .cadence/archive/. */
+export function cmdArchive(c) {
+    const { values, io, today, root, planConfig, planPath, loadPlan, newsDir } = c;
+    if (values.before !== undefined && !isDay(values.before))
+        throw new RafError(`--before invalide : ${values.before} (attendu AAAA-MM-JJ)`);
+    // L'archive vit à côté du plan : à l'ancien emplacement, elle irait sous docs/ (publié) et raf migrate ne la déplacerait pas — migrer d'abord.
+    if (planPath === resolve(root, PLAN_LEGACY))
+        throw new RafError(`raf archive refusé : le plan est à l'ancien emplacement ${PLAN_LEGACY}, l'archive irait sous docs/ — le déplacer d'abord : raf migrate`);
+    const dry = !!values['dry-run'];
+    const plan = loadPlan();
+    // Un lot clos qui a encore un écart (revue, UX, docs.sync, Nouveauté… ce que `raf check` signale) reste dans le plan, avec l'écart pour raison.
+    const issues = audit(plan, root, newsDir, today);
+    const blocked = (lot) => issues.find((i) => plan.refs(i.message).some((r) => r.lot === lot.id))?.message ?? null;
+    const { moved, kept } = plan.archive(today, { before: values.before, dryRun: dry, blocked: (lot) => (blocked(lot) ? `écart ouvert — ${blocked(lot)}` : null) });
+    const files = [...new Set(moved.map((m) => m.file))];
+    for (const f of files) {
+        const ids = moved.filter((m) => m.file === f).map((m) => m.lot.id);
+        io.out(`${dry ? 'à archiver' : 'archivé'} dans ${relative(io.cwd, f)} : ${ids.join(', ')}`);
+    }
+    for (const k of kept)
+        io.out(`${k.id} reste dans le plan : ${k.why}`);
+    if (moved.length === 0)
+        io.out('rien à archiver');
+    else if (!dry) {
+        if (plan.republishes)
+            io.err('raf: plan.onWrite republie le fichier du plan sans les lots archivés : le générateur de la copie publiée doit aussi lire .cadence/archive/*.yaml (clé `lots`), sinon l\'historique livré disparaît de la feuille de route publique');
+        printUncommittedPlan(io.out, plan, root, moved[0].lot.id, planConfig?.commit, PLAN_ACTIONS.archived(moved.length));
+    }
+    return 0;
+}
+/** raf todo <id> : remet en attente un lot démarré sans commit de travail, ou rouvre un lot clos. */
+export function cmdTodo(c) {
+    const { rest, values, io, today, root, loadPlan, need } = c;
+    need(1, 'todo <id> [--reason texte]');
+    const plan = loadPlan();
+    plan.putBack(rest[0], today, values.reason ?? '', () => lotWork(plan, root, rest[0]).length);
+    plan.save();
+    io.out(`${rest[0]} → todo`);
+    return 0;
+}
+/** raf note <id> "texte". */
+export function cmdNote(c) {
+    const { rest, values, io, today, root, loadPlan, need } = c;
+    need(2, 'note <id> "texte"');
+    const plan = loadPlan();
+    plan.note(rest[0], rest.slice(1).join(' '), today);
+    plan.save();
+    warnIntegrating(root, io.err);
+    warnWaveWorking(root, io.env, io.err);
+    touchedLot(plan, rest[0], values.verbose, io);
+    return 0;
+}
+/** raf did <id> : un lot récurrent a été refait. */
+export function cmdDid(c) {
+    const { rest, io, today, loadPlan, need } = c;
+    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;
+}
+/** raf title <id> "titre" : remplace le titre d'un lot. */
+export function cmdTitle(c) {
+    const { rest, today, loadPlan, need } = c;
+    need(2, 'title <id> "nouveau titre"');
+    const plan = loadPlan();
+    plan.setTitle(rest[0], rest.slice(1).join(' '), today);
+    plan.save();
+    return 0;
+}
+/** raf uses <lot> [<ressource>…] : remplace les ressources partagées du lot. */
+export function cmdUses(c) {
+    const { rest, loadPlan, need } = c;
+    need(1, 'uses <lot> [<ressource>…]');
+    const plan = loadPlan();
+    plan.setUses(rest[0], rest.slice(1));
+    plan.save();
+    return 0;
+}
+/** raf move <id> --before|--after <id> : réordonne un lot dans le plan. */
+export function cmdMove(c) {
+    const { rest, values, io, root, loadPlan } = c;
+    // Une seule position : --before ou --after, avec une cible (« after » est aussi le drapeau de « add », « before » celui de « archive »).
+    const place = values.before !== undefined && values.after === undefined ? 'before' : values.after !== undefined && values.before === undefined ? 'after' : null;
+    if (rest.length !== 1 || !place)
+        throw new RafError('usage : raf move <id> --before <id> | raf move <id> --after <id>');
+    const plan = loadPlan();
+    plan.move(rest[0], place, values[place]); // en mémoire : les refus de la commande (plan en lecture seule, parent, archive) passent avant celui de la vague
+    // Un lot de la vague s'appuie sur l'ordre du plan qu'il a lu : le réordonner sous ses pieds est refusé tant que la vague tient le dépôt.
+    const holding = waveHolding(root, 'move');
+    if (holding)
+        throw new RafError(`move : orchestration en cours (vague ${holding.wave}, pid ${holding.pid}) — attendre que les lots de ce dépôt soient finis (le verrou tombe dès que tous sont prêts ou rendus), puis relancer`);
+    plan.save();
+    touchedLot(plan, rest[0], values.verbose, io);
+    return 0;
+}
+/** raf public <id> "titre public" | --clear. */
+export function cmdPublic(c) {
+    const { rest, values, io, loadPlan, refuseLongTitle, need } = c;
+    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();
+    if (!values.clear)
+        refuseLongTitle(rest.slice(1).join(' '));
+    plan.setPublic(rest[0], values.clear ? null : rest.slice(1).join(' '));
+    plan.save();
+    touchedLot(plan, rest[0], values.verbose, io);
+    return 0;
+}
+/** raf screen <id> page|component|journey|none. */
+export function cmdScreen(c) {
+    const { rest, loadPlan, need } = c;
+    need(2, 'screen <id> page|component|journey|none');
+    if (rest.length > 2)
+        throw new RafError('usage : raf screen <id> page|component|journey|none');
+    const plan = loadPlan();
+    if (rest[1] !== 'none' && !SCREENS.includes(rest[1]))
+        throw new RafError(`screen inconnu : ${rest[1]} (${SCREENS.join(', ')}, none)`);
+    plan.setScreen(rest[0], rest[1] === 'none' ? null : rest[1]);
+    plan.save();
+    return 0;
+}
+/** raf estimate <id> <jours>. */
+export function cmdEstimate(c) {
+    const { rest, loadPlan } = c;
+    if (rest.length !== 2)
+        throw new RafError('usage : raf estimate <id> <jours>');
+    const plan = loadPlan();
+    if (!/^\d+(\.\d+)?$/.test(rest[1].trim()))
+        throw new RafError(`estimation invalide : ${rest[1]} (un nombre de jours > 0)`);
+    plan.setEstimate(rest[0], Number(rest[1]));
+    plan.save();
+    return 0;
+}
+/** raf visible <id> on|off. */
+export function cmdVisible(c) {
+    const { rest, loadPlan } = c;
+    if (rest.length !== 2 || (rest[1] !== 'on' && rest[1] !== 'off'))
+        throw new RafError('usage : raf visible <id> on|off');
+    const plan = loadPlan();
+    plan.setVisible(rest[0], rest[1] === 'on');
+    plan.save();
+    return 0;
+}
+/** raf ignore <sha> | "<sujet exact>" : acquitte un commit sans lot. */
+export function cmdIgnore(c) {
+    const { rest, values, io, today, root, loadPlan, need } = c;
+    need(1, 'ignore <sha> | "<sujet exact>" [--reason texte]');
+    if (rest.length > 1)
+        throw new RafError('un seul commit attendu ; la raison se passe par --reason "texte"');
+    const plan = loadPlan();
+    const arg = rest[0];
+    const commits = planCommits(plan, root);
+    // Un sujet exact l'emporte sur un nom de ref homonyme (`other` à la fois sujet et branche).
+    const sha = commits.some((c) => c.subject === arg) ? null : resolveCommit(root, arg);
+    const found = sha ? commits.find((c) => c.sha === sha) : commits.find((c) => c.subject === arg);
+    if (!found)
+        throw new RafError(`aucun commit ne correspond à « ${arg} » (sha ou sujet exact)`);
+    // Un sha est exact ; un sujet vaut pour tous les commits qui le portent.
+    const bySha = sha !== null;
+    plan.acknowledge({ ...(bySha ? { sha: found.sha, subject: found.subject } : { subject: found.subject }), date: today, ...(values.reason ? { reason: values.reason } : {}) });
+    plan.save();
+    io.out(`${bySha ? short(found) : found.subject} acquitté`);
+    return 0;
+}
+/** raf docs-ok <lot> --reason texte : acquitte l'écart docs.sync d'un lot. */
+export function cmdDocsOk(c) {
+    const { rest, values, io, today, loadPlan, need } = c;
+    need(1, 'docs-ok <lot> --reason texte');
+    if (rest.length > 1)
+        throw new RafError('un seul lot attendu ; la raison se passe par --reason "texte"');
+    const plan = loadPlan();
+    knownLot(plan, rest[0], 'docs-ok se pose sur un lot, pas sur une sous-tâche');
+    plan.setDocsOk(rest[0], values.reason ?? '', today);
+    // Un plan en lecture seule n'est pas écrit : l'acquittement est dans .cadence/docs-ok.yaml, à commiter à la place du plan (L386).
+    if (plan.readonly)
+        io.out(`${rest[0]} : écart docs.sync acquitté dans .cadence/docs-ok.yaml (le plan n'est pas touché) — commiter ce fichier`);
+    else {
+        plan.save();
+        io.out(`${rest[0]} : écart docs.sync acquitté`);
+    }
+    return 0;
+}
+/** raf status : les états détaillés du projet, ou la pose de l'état d'un lot. */
+export function cmdStatus(c) {
+    const { rest, values, io, today, root, loadPlan } = c;
+    return statusCommand(loadPlan(), rest, { back: !!values.back, today, out: io.out, commits: (p, id) => lotWork(p, root, id).length });
+}