baldart 3.6.2

package/src/commands/doctor.js

@@ -0,0 +1,486 @@
+/**
+ * `baldart doctor` — smart diagnostic + suggested action.
+ *
+ * Invoked with no arguments (`npx baldart`) or explicitly (`npx baldart doctor`).
+ * Inspects the consumer repo, prints a status table, then proposes the next
+ * sensible action(s) and (with confirmation) runs them.
+ *
+ * Detection priority (precondition order, lowest-permissive first):
+ *
+ *   1.  no git repo                  → suggest `git init`, abort.
+ *   2.  no .framework/               → suggest `add`.
+ *   3.  legacy v2.0.x bulk skills    → suggest `migrate`.
+ *   4.  no baldart.config.yml        → suggest `configure`.
+ *   5.  config schema drift          → suggest `configure` (idempotent merge).
+ *   6.  remote ahead AND local changes → suggest `update` then `push` (two prompts).
+ *   7.  remote ahead                 → suggest `update`.
+ *   8.  local changes                → suggest `push`.
+ *   9.  all clean                    → print extended status + hints.
+ *
+ * Flags:
+ *   --auto       run with no confirmation prompts (CI-friendly). Errors out
+ *                on multi-choice ambiguity rather than guessing.
+ *   --offline    skip the upstream fetch (no remote drift check).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const GitUtils = require('../utils/git');
+const UI = require('../utils/ui');
+const State = require('../utils/state');
+const Hooks = require('../utils/hooks');
+
+const FRAMEWORK_DIR = '.framework';
+const REPO_DEFAULT = 'antbald/BALDART';
+const CONFIG_FILE = 'baldart.config.yml';
+
+// ──────────────────────────────────────────────────────────────────────
+// State detection
+// ──────────────────────────────────────────────────────────────────────
+
+function fileExists(p) {
+  try { return fs.existsSync(p); } catch (_) { return false; }
+}
+
+function isLegacySkillsLayout(cwd) {
+  const skills = path.join(cwd, '.claude', 'skills');
+  if (!fileExists(skills)) return false;
+  try { return fs.lstatSync(skills).isSymbolicLink(); }
+  catch (_) { return false; }
+}
+
+function loadConfig(cwd) {
+  const full = path.join(cwd, CONFIG_FILE);
+  if (!fileExists(full)) return null;
+  try { return yaml.load(fs.readFileSync(full, 'utf8')); }
+  catch (_) { return { __malformed: true }; }
+}
+
+function loadConfigTemplate(cwd) {
+  const tpl = path.join(cwd, FRAMEWORK_DIR, 'framework', 'templates', 'baldart.config.template.yml');
+  if (!fileExists(tpl)) return null;
+  try { return yaml.load(fs.readFileSync(tpl, 'utf8')); }
+  catch (_) { return null; }
+}
+
+function configSchemaDrift(config, template) {
+  if (!config || !template || config.__malformed) return [];
+  const drift = [];
+  for (const section of ['paths', 'features']) {
+    const tplKeys = Object.keys(template[section] || {});
+    const cfgKeys = Object.keys(config[section] || {});
+    for (const k of tplKeys) {
+      if (!cfgKeys.includes(k)) drift.push(`${section}.${k}`);
+    }
+  }
+  return drift;
+}
+
+function countOverlays(cwd) {
+  const dir = path.join(cwd, '.baldart', 'overlays');
+  if (!fileExists(dir)) return 0;
+  try {
+    return fs.readdirSync(dir).filter((f) => f.endsWith('.md')).length;
+  } catch (_) { return 0; }
+}
+
+function overlayDrift(cwd, frameworkVersion) {
+  if (!frameworkVersion) return [];
+  const dir = path.join(cwd, '.baldart', 'overlays');
+  if (!fileExists(dir)) return [];
+  const drifted = [];
+  try {
+    for (const f of fs.readdirSync(dir)) {
+      if (!f.endsWith('.md')) continue;
+      const txt = fs.readFileSync(path.join(dir, f), 'utf8');
+      const fm = txt.match(/^---\n([\s\S]*?)\n---/);
+      if (!fm) continue;
+      try {
+        const meta = yaml.load(fm[1]) || {};
+        if (meta.base_skill_version && meta.base_skill_version !== frameworkVersion) {
+          drifted.push({ name: f, target: meta.base_skill_version, installed: frameworkVersion });
+        }
+      } catch (_) { /* ignore unparseable */ }
+    }
+  } catch (_) { /* ignore */ }
+  return drifted;
+}
+
+async function describeRemote(git, repo, offline) {
+  // Best-effort remote drift detection. Returns { ahead, behind, fetched }.
+  if (offline) return { fetched: false };
+  try { await git.fetch(repo); }
+  catch (_) { return { fetched: false }; }
+  try {
+    const out = await git.git.raw(['rev-list', '--left-right', '--count', 'HEAD...FETCH_HEAD']);
+    const [ahead, behind] = out.trim().split('\t').map(Number);
+    return { ahead, behind, fetched: true };
+  } catch (_) { return { fetched: false }; }
+}
+
+async function localFrameworkChanges(git) {
+  // Files modified vs HEAD inside .framework/. Distinct from "ahead of remote"
+  // (which counts commits). This is the working-tree dirty count.
+  try {
+    const out = await git.git.raw(['status', '--porcelain', '--', FRAMEWORK_DIR]);
+    return out.split('\n').filter((l) => l.trim()).length;
+  } catch (_) { return 0; }
+}
+
+async function commitsAheadOfRemote(git) {
+  try {
+    const out = await git.git.raw(['rev-list', '--count', 'FETCH_HEAD..HEAD', '--', FRAMEWORK_DIR]);
+    return Number(out.trim()) || 0;
+  } catch (_) { return 0; }
+}
+
+async function detectState(cwd, opts = {}) {
+  const git = new GitUtils(cwd);
+  const state = {
+    cwd,
+    isGitRepo: await git.isGitRepo(),
+    frameworkPresent: await git.frameworkExists(),
+    legacyLayout: false,
+    frameworkVersion: null,
+    configPresent: false,
+    configMalformed: false,
+    configSchemaMissing: [],
+    statePresent: false,
+    stateInstalled: null,
+    stateInstallDate: null,
+    stateLastUpdate: null,
+    stateLastPush: null,
+    remote: { fetched: false },
+    commitsAhead: 0,
+    workingTreeDirty: 0,
+    overlays: 0,
+    overlaysDrifted: [],
+  };
+
+  if (!state.isGitRepo) return state;
+
+  if (state.frameworkPresent) {
+    state.legacyLayout = isLegacySkillsLayout(cwd);
+    try { state.frameworkVersion = await git.getFrameworkVersion(); } catch (_) {}
+
+    const config = loadConfig(cwd);
+    state.configPresent = !!config && !config.__malformed;
+    state.configMalformed = !!(config && config.__malformed);
+    if (state.configPresent) {
+      const tpl = loadConfigTemplate(cwd);
+      state.configSchemaMissing = configSchemaDrift(config, tpl);
+    }
+
+    const ledger = State.load(cwd);
+    state.statePresent = !!ledger.installed_version;
+    state.stateInstalled = ledger.installed_version;
+    state.stateInstallDate = ledger.install_date;
+    state.stateLastUpdate = ledger.last_update_date;
+    state.stateLastPush = ledger.last_pushed_version
+      ? `v${ledger.last_pushed_version} (${(ledger.last_push_date || '').slice(0, 10) || '—'})`
+      : null;
+
+    state.remote = await describeRemote(git, ledger.framework_repo || REPO_DEFAULT, !!opts.offline);
+    state.commitsAhead = await commitsAheadOfRemote(git);
+    state.workingTreeDirty = await localFrameworkChanges(git);
+
+    state.overlays = countOverlays(cwd);
+    state.overlaysDrifted = overlayDrift(cwd, state.frameworkVersion);
+
+    state.editGateRegistered = false;
+    try { state.editGateRegistered = Hooks.isRegistered(cwd); } catch (_) {}
+  }
+
+  return state;
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Action planner
+// ──────────────────────────────────────────────────────────────────────
+
+/**
+ * Returns an array of action proposals. Each item:
+ *   { key, label, why, run() }
+ *
+ * Order matters: actions are presented and (with confirmation) executed in
+ * the order returned. Empty array means "nothing to do".
+ */
+function planActions(state) {
+  const actions = [];
+
+  if (!state.isGitRepo) {
+    actions.push({
+      key: 'git-init',
+      label: 'Initialize a git repo',
+      why: 'BALDART requires a git repository to install (it uses git subtree).',
+      run: () => {
+        UI.error('Run `git init` first, then re-run `npx baldart`.');
+        process.exit(1);
+      },
+    });
+    return actions;
+  }
+
+  if (!state.frameworkPresent) {
+    actions.push({
+      key: 'add',
+      label: 'Install BALDART framework',
+      why: 'No .framework/ directory found in this repo.',
+      run: async () => {
+        const add = require('./add');
+        await add(REPO_DEFAULT, { branch: 'main' });
+      },
+    });
+    return actions;
+  }
+
+  if (state.legacyLayout) {
+    actions.push({
+      key: 'migrate',
+      label: 'Migrate legacy v2.0.x layout',
+      why: '.claude/skills/ is a bulk symlink — v2.0.x layout. v2.1.1+ uses per-item merge.',
+      run: () => require('./migrate')(),
+    });
+    return actions;
+  }
+
+  if (state.configMalformed) {
+    actions.push({
+      key: 'configure-malformed',
+      label: 'Rewrite baldart.config.yml (current file is malformed)',
+      why: 'Existing baldart.config.yml is not valid YAML — re-running configure will rebuild it.',
+      run: () => require('./configure')(),
+    });
+    return actions;
+  }
+
+  if (!state.configPresent) {
+    actions.push({
+      key: 'configure',
+      label: 'Generate baldart.config.yml',
+      why: 'Skills require a config to resolve project-specific paths/identity/stack. Without it they will prompt on every invocation.',
+      run: () => require('./configure')(),
+    });
+    return actions;
+  }
+
+  if (state.configSchemaMissing.length > 0) {
+    actions.push({
+      key: 'configure-drift',
+      label: `Refresh baldart.config.yml (${state.configSchemaMissing.length} new key(s) from framework template)`,
+      why: 'Framework added config keys this consumer doesn\'t yet declare: ' + state.configSchemaMissing.join(', '),
+      run: () => require('./configure')(),
+    });
+    // Drift is non-blocking — keep checking for other actions after.
+  }
+
+  if (state.editGateRegistered === false) {
+    actions.push({
+      key: 'register-edit-gate',
+      label: 'Register framework-edit-gate hook (.claude/settings.json)',
+      why: 'Prevents project-specific tokens (Neo-Brutalism, merchant, …) from being written to .framework/ accidentally. Standard in v3.3.0+; missing on installs predating that version.',
+      run: async () => {
+        const res = require('../utils/hooks').register();
+        UI.success(`Hook registered: ${res.status} (${res.path})`);
+      },
+    });
+  }
+
+  const remoteAhead = state.remote.fetched && state.remote.behind > 0;
+  const hasLocalWork = state.workingTreeDirty > 0 || state.commitsAhead > 0;
+
+  if (remoteAhead) {
+    actions.push({
+      key: 'update',
+      label: `Pull ${state.remote.behind} commit(s) from upstream`,
+      why: 'Remote framework is ahead of your local copy. Updating first keeps your contributions on a fresh base.',
+      run: () => require('./update')(),
+    });
+  }
+
+  if (hasLocalWork) {
+    actions.push({
+      key: 'push',
+      label: 'Push local framework improvements upstream',
+      why: state.workingTreeDirty
+        ? `${state.workingTreeDirty} uncommitted file(s) in .framework/ — commit them through \`baldart push\`.`
+        : `${state.commitsAhead} commit(s) on .framework/ not yet pushed.`,
+      run: () => require('./push')(),
+    });
+  }
+
+  return actions;
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Diagnostic table
+// ──────────────────────────────────────────────────────────────────────
+
+function fmtDate(iso) {
+  if (!iso) return '—';
+  try { return iso.slice(0, 10); } catch (_) { return iso; }
+}
+
+function statusLine(label, value, severity) {
+  const symbol = severity === 'ok' ? '✓' : severity === 'warn' ? '⚠' : severity === 'err' ? '✗' : '·';
+  return `${symbol}  ${label.padEnd(15)} ${value}`;
+}
+
+function renderDiagnostic(state) {
+  UI.header('BALDART DOCTOR');
+  console.log(`Repository:    ${state.cwd}`);
+  console.log();
+
+  console.log(statusLine('Git repo', state.isGitRepo ? 'yes' : 'no', state.isGitRepo ? 'ok' : 'err'));
+
+  if (!state.isGitRepo) return;
+
+  console.log(statusLine(
+    'Framework',
+    state.frameworkPresent ? `v${state.frameworkVersion}` : 'not installed',
+    state.frameworkPresent ? 'ok' : 'warn'
+  ));
+
+  if (!state.frameworkPresent) return;
+
+  console.log(statusLine(
+    'Layout',
+    state.legacyLayout ? 'legacy v2.0.x (migration needed)' : 'current',
+    state.legacyLayout ? 'warn' : 'ok'
+  ));
+
+  console.log(statusLine(
+    'Config',
+    state.configMalformed
+      ? 'malformed YAML'
+      : state.configPresent
+        ? (state.configSchemaMissing.length
+            ? `${state.configSchemaMissing.length} key(s) missing from current schema`
+            : 'present')
+        : 'missing',
+    state.configMalformed || !state.configPresent ? 'err'
+      : state.configSchemaMissing.length ? 'warn'
+        : 'ok'
+  ));
+
+  console.log(statusLine(
+    'State ledger',
+    state.statePresent
+      ? `installed v${state.stateInstalled} (${fmtDate(state.stateInstallDate)})`
+      : 'not seeded',
+    state.statePresent ? 'ok' : 'warn'
+  ));
+
+  if (state.stateLastUpdate) {
+    console.log(statusLine('Last update', fmtDate(state.stateLastUpdate), 'ok'));
+  }
+  if (state.stateLastPush) {
+    console.log(statusLine('Last push', state.stateLastPush, 'ok'));
+  }
+
+  if (state.remote.fetched) {
+    const behind = state.remote.behind || 0;
+    console.log(statusLine(
+      'Remote',
+      behind > 0 ? `${behind} commit(s) ahead — update available` : 'up to date',
+      behind > 0 ? 'warn' : 'ok'
+    ));
+  } else {
+    console.log(statusLine('Remote', 'offline / not fetched', 'warn'));
+  }
+
+  console.log(statusLine(
+    'Local changes',
+    state.workingTreeDirty > 0
+      ? `${state.workingTreeDirty} file(s) in .framework/`
+      : state.commitsAhead > 0
+        ? `${state.commitsAhead} unpushed commit(s)`
+        : 'clean',
+    (state.workingTreeDirty + state.commitsAhead) > 0 ? 'warn' : 'ok'
+  ));
+
+  console.log(statusLine(
+    'Overlays',
+    state.overlays === 0 ? 'none authored' : `${state.overlays} authored`,
+    state.overlaysDrifted.length ? 'warn' : 'ok'
+  ));
+  if (state.overlaysDrifted.length) {
+    state.overlaysDrifted.forEach((o) =>
+      console.log(`   • ${o.name} targets v${o.target}, installed v${o.installed}`));
+  }
+
+  console.log(statusLine(
+    'Edit gate',
+    state.editGateRegistered ? 'registered' : 'NOT registered (.claude/settings.json)',
+    state.editGateRegistered ? 'ok' : 'warn'
+  ));
+
+  console.log();
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Main
+// ──────────────────────────────────────────────────────────────────────
+
+async function doctor(opts = {}) {
+  const cwd = process.cwd();
+  const auto = !!opts.auto;
+  const offline = !!opts.offline;
+
+  const state = await detectState(cwd, { offline });
+  renderDiagnostic(state);
+
+  const actions = planActions(state);
+
+  if (actions.length === 0) {
+    UI.success('Nothing to do — framework is healthy and in sync.');
+    UI.newline();
+    UI.info('Available actions:');
+    UI.list([
+      '`npx baldart push`      — contribute local improvements upstream',
+      '`npx baldart configure` — re-run config prompts (e.g. after enabling a feature)',
+      '`npx baldart status`    — symlink + overlay validity check',
+      '`npx baldart version`   — installed version + remote drift',
+    ], 'cyan');
+    return;
+  }
+
+  UI.section('Recommended action(s)');
+  actions.forEach((a, i) =>
+    console.log(`  ${i + 1}. ${a.label}\n     ${a.why}`));
+  UI.newline();
+
+  // Multi-action ambiguity check in --auto mode.
+  if (auto && actions.length > 1 && actions.some((a) => a.key !== 'configure-drift')) {
+    // Drift refresh is a no-op-style action; pairs with other actions safely.
+    // Anything else that yields >1 step is genuine ambiguity in CI.
+    const ambiguous = actions.filter((a) => a.key !== 'configure-drift').length > 1;
+    if (ambiguous) {
+      UI.error('Multiple actions proposed; --auto refuses to chain in ambiguous state.');
+      UI.info('Run them explicitly with the corresponding `baldart <subcommand>` calls.');
+      process.exit(2);
+    }
+  }
+
+  for (const action of actions) {
+    let proceed = auto;
+    if (!auto) {
+      proceed = await UI.confirm(`Run: ${action.label}?`, true);
+    }
+    if (!proceed) {
+      UI.info(`Skipped: ${action.label}`);
+      break;
+    }
+    try {
+      await action.run();
+    } catch (err) {
+      UI.error(`Action "${action.key}" failed: ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+module.exports = doctor;
+module.exports.detectState = detectState;
+module.exports.planActions = planActions;

package/src/commands/migrate.js

@@ -0,0 +1,185 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const UI = require('../utils/ui');
+const SymlinkUtils = require('../utils/symlinks');
+
+/**
+ * `npx baldart migrate` — fixes installation state on existing repos.
+ *
+ * Today handles two known migration paths:
+ *
+ *   1. **v1.x → v2.1.1**: no `.claude/skills/` directory existed; the v2.0.x
+ *      update tried to install a bulk symlink and (depending on the user's
+ *      state) may have renamed their existing skills directory to
+ *      `.claude/skills.backup`. We surface that, convert to per-item layout,
+ *      and offer to restore the backup contents alongside framework skills.
+ *
+ *   2. **v2.0.x → v2.1.1**: the v2.0.x bulk symlink at `.claude/skills` is
+ *      replaced with a real directory + per-item framework skill symlinks.
+ *      Any user skills that ended up in `.claude/skills.backup` are restored
+ *      into the new directory (with name-collision detection).
+ *
+ * The command is idempotent: running it on an already-migrated repo simply
+ * reports "nothing to do".
+ */
+async function migrate() {
+  UI.header('BALDART Migration');
+
+  const cwd = process.cwd();
+  const symlinks = new SymlinkUtils(cwd);
+
+  const skillsPath = path.join(cwd, '.claude', 'skills');
+  const skillsBackup = path.join(cwd, '.claude', 'skills.backup');
+  const frameworkDir = path.join(cwd, '.framework');
+  const frameworkSkillsDir = path.join(frameworkDir, 'framework', '.claude', 'skills');
+
+  // --- Pre-flight ---------------------------------------------------------
+
+  if (!fs.existsSync(frameworkDir)) {
+    UI.error('No `.framework/` directory found. BALDART is not installed in this repo.');
+    UI.info('Run `npx baldart add` first.');
+    return;
+  }
+
+  if (!fs.existsSync(frameworkSkillsDir)) {
+    UI.warning('Framework appears to be older than v2.0.0 (no skills directory). Run `npx baldart update` first.');
+    return;
+  }
+
+  // --- Inspect current state ---------------------------------------------
+
+  UI.section('Inspecting current installation');
+
+  let skillsState = 'none';                  // none | bulk-symlink | real-dir
+  let backupPresent = false;
+
+  if (fs.existsSync(skillsPath)) {
+    const stat = fs.lstatSync(skillsPath);
+    if (stat.isSymbolicLink()) {
+      skillsState = 'bulk-symlink';
+      const linkTarget = fs.readlinkSync(skillsPath);
+      UI.warning(`.claude/skills is a legacy bulk symlink → ${linkTarget}`);
+    } else {
+      skillsState = 'real-dir';
+      const entries = fs.readdirSync(skillsPath);
+      UI.info(`.claude/skills/ is a real directory with ${entries.length} entries.`);
+    }
+  } else {
+    UI.info('.claude/skills/ does not exist yet.');
+  }
+
+  if (fs.existsSync(skillsBackup)) {
+    backupPresent = true;
+    const entries = fs.readdirSync(skillsBackup).filter(n => !n.startsWith('.'));
+    UI.warning(`Found .claude/skills.backup with ${entries.length} entries (from a prior failed update).`);
+  }
+
+  // --- Plan ---------------------------------------------------------------
+
+  const actions = [];
+  if (skillsState === 'bulk-symlink') {
+    actions.push('Replace legacy bulk symlink with a real directory (.claude/skills/).');
+  }
+  if (skillsState === 'none') {
+    actions.push('Create .claude/skills/ as a real directory.');
+  }
+  actions.push('Merge framework skills as per-item symlinks (existing user skills preserved).');
+  if (backupPresent) {
+    actions.push('Restore user skills from .claude/skills.backup into .claude/skills/ (no overwrites).');
+  }
+  actions.push('Record any name collisions in .baldart/skill-conflicts.json.');
+
+  UI.section('Planned actions');
+  UI.list(actions);
+  UI.newline();
+
+  const proceed = await UI.confirm('Proceed with migration?', true);
+  if (!proceed) {
+    UI.info('Aborted. No changes made.');
+    return;
+  }
+
+  // --- Step 1: convert bulk symlink → real directory ---------------------
+
+  if (skillsState === 'bulk-symlink') {
+    UI.section('Step 1: convert legacy bulk symlink');
+    fs.unlinkSync(skillsPath);
+    fs.mkdirSync(skillsPath, { recursive: true });
+    UI.success('Replaced bulk symlink with empty real directory.');
+  } else if (skillsState === 'none') {
+    fs.mkdirSync(skillsPath, { recursive: true });
+    UI.success('Created .claude/skills/ directory.');
+  }
+
+  // --- Step 2: per-item framework skill merge ----------------------------
+
+  UI.section('Step 2: merge framework skills (per-item)');
+  const mergeResult = symlinks.mergeSkills();
+  UI.info(`Linked ${mergeResult.linked.length} framework skills, kept ${mergeResult.skipped.length} as-is, ${mergeResult.conflicts.length} conflict(s).`);
+
+  // --- Step 3: restore user skills from .backup --------------------------
+
+  if (backupPresent) {
+    UI.section('Step 3: restore user skills from .backup');
+    const entries = fs.readdirSync(skillsBackup).filter(n => !n.startsWith('.'));
+    let restored = 0;
+    let collided = 0;
+
+    entries.forEach(name => {
+      const src = path.join(skillsBackup, name);
+      const dst = path.join(skillsPath, name);
+
+      if (fs.existsSync(dst)) {
+        const stat = fs.lstatSync(dst);
+        if (stat.isSymbolicLink()) {
+          // Framework symlink already there — name collision
+          UI.warning(`Collision: backup has "${name}" but framework also ships it. Backup kept at .claude/skills.backup/${name}.`);
+          collided++;
+          return;
+        }
+      }
+
+      // Move (atomic rename) from backup into skills/
+      fs.renameSync(src, dst);
+      UI.success(`Restored user skill: .claude/skills/${name}`);
+      restored++;
+    });
+
+    // Remove the backup dir if empty
+    const remaining = fs.readdirSync(skillsBackup).filter(n => !n.startsWith('.'));
+    if (remaining.length === 0) {
+      fs.rmSync(skillsBackup, { recursive: true, force: true });
+      UI.success('Removed empty .claude/skills.backup.');
+    } else {
+      UI.warning(`${remaining.length} item(s) still in .claude/skills.backup (collisions kept for manual review).`);
+    }
+
+    UI.info(`Restored ${restored} user skill(s). ${collided} collision(s) left in .backup.`);
+  }
+
+  // --- Step 4: report ----------------------------------------------------
+
+  UI.newline();
+  UI.header('✓ MIGRATION COMPLETE');
+
+  const summaryLines = [
+    `Framework skills linked: ${mergeResult.linked.length}`,
+    `Existing user skills kept: ${mergeResult.skipped.filter(s => s.reason !== 'already-linked').length}`,
+    `Name collisions recorded: ${mergeResult.conflicts.length}`
+  ];
+  if (backupPresent) {
+    summaryLines.push('.claude/skills.backup processed (see warnings above).');
+  }
+  UI.box('Migration summary', summaryLines);
+
+  UI.section('Next steps');
+  UI.list([
+    'Run `npx baldart routines list` to review schedule status (v2.1.0+).',
+    'Run `npx baldart status` for an overall installation check.',
+    'Commit the resulting changes (`.claude/skills/`, `.baldart/skill-conflicts.json` if any) so the team sees the same state.'
+  ]);
+  UI.newline();
+}
+
+module.exports = migrate;