@sylad/cadence 1.40.0 → 1.42.1

package/dist/cli/read-commands.js

@@ -0,0 +1,227 @@
+// Les commandes qui lisent le plan et l'historique : commits, show, list, now, check, gantt, news (L488, sorti de cli.ts).
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { readOrchestrateConfig } from '../config.js';
+import { repoSections } from '../repos.js';
+import { lotJson, lotLines } from '../lot-lines.js';
+import { audit, gateWaiting, hypothesesOf, lotWork, nextUp, planCommits, workByLot } from '../audit.js';
+import { short } from '../check.js';
+import { toDay } from '../dates.js';
+import { ganttData, renderGantt } from '../gantt.js';
+import { linkCommits } from '../link.js';
+import { buildNews, loadEntries, newEntry, newsData, newsIssues, stampEntries } from '../news.js';
+import { RafError, STATUSES } from '../plan.js';
+import { dueLine, recurringByDue } from '../recurring.js';
+import { schedule } from '../schedule.js';
+import { coverageCommand } from '../ref/coverage.js';
+import { knownLot } from './context.js';
+function describe(l, commits) {
+    const bits = [`${l.estimate} j`];
+    if (commits)
+        bits.push(`${commits} commit(s)`);
+    if (l.tasks.length)
+        bits.push(`sous-tâches ${l.tasks.filter((t) => t.status === 'done').length}/${l.tasks.length}`);
+    return `${l.quickwin ? '⚡ ' : ''}${l.id}  ${l.title}  (${bits.join(', ')})`;
+}
+function now(plan, root, newsDir, today, io) {
+    const lots = plan.lots();
+    const linked = linkCommits(lots, planCommits(plan, root), plan.refs);
+    const { doing, ready, blocked } = nextUp(lots);
+    const work = workByLot(plan, root, linked, [...doing, ...ready.slice(0, 5)].map((l) => l.id));
+    const count = (id) => work.get(id)?.length ?? 0;
+    io.out(`${plan.project} — ${today}`);
+    io.out('\nEn cours');
+    if (doing.length === 0)
+        io.out('  (rien)');
+    for (const l of doing)
+        io.out(`  ${describe(l, count(l.id))}`);
+    io.out('\nÀ suivre');
+    if (ready.length === 0)
+        io.out('  (rien de prêt)');
+    for (const l of ready.slice(0, 5))
+        io.out(`  ${describe(l, count(l.id))}`);
+    if (ready.length > 5)
+        io.out(`  … et ${ready.length - 5} autre(s)`);
+    const gated = gateWaiting(lots, blocked);
+    const byDeps = blocked.filter((l) => !gated.some((g) => g.lot === l));
+    if (byDeps.length)
+        io.out(`  en attente de dépendances : ${byDeps.map((l) => l.id).join(', ')}`);
+    if (gated.length)
+        io.out(`  en attente de condition de tirage : ${gated.map((g) => `${g.lot.id} (${g.text})`).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))
+        .slice(0, 3);
+    if (done.length) {
+        io.out('\nTerminés récemment');
+        for (const l of done)
+            io.out(`  ${l.id}  ${l.title}  (${l.finished})`);
+    }
+    const issues = audit(plan, root, newsDir, today).filter((i) => !i.warning);
+    if (issues.length)
+        io.out(`\n${issues.length} écart(s) entre le plan et l'historique — raf check`);
+    return 0;
+}
+function news([sub, ...args], plan, dir, today, values, io, refuseLongTitle, hypotheses) {
+    const lots = plan.lots();
+    switch (sub) {
+        case 'new': {
+            if (args.length === 0)
+                throw new RafError('usage : cadence news new <lot…> [--title t]');
+            for (const id of args)
+                plan.lot(id);
+            // Mesuré comme newEntry l'écrit : espaces fusionnés.
+            const title = (values.title ?? plan.lot(args[0]).public ?? plan.lot(args[0]).title).replace(/\s+/g, ' ').trim();
+            refuseLongTitle(title, values.title === undefined ? ' — donner un titre court : cadence news new <lot> --title "…"' : '');
+            io.out(newEntry(dir, args, title, today, io.now()));
+            return 0;
+        }
+        case 'stamp': {
+            const stamped = stampEntries(dir, io.now());
+            for (const s of stamped)
+                io.out(`${s.file}  created: ${s.created}`);
+            if (stamped.length === 0)
+                io.out('✓ toutes les entrées ont une heure de création');
+            return 0;
+        }
+        case 'list':
+            for (const e of loadEntries(dir))
+                io.out(`${e.date}  ${e.title}  (${e.lots.join(', ')})`);
+            return 0;
+        case 'check':
+        case 'build': {
+            const entries = loadEntries(dir);
+            const issues = newsIssues(lots, entries, dir, sub === 'check' ? hypotheses() : undefined);
+            for (const i of issues)
+                io.out(`✗ ${i.message}`);
+            // Le build refuse seulement ce qu'il ne saurait pas publier : entrée illisible, capture absente.
+            const blocking = sub === 'check' ? issues : issues.filter((i) => i.kind === 'bad-entry' || i.kind === 'missing-capture');
+            if (sub === 'check')
+                io.out(issues.length === 0 ? '✓ Nouveautés cohérentes avec le plan' : `${issues.length} écart(s)`);
+            if (blocking.length > 0)
+                return 1;
+            if (sub === 'build') {
+                const stamp = io.now();
+                const data = newsData(plan.project, entries, `${toDay(stamp)} ${stamp.toTimeString().slice(0, 5)}`);
+                for (const f of buildNews(data, dir, resolve(io.cwd, values.output ?? join(dir, 'site'))))
+                    io.out(f);
+            }
+            return 0;
+        }
+        default:
+            throw new RafError('usage : cadence news new|list|check|stamp|build');
+    }
+}
+/** raf commits <lot> : les commits que compte la porte de revue. */
+export function cmdCommits(c) {
+    const { rest, io, root, loadPlan, need } = c;
+    need(1, 'commits <lot>');
+    const plan = loadPlan();
+    const id = rest[0];
+    knownLot(plan, id, 'les commits se listent par lot, pas par sous-tâche');
+    // Une lecture : le même ensemble que « raf done » et « raf check », plan en lecture seule compris.
+    for (const c of lotWork(plan, root, id).reverse())
+        io.out(short(c));
+    for (const line of repoSections(plan, root, plan.lot(id)))
+        io.out(line);
+    return 0;
+}
+/** raf show <lot> [--notes]. */
+export function cmdShow(c) {
+    const { rest, values, io, root, loadPlan, need } = c;
+    need(1, 'show <lot> [--notes]');
+    const plan = loadPlan();
+    const lot = knownLot(plan, rest[0], 'show se lit par lot, pas par sous-tâche');
+    const notes = lot.notes.map((n) => `${n.date}  ${n.text}`);
+    if (values.notes) {
+        for (const n of notes)
+            io.out(n);
+        return 0;
+    }
+    for (const line of lotLines(plan, lot))
+        io.out(line);
+    if (notes.length) {
+        io.out('notes :');
+        // Les lignes suivantes d'une note multiligne s'alignent sous son texte, pas en colonne 0.
+        for (const n of lot.notes)
+            io.out(`  ${n.date}  ${n.text.replace(/\n/g, `\n${' '.repeat(n.date.length + 4)}`)}`);
+    }
+    const commits = lotWork(plan, root, lot.id).reverse();
+    io.out(`commits (${commits.length}) :`);
+    for (const c of commits)
+        io.out(`  ${short(c)}`);
+    for (const line of repoSections(plan, root, lot, '  '))
+        io.out(line);
+    return 0;
+}
+/** raf list [--status s] [--json]. */
+export function cmdList(c) {
+    const { values, io, loadPlan } = c;
+    const plan = loadPlan();
+    if (values.status && !STATUSES.includes(values.status))
+        throw new RafError(`statut inconnu : ${values.status}`);
+    const shown = plan.lots().filter((l) => !values.status || l.status === values.status);
+    if (values.json)
+        io.out(JSON.stringify(shown.map(lotJson), null, 2));
+    else
+        for (const l of shown)
+            io.out(`${l.id.padEnd(6)} ${l.status.padEnd(8)} ${l.quickwin ? '⚡ ' : ''}${l.title}`);
+    return 0;
+}
+/** raf check : les écarts entre le plan et l'historique, code 1 s'il y en a. */
+export function cmdCheck(c) {
+    const { values, io, today, root, loadPlan, newsDir } = c;
+    if (values.ignored) {
+        const list = loadPlan().acknowledged;
+        if (list.length === 0)
+            io.out('aucun commit acquitté');
+        for (const a of list)
+            io.out(`${a.sha ? a.sha.slice(0, 7) : 'sujet  '} ${a.subject ?? ''}  (${a.date}${a.reason ? ` — ${a.reason}` : ''})`);
+        return 0;
+    }
+    const idle = values.idle === undefined ? 7 : Number(values.idle);
+    if (!Number.isInteger(idle) || idle < 0)
+        throw new RafError(`--idle invalide : ${values.idle}`);
+    const issues = audit(loadPlan(), root, newsDir, today, { since: values.since, idle });
+    for (const i of issues)
+        io.out(`${i.warning ? '⚠' : '✗'} ${i.message}`);
+    // Un avertissement s'affiche mais ne fait pas échouer : seuls les écarts comptent pour le code de sortie.
+    const errors = issues.filter((i) => !i.warning).length;
+    const warnings = issues.length - errors;
+    io.out(errors === 0 ? `✓ plan et historique cohérents${warnings ? ` (${warnings} avertissement(s))` : ''}` : `${errors} écart(s)${warnings ? `, ${warnings} avertissement(s)` : ''}`);
+    return errors === 0 ? 0 : 1;
+}
+/** raf gantt [-o fichier] : la page Gantt du plan. */
+export function cmdGantt(c) {
+    const { values, io, today, root, planPath, loadPlan } = c;
+    const plan = loadPlan();
+    const lots = plan.lots();
+    const linked = linkCommits(lots, planCommits(plan, root), plan.refs);
+    const stamp = io.now();
+    const html = renderGantt(ganttData(plan.project, schedule(lots, workByLot(plan, root, linked), today), today, `${toDay(stamp)} ${stamp.toTimeString().slice(0, 5)}`));
+    const out = resolve(io.cwd, values.output ?? join(dirname(planPath), 'gantt.html'));
+    mkdirSync(dirname(out), { recursive: true });
+    writeFileSync(out, html);
+    io.out(out);
+    return 0;
+}
+/** raf now : ce qui est en cours, la suite, les derniers terminés. */
+export function cmdNow(c) {
+    return now(c.loadPlan(), c.root, c.newsDir, c.today, c.io);
+}
+/** raf news … : les entrées Nouveautés. */
+export function cmdNews(c) {
+    const { rest, values, io, today, root, configPath, loadPlan, newsDir, refuseLongTitle } = c;
+    return news(rest, loadPlan(), newsDir, today, values, io, refuseLongTitle, () => hypothesesOf(root, configPath));
+}
+/** cadence ref coverage lit le plan (les lots faits qui citent les éléments) : il passe après le choix du plan, les autres ref n'y touchent pas (L367). */
+export function cmdRef(c) {
+    const { rest, io, root, configPath, loadPlan } = c;
+    return coverageCommand(rest.slice(1), loadPlan, io, { repo: root, specDir: readOrchestrateConfig(configPath).spec.dir });
+}

package/dist/cli/session-commands.js

@@ -0,0 +1,152 @@
+// session start|close|next|context, et leur variante --all (L488, sorti de cli.ts).
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { readSessionConfig } from '../config.js';
+import { parseDeliverConfig } from '../deliver.js';
+import { defaultTarget, effectLines, realCheckDeps } from '../verify.js';
+import { gitRoot } from '../git.js';
+import { RafError } from '../plan.js';
+import { closeMemoryLines } from '../memory-index.js';
+import { findLeadDir, findProjects, readLeadContextThreshold } from '../lead.js';
+import { readHudContext } from '../hud-context.js';
+import { sessionClose, sessionStart } from '../session.js';
+import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from '../state.js';
+/**
+ * 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 target = defaultTarget(root, config);
+        return effectLines(config, target.sha, realCheckDeps(root, { quiet: true }), target.note);
+    }
+    catch (e) {
+        return [`✗ ${e.message}`];
+    }
+}
+/** `session start|close --all [--depth n]` : la commande jouée dans chaque projet sous le dossier courant, une section par projet. */
+async function sessionAll(rest, values, io, run) {
+    const sub = rest[0];
+    if (!values.all)
+        throw new RafError('--depth demande --all');
+    // Chaque projet lit son propre plan : un plan ou une config imposés se retrouveraient dans toutes les sections.
+    const imposed = values.file !== undefined ? '--file' : values.config !== undefined ? '--config' : io.env.RAF_FILE !== undefined ? 'RAF_FILE' : null;
+    if (imposed)
+        throw new RafError(`${imposed} ne va pas avec --all : chaque projet lit son propre plan (lancer la commande dans le projet visé)`);
+    if (sub !== 'start' && sub !== 'close')
+        throw new RafError('--all ne va qu\'avec session start ou session close');
+    const depth = values.depth === undefined ? 1 : Number(values.depth);
+    if (!Number.isInteger(depth) || depth < 1)
+        throw new RafError(`--depth invalide : ${values.depth} (un entier ≥ 1)`);
+    if (values.idle !== undefined && !(Number.isInteger(Number(values.idle)) && Number(values.idle) >= 0))
+        throw new RafError(`--idle invalide : ${values.idle}`);
+    const projects = findProjects(io.cwd, depth);
+    if (projects.length === 0) {
+        io.out(`aucun projet sous ${io.cwd} (.cadence/raf.yaml, docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
+        return 0;
+    }
+    const argv = ['session', sub, ...(values.since === undefined ? [] : [`--since=${values.since}`]), ...(values.idle === undefined ? [] : ['--idle', values.idle])];
+    let worst = 0;
+    for (const dir of projects) {
+        io.out(`${dir === projects[0] ? '' : '\n'}## ${relative(io.cwd, dir)}`);
+        let code;
+        const top = gitRoot(dir);
+        if (top && realpathSync(top) !== realpathSync(dir)) {
+            // run() lirait le plan du dépôt parent : mieux vaut le dire que montrer le plan d'un autre projet.
+            io.out(`✗ ${relative(io.cwd, dir)} n'a pas son propre dépôt git (dépôt parent : ${top}) — lancer cadence dans ce dossier`);
+            worst = 2;
+            continue;
+        }
+        try {
+            code = await run(argv, { ...io, cwd: dir, err: (l) => io.out(`✗ ${l}`), notice: io.notice ?? io.err });
+        }
+        catch (e) {
+            io.out(`✗ ${e instanceof Error ? e.message : String(e)}`);
+            code = 2;
+        }
+        worst = Math.max(worst, code);
+    }
+    return worst;
+}
+/** Le contexte (et sa position par rapport à `lead.contextThreshold`, en tokens) de la session de `--session <id>`, sinon de `CLAUDE_CODE_SESSION_ID`, sinon (variable absente) de la seule session du dossier courant, tel que la bande cadence-hud le publie ; illisible = code 2, à lire comme « au seuil ». */
+function sessionContext(io, session) {
+    const r = readHudContext(io.env, io.now().getTime(), { cwd: io.cwd, session });
+    if (!r.ok)
+        throw new RafError(`session context : contexte illisible — ${r.reason} ; à traiter comme au seuil`);
+    io.out(`ctx ${Math.round(r.ctx.percent)} % (${r.ctx.tokens}/${r.ctx.window})`);
+    // Lancée d'un sous-projet, la commande lit le cadence.yaml du dossier du lead (L457) et nomme le dossier lu.
+    const leadDir = findLeadDir(io.cwd);
+    const threshold = readLeadContextThreshold(leadDir);
+    io.out(`seuil ${threshold} tokens : ${r.ctx.tokens >= threshold ? 'atteint' : 'sous le seuil'}${leadDir === io.cwd ? '' : ` (lu dans ${join(leadDir, 'cadence.yaml')})`}`);
+    return 0;
+}
+function session([sub, ...args], ctx, values) {
+    switch (sub) {
+        case 'start': {
+            const idle = values.idle === undefined ? 2 : Number(values.idle);
+            if (!Number.isInteger(idle) || idle < 0)
+                throw new RafError(`--idle invalide : ${values.idle}`);
+            return sessionStart(ctx, { since: values.since ?? '24 hours ago', idle });
+        }
+        case 'close':
+            return sessionClose(ctx, { since: values.since });
+        case 'next': {
+            const lines = args.filter((l) => l.trim() !== '');
+            if (values.clear) {
+                if (lines.length)
+                    throw new RafError('session next --clear efface les notes : ne pas lui passer de ligne');
+                const gone = clearNext(ctx.state);
+                ctx.out(gone ? `notes effacées (${gone.lines.length} ligne(s) du ${gone.date})` : 'aucune note à effacer');
+                return 0;
+            }
+            // Lancée sans ligne (variable vide dans un script, agent pressé), la commande effaçait en silence
+            // les notes de la dernière clôture : effacer se demande exprès.
+            if (lines.length === 0) {
+                const kept = readNext(ctx.state);
+                throw new RafError(`session next : aucune ligne — ${kept ? `${kept.lines.length} ligne(s) du ${kept.date} conservée(s)` : "rien n'est écrit"} ; ` +
+                    'usage : cadence session next "ligne" … (pour effacer les notes exprès : cadence session next --clear)');
+            }
+            writeNext(ctx.state, ctx.today, lines);
+            // Rien sur stdout laissait croire à un échec : on redit les lignes telles qu'enregistrées, pour que
+            // session-close les rapporte sans relancer session start.
+            const n = lines.length;
+            ctx.out(`${n} ligne${n > 1 ? 's' : ''} enregistrée${n > 1 ? 's' : ''} pour la prochaine ouverture\n${lines.map((l) => `  - ${l}`).join('\n')}`);
+            return 0;
+        }
+        default:
+            throw new RafError('usage : cadence session start [--since …] [--idle 2] | close [--since …] | start|close --all [--depth n] | next "ligne" … | next --clear | context [--session id]');
+    }
+}
+/** cadence session start|close|next|context. */
+export function cmdSession(c) {
+    const { rest, values, io, today, root, configPath, loadPlan, newsDir } = c;
+    // Le contexte de la session ne dépend d'aucun dépôt : le lead le lit depuis le dossier parent.
+    if (rest[0] === 'context')
+        return sessionContext(io, values.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 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, now: io.now(), out: io.out, facts, clean, memory: closeMemoryLines(io.env, io.cwd, configPath) };
+    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));
+}
+/** `--all` balaie les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant ; null sans --all ni --depth. */
+export function cmdSessionAll(c, run) {
+    return c.values.all || c.values.depth !== undefined ? sessionAll(c.rest, c.values, c.io, run) : null;
+}

package/dist/cli/setup-commands.js

@@ -0,0 +1,72 @@
+// Installer et déplacer : init, skills, migrate (L488, sorti de cli.ts).
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { gitRoot } from '../git.js';
+import { installHook } from '../hook.js';
+import { Plan, RafError } from '../plan.js';
+import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from '../skills.js';
+import { applyMigration, describeMigration, planMigration, unhandledError } from '../migrate.js';
+/** Ajoute `line` au .gitignore de `root` s'il n'y est pas déjà (avec ou sans `/` initial ou final). Rend vrai si écrit. */
+export function ensureGitignore(root, line) {
+    const file = join(root, '.gitignore');
+    const text = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    const norm = (l) => l.trim().replace(/^\//, '').replace(/\/$/, '');
+    if (text.split('\n').some((l) => norm(l) === norm(line)))
+        return false;
+    writeFileSync(file, `${text}${text === '' || text.endsWith('\n') ? '' : '\n'}${line}\n`);
+    return true;
+}
+/** raf init : crée le plan, le dossier des notes, le .gitignore et le hook. */
+export function cmdInit(c) {
+    const { values, io, today, root, configPath, planConfig, planPath, chosen } = c;
+    if (planConfig?.settings.format)
+        throw new RafError(`plan en lecture seule : ${configPath} décrit un plan tenu par un autre outil`);
+    const plan = Plan.create(planPath, values.project ?? basename(root), values.prefix ?? 'L', today);
+    io.out(`plan créé : ${plan.path}`);
+    if (chosen === undefined) {
+        mkdirSync(join(root, '.cadence/notes'), { recursive: true });
+        writeFileSync(join(root, '.cadence/notes/.gitkeep'), '');
+    }
+    if (ensureGitignore(root, '.playwright-mcp/'))
+        io.out('.gitignore : .playwright-mcp/');
+    if (!values['no-hook'] && gitRoot(io.cwd))
+        io.out(`hook : ${installHook(io.cwd).path}`);
+    return 0;
+}
+/** cadence skills install : skills et agents dans le dossier .claude. */
+export function cmdSkills(c) {
+    const { rest, values, io, root } = c;
+    if (rest[0] !== 'install')
+        throw new RafError('usage : cadence skills install [--dir .claude] [--force]');
+    // --dir désigne le dossier .claude (défaut : celui du dépôt) : skills/ et agents/ dedans.
+    const base = resolve(io.cwd, values.dir ?? join(root, '.claude'));
+    const label = { installed: 'installé', updated: 'mis à jour', unchanged: 'inchangé' };
+    const force = !!values.force;
+    // Vérifier les deux avant d'écrire : un conflit d'agent ne doit pas laisser les skills à moitié installés.
+    if (!force) {
+        installSkills(SKILLS_DIR, join(base, 'skills'), false, true);
+        installAgents(AGENTS_DIR, join(base, 'agents'), false, true);
+    }
+    for (const r of installSkills(SKILLS_DIR, join(base, 'skills'), force))
+        io.out(`${r.name} : ${label[r.status]}`);
+    for (const r of installAgents(AGENTS_DIR, join(base, 'agents'), force))
+        io.out(`${r.name} (agent) : ${label[r.status]}`);
+    io.out(base);
+    return 0;
+}
+/** Déplacer le plan ne lit pas le plan : pas d'avertissement « ancien emplacement » (L284). */
+export function cmdMigrate(c) {
+    const { rest, values, io, root } = c;
+    if (rest.length > 0)
+        throw new RafError('usage : raf migrate [--dry-run]');
+    const migration = planMigration(root);
+    // --dry-run décrit ce qui serait fait avant de refuser ; sans lui, un refus n'annonce rien de fait.
+    if (values['dry-run'] || migration.unhandled.length === 0)
+        for (const l of describeMigration(migration, !!values['dry-run']))
+            io.out(l);
+    if (migration.unhandled.length > 0)
+        throw unhandledError(migration);
+    if (!values['dry-run'])
+        applyMigration(root, migration);
+    return 0;
+}