@ashlr/hub 2.2.0

package/dist/cli/index.js

@@ -0,0 +1,1208 @@
+#!/usr/bin/env node
+/**
+ * ashlr CLI — main entry point.
+ *
+ * Commands:
+ *   index [--refresh]          Rebuild the desktop index; print counts by category.
+ *   go [query] [--open|--cd]   Find an item; open in editor, cd, or just print.
+ *   status                     Attention board: dirty/stale repos, aligned table.
+ *   ls [category]              List all indexed items, optionally filtered.
+ *   open [query]               Open best match in editor; no query → picker.
+ *   tidy [--apply] [--json]    Plan (dry-run) or apply tidy moves; --json emits machine output.
+ *   config [get|set|path]      Read/write config values.
+ *   doctor                     One-glance health check (config, phantom, providers).
+ *   init [--yes]               Idempotent onboarding; NON-TTY safe with --yes.
+ *   mcp [list|doctor|install]  MCP aggregation gateway and registry management.
+ *   run "<goal>" [opts]        Local-first agent orchestrator; decompose & execute a goal.
+ *   run show <id>              Print a past run in detail.
+ *   runs [--json]              List past runs.
+ *   pulse [--json] [--window]  Local observability dashboard: tokens, cost, activity.
+ *   new <name> [opts]          Scaffold a new project and register it in the index.
+ *   ship [path] [opts]         Run pre-ship gate (lint/test/build/deps) + optional deploy.
+ *   recall "<query>"           Search shared genome memory; return top relevant entries.
+ *   learn "<text>" [opts]      Append a note to shared genome memory.
+ *   genome                     Genome status/health: entry count, projects, staleness.
+ *   update [--check] [--json]  Safe self-update: git pull --ff-only + rebuild; --check reports only.
+ *   spec new "<goal>" [opts]   Author a versioned end-state spec artifact.
+ *   spec list/show/refine      Manage spec artifacts.
+ *   swarm "<goal>"|<specId>    Decompose a spec into a contracts-first agent swarm and run it.
+ *   swarms [--json]            List past swarm runs.
+ *   tui [--once]               Interactive terminal dashboard (alias: dash).
+ *   serve [--port N] [--open]  Local web dashboard + JSON API on 127.0.0.1 (default port 7777).
+ *   gh <pr|issue|ci>           Read GitHub PRs / issues / CI status (read-only via gh CLI).
+ *   gh pr create               Create a PR (explicit + confirm-gated mutation).
+ *   vercel <ls|logs>           Read Vercel deployments / latest logs (read-only via vercel CLI).
+ *   wire [claude|codex|cursor|all]  Wire ashlr MCP gateway into editor config(s).
+ *   notify test                Send a test ping to the configured webhook (no-op if unconfigured).
+ *   help                       Show this help.
+ *
+ * Exit codes: 0 success, 1 error/not-found, 2 bad usage.
+ */
+import { loadConfig, saveConfig, CONFIG_PATH } from '../core/config.js';
+import { buildIndex, loadIndex, writeIndex } from '../core/index-engine.js';
+import { planTidy, applyTidy } from '../core/tidy.js';
+import { openInEditor } from './open.js';
+import { pick } from './picker.js';
+import { cmdDoctor, cmdInit } from './doctor-init.js';
+import { pad, makeColors } from './ui.js';
+/**
+ * Build a lazy loader for a CLI command export.
+ * @param importer  dynamic import of the command module
+ * @param pick      selects the command function from the loaded module
+ * @param label     human command name + source path for the fallback message
+ *                  (e.g. "mcp command requires src/cli/mcp.ts (M3 module not yet built).")
+ */
+function lazyCmd(importer, pick, label) {
+    let cached;
+    return async () => {
+        if (cached === undefined) {
+            try {
+                cached = pick((await importer()));
+            }
+            catch {
+                cached = null;
+            }
+        }
+        if (cached === null) {
+            return async (_args) => {
+                console.error(red('error: ') + label);
+                return 1;
+            };
+        }
+        return cached;
+    };
+}
+const loadMcpCmd = lazyCmd(() => import('./mcp.js'), (m) => m.cmdMcp, 'mcp command requires src/cli/mcp.ts (M3 module not yet built).');
+// Cache slots — undefined = not yet attempted; null = attempted & failed
+let _getToolsRegistry = undefined;
+let _discoverMcpServers = undefined;
+async function tryGetToolsRegistry() {
+    if (_getToolsRegistry === undefined) {
+        try {
+            const mod = await import('../core/tools-registry.js');
+            _getToolsRegistry = mod.getToolsRegistry;
+        }
+        catch {
+            _getToolsRegistry = null;
+        }
+    }
+    return _getToolsRegistry ?? null;
+}
+async function tryDiscoverMcpServers() {
+    if (_discoverMcpServers === undefined) {
+        try {
+            const mod = await import('../core/mcp-registry.js');
+            _discoverMcpServers = mod.discoverMcpServers;
+        }
+        catch {
+            _discoverMcpServers = null;
+        }
+    }
+    return _discoverMcpServers ?? null;
+}
+// ─── M4 command loaders ────────────────────────────────────────────
+const loadRunCmd = lazyCmd(() => import('./run.js'), (m) => m.cmdRun, 'run command requires src/cli/run.ts (M4 module not yet built).');
+const loadRunsCmd = lazyCmd(() => import('./run.js'), (m) => m.cmdRuns, 'runs command requires src/cli/run.ts (M4 module not yet built).');
+let _buildRollup = undefined;
+const loadPulseCmd = lazyCmd(() => import('./pulse.js'), (m) => m.cmdPulse, 'pulse command requires src/cli/pulse.ts (M5 module not yet built).');
+async function tryBuildRollup() {
+    if (_buildRollup === undefined) {
+        try {
+            const mod = (await import('../core/observability/rollup.js'));
+            _buildRollup = mod.buildRollup;
+        }
+        catch {
+            _buildRollup = null;
+        }
+    }
+    return _buildRollup ?? null;
+}
+// ─── M6 command loaders ────────────────────────────────────────────
+const loadNewCmd = lazyCmd(() => import('./new.js'), (m) => m.cmdNew, 'new command requires src/cli/new.ts (M6 module not yet built).');
+const loadShipCmd = lazyCmd(() => import('./ship.js'), (m) => m.cmdShip, 'ship command requires src/cli/ship.ts (M6 module not yet built).');
+// ─── M7 command loaders ────────────────────────────────────────────
+const loadRecallCmd = lazyCmd(() => import('./genome.js'), (m) => m.cmdRecall, 'recall command requires src/cli/genome.ts (M7 module not yet built).');
+const loadLearnCmd = lazyCmd(() => import('./genome.js'), (m) => m.cmdLearn, 'learn command requires src/cli/genome.ts (M7 module not yet built).');
+const loadGenomeCmd = lazyCmd(() => import('./genome.js'), (m) => m.cmdGenome, 'genome command requires src/cli/genome.ts (M7 module not yet built).');
+// ─── M9 command loader ───────────────────────────────────────────
+const loadUpdateCmd = lazyCmd(() => import('./update.js'), (m) => m.cmdUpdate, 'update command requires src/cli/update.ts (M9 module not yet built).');
+// ─── M12 command loaders ────────────────────────────────────────────
+const loadSpecCmd = lazyCmd(() => import('./spec.js'), (m) => m.cmdSpec, 'spec command requires src/cli/spec.ts (M12 module not yet built).');
+const loadSwarmCmd = lazyCmd(() => import('./swarm.js'), (m) => m.cmdSwarm, 'swarm command requires src/cli/swarm.ts (M12 module not yet built).');
+const loadSwarmsCmd = lazyCmd(() => import('./swarm.js'), (m) => m.cmdSwarms, 'swarms command requires src/cli/swarm.ts (M12 module not yet built).');
+// ─── M13 command loader ────────────────────────────────────────────
+const loadTuiCmd = lazyCmd(() => import('./tui.js'), (m) => m.cmdTui, 'tui command requires src/cli/tui.ts (M13 module not yet built).');
+// ─── M14 command loader ────────────────────────────────────────────
+const loadServeCmd = lazyCmd(() => import('./serve.js'), (m) => m.cmdServe, 'serve command requires src/cli/serve.ts (M14 module not yet built).');
+const loadModelsCmd = lazyCmd(() => import('./models.js'), (m) => m.cmdModels, 'models command requires src/cli/models.ts (M15 module not yet built).');
+// ─── M18 command loaders ───────────────────────────────────────────
+const loadGhCmd = lazyCmd(() => import('./gh.js'), (m) => m.cmdGh, 'gh command requires src/cli/gh.ts (M18 module not yet built).');
+const loadVercelCmd = lazyCmd(() => import('./vercel.js'), (m) => m.cmdVercel, 'vercel command requires src/cli/vercel.ts (M18 module not yet built).');
+const loadWireCmd = lazyCmd(() => import('./wire.js'), (m) => m.cmdWire, 'wire command requires src/cli/wire.ts (M18 module not yet built).');
+const loadNotifyCmd = lazyCmd(() => import('./notify.js'), (m) => m.cmdNotify, 'notify command requires src/cli/notify.ts (M18 module not yet built).');
+// ─── M19 command loader ────────────────────────────────────────────
+const loadTelemetryCmd = lazyCmd(() => import('./telemetry.js'), (m) => m.cmdTelemetry, 'telemetry command requires src/cli/telemetry.ts (M19 module not yet built).');
+// ─── M21 command loaders ────────────────────────────────────────────
+const loadSandboxCmd = lazyCmd(() => import('./sandbox.js'), (m) => m.cmdSandbox, 'sandbox command requires src/cli/sandbox.ts (M21 module not yet built).');
+// H6 (PART A): the `ashlr audit` viewer moved to its own ./audit.ts module
+// (read-only; adds --action/--result/--since filters). Re-pointed here from the
+// old sandbox.ts#cmdAudit, matching the reflect/health/seams/verify-safety
+// loaders — see docs/contracts/CONTRACT-H6.md §A.3.
+const loadAuditCmd = lazyCmd(() => import('./audit.js'), (m) => m.cmdAudit, 'audit command requires src/cli/audit.ts (H6 module not yet built).');
+const loadEnrollCmd = lazyCmd(() => import('./sandbox.js'), (m) => m.cmdEnroll, 'enroll command requires src/cli/sandbox.ts (M21 module not yet built).');
+// ─── M22 command loaders ────────────────────────────────────────────
+const loadBacklogCmd = lazyCmd(() => import('./backlog.js'), (m) => m.cmdBacklog, 'backlog command requires src/cli/backlog.ts (M22 module not yet built).');
+// ─── M23 command loaders ────────────────────────────────────────────
+const loadInboxCmd = lazyCmd(() => import('./inbox.js'), (m) => m.cmdInbox, 'inbox command requires src/cli/inbox.ts (M23 module not yet built).');
+// ─── M24 command loaders ────────────────────────────────────────────
+const loadDaemonCmd = lazyCmd(() => import('./daemon.js'), (m) => m.cmdDaemon, 'daemon command requires src/cli/daemon.ts (M24 module not yet built).');
+// ─── M25 command loaders ────────────────────────────────────────────
+const loadAskCmd = lazyCmd(() => import('./ask.js'), (m) => m.cmdAsk, 'ask command requires src/cli/ask.ts (M25 module not yet built).');
+const loadKnowledgeCmd = lazyCmd(() => import('./knowledge.js'), (m) => m.cmdKnowledge, 'knowledge command requires src/cli/knowledge.ts (M25 module not yet built).');
+// ─── M26 command loaders ────────────────────────────────────────────
+const loadReflectCmd = lazyCmd(() => import('./reflect.js'), (m) => m.cmdReflect, 'reflect command requires src/cli/reflect.ts (M26 module not yet built).');
+// ─── M27 command loaders ────────────────────────────────────────────
+const loadHealthCmd = lazyCmd(() => import('./health.js'), (m) => m.cmdHealth, 'health command requires src/cli/health.ts (M27 module not yet built).');
+// ─── M28 command loaders ────────────────────────────────────────────
+const loadGoalsCmd = lazyCmd(() => import('./goals.js'), (m) => m.cmdGoals, 'goals command requires src/cli/goals.ts (M28 module not yet built).');
+// ─── M29 command loaders ────────────────────────────────────────────
+const loadDigestCmd = lazyCmd(() => import('./digest.js'), (m) => m.cmdDigest, 'digest command requires src/cli/digest.ts (M29 module not yet built).');
+// ─── M30 command loaders ────────────────────────────────────────────
+const loadSeamsCmd = lazyCmd(() => import('./seams.js'), (m) => m.cmdSeams, 'seams command requires src/cli/seams.ts (M30 module not yet built).');
+// ─── M31 command loaders ──────────────────────────────────────────────────────────────
+const loadOrientCmd = lazyCmd(() => import('./orient.js'), (m) => m.cmdOrient, 'orient command requires src/cli/orient.ts (M31 module not yet built).');
+const loadDocsCmd = lazyCmd(() => import('./help.js'), (m) => m.cmdDocs, 'docs command requires src/cli/help.ts (M31 module not yet built).');
+const loadCompletionsCmd = lazyCmd(() => import('./completions.js'), (m) => m.cmdCompletions, 'completions command requires src/cli/completions.ts (M31 module not yet built).');
+// ─── M33 command loaders ──────────────────────────────────────────────────────────────
+const loadPluginsCmd = lazyCmd(() => import('./plugins.js'), (m) => m.cmdPlugins, 'plugins command requires src/cli/plugins.ts (M33 module not yet built).');
+const loadXCmd = lazyCmd(() => import('./plugins.js'), (m) => m.cmdX, 'x command requires src/cli/plugins.ts (M33 module not yet built).');
+// ─── H4 command loaders ─────────────────────────────────────────────
+const loadVerifySafetyCmd = lazyCmd(() => import('./verify-safety.js'), (m) => m.cmdVerifySafety, 'verify-safety command requires src/cli/verify-safety.ts (H4 module not yet built).');
+// ─── H7 command loaders ─────────────────────────────────────────────
+// preflight + onboard, matching the reflect/health/seams/verify-safety/audit
+// loaders — see docs/contracts/CONTRACT-H7.md.
+const loadPreflightCmd = lazyCmd(() => import('./preflight.js'), (m) => m.cmdPreflight, 'preflight command requires src/cli/preflight.ts (H7 module not yet built).');
+const loadOnboardCmd = lazyCmd(() => import('./onboard.js'), (m) => m.cmdOnboard, 'onboard command requires src/cli/onboard.ts (H7 module not yet built).');
+// ─── H8 command loader ──────────────────────────────────────────────
+// `ashlr demo` — a watchable, reproducible run of the FULL autonomous chain on a
+// DISPOSABLE repo in an ISOLATED tmp context; proposal-only; auto-cleans. The
+// ONE new runtime surface in v2.1 (see docs/contracts/CONTRACT-H8.md).
+const loadDemoCmd = lazyCmd(() => import('./demo.js'), (m) => m.cmdDemo, 'demo command requires src/cli/demo.ts (H8 module not yet built).');
+let _githubStatus = undefined;
+let _vercelStatus = undefined;
+let _getIdentity = undefined;
+async function tryGithubStatus() {
+    if (_githubStatus === undefined) {
+        try {
+            const mod = (await import('../core/integrations/github.js'));
+            _githubStatus = mod.githubStatus;
+        }
+        catch {
+            _githubStatus = null;
+        }
+    }
+    return _githubStatus ?? null;
+}
+async function tryVercelStatus() {
+    if (_vercelStatus === undefined) {
+        try {
+            const mod = (await import('../core/integrations/vercel.js'));
+            _vercelStatus = mod.vercelStatus;
+        }
+        catch {
+            _vercelStatus = null;
+        }
+    }
+    return _vercelStatus ?? null;
+}
+async function tryGetIdentity() {
+    if (_getIdentity === undefined) {
+        try {
+            const mod = (await import('../core/integrations/identity.js'));
+            _getIdentity = mod.getIdentity;
+        }
+        catch {
+            _getIdentity = null;
+        }
+    }
+    return _getIdentity ?? null;
+}
+// ─── ANSI helpers ──────────────────────────────────────────────────────────────
+// index.ts colorizes unconditionally (output is always color-coded regardless
+// of TTY), so we bind the shared colorizers with tty=true.
+const { bold, dim, red, green, yellow, cyan, gray, magenta } = makeColors(true);
+// ─── Utility ──────────────────────────────────────────────────────────────────
+function die(msg, code = 1) {
+    console.error(red('error: ') + msg);
+    process.exit(code);
+}
+/** Ensure the index exists; auto-build if missing. Returns the index. */
+function requireIndex(cfg) {
+    let idx = loadIndex();
+    if (!idx) {
+        // Informational chatter goes to stderr so stdout stays clean for capture
+        // (e.g. `cd $(ashlr go foo --cd)`).
+        console.error(dim('No index found — building now…'));
+        idx = buildIndex(cfg);
+        writeIndex(idx);
+    }
+    return idx;
+}
+/** Score an item against a query string (higher = better match). */
+function scoreItem(item, query) {
+    const q = query.toLowerCase();
+    const name = item.name.toLowerCase();
+    const cat = (item.category ?? '').toLowerCase();
+    const desc = (item.description ?? '').toLowerCase();
+    // Exact name match
+    if (name === q)
+        return 100;
+    // Name starts with query
+    if (name.startsWith(q))
+        return 80;
+    // Name contains query
+    if (name.includes(q))
+        return 60;
+    // Category + name
+    if (cat.includes(q))
+        return 40;
+    // Description
+    if (desc.includes(q))
+        return 20;
+    return 0;
+}
+/** Filter and rank items by query. Returns sorted descending by score. */
+function filterItems(items, query) {
+    if (!query.trim())
+        return items;
+    return items
+        .map(item => ({ item, score: scoreItem(item, query) }))
+        .filter(({ score }) => score > 0)
+        .sort((a, b) => b.score - a.score)
+        .map(({ item }) => item);
+}
+/** Days since a date string. */
+function daysSince(iso) {
+    return (Date.now() - new Date(iso).getTime()) / (1000 * 60 * 60 * 24);
+}
+/** Format a short relative time. */
+function relativeTime(iso) {
+    if (!iso)
+        return gray('—');
+    const days = daysSince(iso);
+    if (days < 1)
+        return green('today');
+    if (days < 2)
+        return green('yesterday');
+    if (days < 7)
+        return green(`${Math.floor(days)}d ago`);
+    if (days < 30)
+        return yellow(`${Math.floor(days)}d ago`);
+    if (days < 365)
+        return `${Math.floor(days / 30)}mo ago`;
+    return red(`${Math.floor(days / 365)}y ago`);
+}
+/**
+ * Config key segments that would let `config set` walk into an object's
+ * prototype chain (prototype pollution). Any dot-path containing one of these
+ * is rejected before we walk/assign, since the result is persisted to
+ * ~/.ashlr/config.json and re-applied via deepMerge on the next load.
+ */
+const DANGEROUS_KEY_SEGMENTS = new Set(['__proto__', 'prototype', 'constructor']);
+/** Reject a config dot-path whose any segment is a prototype-polluting prop. */
+function assertSafeConfigKey(key) {
+    for (const segment of key.split('.')) {
+        if (DANGEROUS_KEY_SEGMENTS.has(segment)) {
+            die(`Illegal config key segment: "${segment}"`, 2);
+        }
+    }
+}
+/** Get a nested config value by dot-path key. */
+function getConfigValue(cfg, key) {
+    const parts = key.split('.');
+    let val = cfg;
+    for (const part of parts) {
+        if (val === null || typeof val !== 'object')
+            return undefined;
+        val = val[part];
+    }
+    return val;
+}
+/**
+ * True when a config dot-path leaf looks sensitive (token/key/secret/etc).
+ * Used to redact values in `config get`/`config set` output so a manually
+ * stashed credential never lands in terminal scrollback or shell history.
+ */
+const SENSITIVE_KEY_RE = /token|key|secret|password|passwd|auth|credential|api[_-]?key/i;
+function isSensitiveKey(key) {
+    const leaf = key.split('.').pop() ?? key;
+    return SENSITIVE_KEY_RE.test(leaf);
+}
+/**
+ * Assign `value` to a dot-path leaf in `cfg`, creating intermediate objects as
+ * needed. Caller MUST run assertSafeConfigKey(key) first (prototype-pollution
+ * guard) — setByPath itself does not re-check.
+ */
+function setByPath(cfg, key, value) {
+    const parts = key.split('.');
+    let obj = cfg;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const hasOwn = Object.prototype.hasOwnProperty.call(obj, parts[i]);
+        const next = hasOwn ? obj[parts[i]] : undefined;
+        if (!hasOwn || next === null || typeof next !== 'object') {
+            obj[parts[i]] = {};
+        }
+        obj = obj[parts[i]];
+    }
+    obj[parts[parts.length - 1]] = value;
+}
+/** Set a nested config value by dot-path key (mutates cfg). */
+function setConfigValue(cfg, key, rawValue) {
+    assertSafeConfigKey(key);
+    // Coerce to number or boolean when applicable
+    let value = rawValue;
+    if (rawValue === 'true')
+        value = true;
+    else if (rawValue === 'false')
+        value = false;
+    else {
+        const num = Number(rawValue);
+        if (!isNaN(num) && rawValue.trim() !== '')
+            value = num;
+    }
+    setByPath(cfg, key, value);
+}
+// ─── Command: index ───────────────────────────────────────────────────────────
+function cmdIndex(args) {
+    const refresh = args.includes('--refresh');
+    const cfg = loadConfig();
+    let idx = loadIndex();
+    if (!idx || refresh) {
+        if (refresh && idx) {
+            console.error(dim('Refreshing index…'));
+        }
+        else {
+            console.error(dim('Building index…'));
+        }
+        idx = buildIndex(cfg);
+        writeIndex(idx);
+    }
+    const { items } = idx;
+    // Count by category
+    const byCat = new Map();
+    for (const item of items) {
+        const cat = item.category ?? '(uncategorized)';
+        byCat.set(cat, (byCat.get(cat) ?? 0) + 1);
+    }
+    const sortedCats = [...byCat.entries()].sort((a, b) => b[1] - a[1]);
+    const maxCat = Math.max(...sortedCats.map(([c]) => c.length), 12);
+    console.log('');
+    console.log(bold('  ashlr index') + gray(` — ${items.length} items, built ${new Date(idx.generatedAt).toLocaleString()}`));
+    console.log('');
+    console.log(`  ${bold(pad('Category', maxCat))}  ${bold(pad('Items', 6, 'right'))}`);
+    console.log(`  ${'─'.repeat(maxCat)}  ${'─'.repeat(6)}`);
+    for (const [cat, count] of sortedCats) {
+        console.log(`  ${cyan(pad(cat, maxCat))}  ${pad(String(count), 6, 'right')}`);
+    }
+    console.log('');
+    console.log(`  ${bold('Total:')} ${items.length} items across ${byCat.size} categories`);
+    const repos = items.filter(i => i.kind === 'repo');
+    const active = repos.filter(i => i.active);
+    console.log(`  ${dim(`${repos.length} repos (${active.length} active)`)}`);
+    console.log('');
+}
+// ─── Command: go ─────────────────────────────────────────────────────────────
+async function cmdGo(args) {
+    const openFlag = args.includes('--open');
+    const cdFlag = args.includes('--cd');
+    const queryArgs = args.filter(a => !a.startsWith('--'));
+    const query = queryArgs.join(' ');
+    const cfg = loadConfig();
+    const idx = requireIndex(cfg);
+    const candidates = filterItems(idx.items, query);
+    let chosen = null;
+    if (candidates.length === 0 && query) {
+        die(`No items match "${query}".`);
+    }
+    else if (candidates.length === 1) {
+        chosen = candidates[0];
+    }
+    else {
+        // Let user pick (fzf or readline)
+        chosen = await pick(candidates.length > 0 ? candidates : idx.items);
+    }
+    if (!chosen) {
+        die('Nothing selected.', 1);
+    }
+    if (openFlag) {
+        openInEditor(chosen.path, cfg);
+        console.log(green('opened: ') + chosen.path);
+    }
+    else if (cdFlag) {
+        // Print path only — caller shell function can eval $(ashlr go ... --cd)
+        process.stdout.write(chosen.path + '\n');
+    }
+    else {
+        // Print a summary
+        printItemSummary(chosen);
+    }
+}
+function printItemSummary(item) {
+    console.log('');
+    console.log(`  ${bold(item.name)}  ${dim(item.kind)}  ${item.category ? cyan(item.category) : ''}`);
+    console.log(`  ${gray(item.path)}`);
+    if (item.description) {
+        console.log(`  ${item.description}`);
+    }
+    if (item.git) {
+        const g = item.git;
+        const dirtyStr = g.dirty > 0 ? red(`${g.dirty} dirty`) : green('clean');
+        const syncStr = g.ahead > 0 || g.behind > 0
+            ? yellow(`↑${g.ahead} ↓${g.behind}`)
+            : green('in sync');
+        console.log(`  git: ${cyan(g.branch)}  ${dirtyStr}  ${syncStr}  last commit: ${relativeTime(g.lastCommit)}`);
+    }
+    if (item.linkTarget) {
+        console.log(`  ${dim('→')} ${item.linkTarget}`);
+    }
+    console.log(`  last modified: ${relativeTime(item.lastModified)}`);
+    console.log('');
+}
+// ─── Command: status ─────────────────────────────────────────────────────────
+async function cmdStatus(_args) {
+    const cfg = loadConfig();
+    const idx = requireIndex(cfg);
+    const repos = idx.items.filter(i => i.kind === 'repo' && i.git);
+    const dirty = repos.filter(i => (i.git?.dirty ?? 0) > 0);
+    const offSync = repos.filter(i => !dirty.includes(i) && ((i.git?.ahead ?? 0) > 0 || (i.git?.behind ?? 0) > 0));
+    const stale = repos.filter(i => !dirty.includes(i) &&
+        !offSync.includes(i) &&
+        daysSince(i.lastModified) > cfg.staleDays);
+    const nameW = 30;
+    const branchW = 18;
+    const gitW = 16;
+    const timeW = 14;
+    function printRepoTable(items) {
+        if (items.length === 0) {
+            console.log(`  ${dim('(none)')}`);
+            return;
+        }
+        console.log(`  ${bold(pad('Repo', nameW))}  ` +
+            `${bold(pad('Branch', branchW))}  ` +
+            `${bold(pad('Git', gitW))}  ` +
+            `${bold(pad('Last commit', timeW))}`);
+        console.log(`  ${'─'.repeat(nameW)}  ${'─'.repeat(branchW)}  ${'─'.repeat(gitW)}  ${'─'.repeat(timeW)}`);
+        for (const item of items) {
+            const g = item.git;
+            const dirtyStr = g.dirty > 0
+                ? red(`${g.dirty}`)
+                : '';
+            const syncStr = g.ahead > 0 || g.behind > 0
+                ? yellow(`↑${g.ahead} ↓${g.behind}`)
+                : '';
+            const gitCol = [dirtyStr, syncStr].filter(Boolean).join('  ') || green('ok');
+            console.log(`  ${pad(cyan(item.name), nameW)}  ` +
+                `${pad(g.branch, branchW)}  ` +
+                `${pad(gitCol, gitW)}  ` +
+                `${relativeTime(g.lastCommit)}`);
+        }
+    }
+    console.log('');
+    console.log(bold('  ashlr status') + gray(` — ${repos.length} repos tracked`));
+    console.log('');
+    if (dirty.length > 0) {
+        console.log(bold(red(`  Dirty (${dirty.length})`)));
+        printRepoTable(dirty);
+        console.log('');
+    }
+    if (offSync.length > 0) {
+        console.log(bold(yellow(`  Off-sync (${offSync.length})`)));
+        printRepoTable(offSync);
+        console.log('');
+    }
+    if (stale.length > 0) {
+        console.log(bold(gray(`  Stale — >  ${cfg.staleDays}d (${stale.length})`)));
+        printRepoTable(stale);
+        console.log('');
+    }
+    const cleanActive = repos.filter(i => !dirty.includes(i) && !offSync.includes(i) && !stale.includes(i));
+    console.log(`  ${green(`${cleanActive.length} clean`)}  ` +
+        `${red(`${dirty.length} dirty`)}  ` +
+        `${yellow(`${offSync.length} off-sync`)}  ` +
+        `${gray(`${stale.length} stale`)}`);
+    console.log('');
+    // ── M3 Ecosystem summary (graceful degradation if modules not yet built) ──
+    const [getToolsRegistryFn, discoverMcpServersFn] = await Promise.all([
+        tryGetToolsRegistry(),
+        tryDiscoverMcpServers(),
+    ]);
+    const ecosystemParts = [];
+    if (getToolsRegistryFn) {
+        try {
+            const reg = getToolsRegistryFn();
+            const installedNames = reg.tools
+                .filter(t => t.installed)
+                .map(t => t.id)
+                .slice(0, 5); // show up to 5 names; remainder implied by count
+            const moreCount = reg.installedCount - installedNames.length;
+            const nameList = installedNames.join(', ') + (moreCount > 0 ? `, +${moreCount}` : '');
+            ecosystemParts.push(`${bold('Tools:')} ${cyan(`${reg.installedCount}/${reg.tools.length} installed`)}` +
+                (installedNames.length > 0 ? ` ${dim('—')} ${gray(nameList)}` : ''));
+        }
+        catch {
+            // silently skip on error
+        }
+    }
+    if (discoverMcpServersFn) {
+        try {
+            const mcpReg = discoverMcpServersFn();
+            ecosystemParts.push(`${bold('MCP servers:')} ${cyan(`${mcpReg.servers.length} discovered`)}`);
+        }
+        catch {
+            // silently skip on error
+        }
+    }
+    if (ecosystemParts.length > 0) {
+        console.log(`  ${ecosystemParts.join(`  ${dim('·')}  `)}`);
+        console.log('');
+    }
+    // ── M5 Activity summary (best-effort; silently skipped on error) ──────────
+    try {
+        const buildRollupFn = await tryBuildRollup();
+        if (buildRollupFn) {
+            const rollup = buildRollupFn('7d', cfg);
+            const t = rollup.totals;
+            const tokK = ((t.tokensIn + t.tokensOut) / 1000).toFixed(1);
+            const cost = t.estCostUsd.toFixed(2);
+            const BUDGET_SUFFIX = {
+                over: `  ${red('● over budget')}`,
+                warn: `  ${yellow('● near cap')}`,
+            };
+            const budgetSuffix = BUDGET_SUFFIX[rollup.budget.level] ?? '';
+            console.log(`  ${bold('Activity (7d):')} ${cyan(`${t.sessions} sessions`)}  ${dim('·')}  ` +
+                `${cyan(`${tokK}k tokens`)}  ${dim('·')}  ` +
+                `${cyan(`$${cost}`)}  ${dim('·')}  ` +
+                `${cyan(`${t.commits} commits`)}` +
+                budgetSuffix);
+            console.log('');
+        }
+    }
+    catch {
+        // silently omit — never break status
+    }
+    // ── M7 Genome summary (best-effort; silently omitted on error) ────────────
+    try {
+        const genomeMod = await import('../core/genome/store.js');
+        const health = genomeMod.genomeHealth(cfg);
+        console.log(`  ${bold('Memory:')} ${cyan(`${health.totalEntries} genome entries`)} across ` +
+            `${cyan(`${health.projects} project${health.projects !== 1 ? 's' : ''}`)}` +
+            (health.embeddingsAvailable ? `  ${dim('·')}  ${gray('embeddings available')}` : ''));
+        console.log('');
+    }
+    catch {
+        // silently omit — genome may not be built yet; never break status
+    }
+    // ── M18 GitHub / Vercel / Identity one-liners (best-effort; never break status) ──
+    // All reads are bounded (reuse installed CLIs; they own auth) and silently
+    // omitted when not applicable (not a gh repo, no vercel link, not logged in).
+    const cwd = process.cwd();
+    // GitHub: only surface when cwd is a gh repo
+    try {
+        const ghStatusFn = await tryGithubStatus();
+        if (ghStatusFn) {
+            const gs = ghStatusFn(cwd);
+            if (gs.isRepo) {
+                const ciStr = gs.ci === 'passing'
+                    ? green('CI passing')
+                    : gs.ci === 'failing'
+                        ? red('CI failing')
+                        : gs.ci === 'pending'
+                            ? yellow('CI pending')
+                            : dim('no CI');
+                const repoLabel = gs.repo ? gray(` (${gs.repo})`) : '';
+                console.log(`  ${bold('GitHub:')} ${cyan(`${gs.openPrs} open PR${gs.openPrs !== 1 ? 's' : ''}`)}` +
+                    `  ${dim('·')}  ${cyan(`${gs.openIssues} open issue${gs.openIssues !== 1 ? 's' : ''}`)}` +
+                    `  ${dim('·')}  ${ciStr}${repoLabel}`);
+                console.log('');
+            }
+        }
+    }
+    catch {
+        // silently omit — never break status
+    }
+    // Vercel: only surface when a project is linked
+    try {
+        const vcStatusFn = await tryVercelStatus();
+        if (vcStatusFn) {
+            const vs = vcStatusFn(cwd);
+            if (vs.linked) {
+                const stateStr = vs.latestState
+                    ? (vs.latestState === 'READY' ? green(vs.latestState) : yellow(vs.latestState))
+                    : dim('unknown');
+                const urlStr = vs.url ? `  ${dim('·')}  ${cyan(vs.url)}` : '';
+                console.log(`  ${bold('Vercel:')} ${stateStr}${urlStr}`);
+                console.log('');
+            }
+        }
+    }
+    catch {
+        // silently omit — never break status
+    }
+    // Identity: only surface when phantom is logged in
+    try {
+        const identityFn = await tryGetIdentity();
+        if (identityFn) {
+            const id = identityFn();
+            if (id.loggedIn && id.user) {
+                const tierStr = id.tier ? `  ${dim('·')}  tier ${cyan(id.tier)}` : '';
+                const teamStr = id.team ? `  ${dim('·')}  team ${cyan(id.team)}` : '';
+                console.log(`  ${bold('You:')} ${cyan(id.user)}${tierStr}${teamStr}`);
+                console.log('');
+            }
+        }
+    }
+    catch {
+        // silently omit — never break status
+    }
+}
+// ─── Command: ls ─────────────────────────────────────────────────────────────
+function cmdLs(args) {
+    const catFilter = args.filter(a => !a.startsWith('--'))[0] ?? null;
+    const cfg = loadConfig();
+    const idx = requireIndex(cfg);
+    let items = idx.items;
+    if (catFilter) {
+        const q = catFilter.toLowerCase();
+        items = items.filter(i => (i.category ?? '').toLowerCase() === q);
+        if (items.length === 0) {
+            // Partial match fallback
+            items = idx.items.filter(i => (i.category ?? '').toLowerCase().includes(q));
+        }
+        if (items.length === 0) {
+            die(`No items found in category "${catFilter}".`);
+        }
+    }
+    const nameW = Math.min(40, Math.max(10, ...items.map(i => i.name.length)));
+    const kindW = 10;
+    const catW = 16;
+    console.log('');
+    console.log(`  ${bold(pad('Name', nameW))}  ${bold(pad('Kind', kindW))}  ${bold(pad('Category', catW))}  ${bold('Description')}`);
+    console.log(`  ${'─'.repeat(nameW)}  ${'─'.repeat(kindW)}  ${'─'.repeat(catW)}  ${'─'.repeat(30)}`);
+    // Sort: repos first, then by category, then by name
+    const sorted = [...items].sort((a, b) => {
+        if (a.kind === 'repo' && b.kind !== 'repo')
+            return -1;
+        if (a.kind !== 'repo' && b.kind === 'repo')
+            return 1;
+        const catCmp = (a.category ?? '').localeCompare(b.category ?? '');
+        if (catCmp !== 0)
+            return catCmp;
+        return a.name.localeCompare(b.name);
+    });
+    for (const item of sorted) {
+        const kindColor = item.kind === 'repo' ? cyan : item.kind === 'symlink' ? magenta : gray;
+        const activeMarker = item.kind === 'repo' && item.active ? green('●') : dim('○');
+        const desc = item.description ? dim(item.description.slice(0, 50)) : '';
+        console.log(`  ${activeMarker} ${pad(item.name, nameW - 2)}  ` +
+            `${pad(kindColor(item.kind), kindW)}  ` +
+            `${pad(item.category ?? dim('—'), catW)}  ` +
+            desc);
+    }
+    console.log('');
+    console.log(`  ${dim(`${sorted.length} items${catFilter ? ` in "${catFilter}"` : ''}`)}`);
+    console.log('');
+}
+// ─── Command: open ────────────────────────────────────────────────────────────
+async function cmdOpen(args) {
+    const query = args.filter(a => !a.startsWith('--')).join(' ');
+    const cfg = loadConfig();
+    const idx = requireIndex(cfg);
+    let chosen = null;
+    if (query) {
+        const candidates = filterItems(idx.items, query);
+        if (candidates.length === 0) {
+            die(`No items match "${query}".`);
+        }
+        // Take top match directly if score is unambiguous, else pick
+        chosen = candidates[0];
+    }
+    else {
+        chosen = await pick(idx.items);
+    }
+    if (!chosen) {
+        die('Nothing selected.', 1);
+    }
+    openInEditor(chosen.path, cfg);
+    console.log(green('opened: ') + chosen.path);
+}
+// ─── Command: tidy ────────────────────────────────────────────────────────────
+function cmdTidy(args) {
+    const apply = args.includes('--apply');
+    const json = args.includes('--json');
+    const cfg = loadConfig();
+    const plan = planTidy(cfg);
+    // ── Machine output ──────────────────────────────────────────────────────
+    // With --json, emit ONLY the TidyPlan as JSON on stdout with zero color or
+    // log noise. The Raycast "Tidy Desktop" command relies on this contract.
+    // Supports `--json --apply` to apply first, then emit the post-apply plan.
+    if (json) {
+        if (apply) {
+            applyTidy(plan);
+            // Recompute so the emitted plan reflects the new (tidied) state.
+            const after = planTidy(cfg);
+            process.stdout.write(JSON.stringify(after));
+        }
+        else {
+            process.stdout.write(JSON.stringify(plan));
+        }
+        return;
+    }
+    const fromW = 50;
+    const toW = 50;
+    if (plan.moves.length === 0 && plan.skipped.length === 0) {
+        console.log('');
+        console.log(`  ${green('Nothing to tidy.')} Desktop is already organized.`);
+        console.log('');
+        return;
+    }
+    if (plan.moves.length > 0) {
+        console.log('');
+        console.log(bold(apply ? '  Applying tidy moves:' : '  Tidy dry-run (use --apply to execute):'));
+        console.log('');
+        console.log(`  ${bold(pad('From', fromW))}  ${bold(pad('To', toW))}  ${bold('Rule')}`);
+        console.log(`  ${'─'.repeat(fromW)}  ${'─'.repeat(toW)}  ${'─'.repeat(20)}`);
+        for (const move of plan.moves) {
+            // Show relative-ish paths
+            const fromShort = move.from.replace(process.env['HOME'] ?? '', '~');
+            const toShort = move.to.replace(process.env['HOME'] ?? '', '~');
+            console.log(`  ${pad(fromShort, fromW)}  ${cyan(pad(toShort, toW))}  ${dim(move.rule)}`);
+        }
+        console.log('');
+    }
+    if (plan.skipped.length > 0) {
+        console.log(`  ${dim(`Skipped ${plan.skipped.length} path(s):`)}`);
+        for (const s of plan.skipped) {
+            const shortPath = s.path.replace(process.env['HOME'] ?? '', '~');
+            console.log(`  ${dim(pad(shortPath, fromW))}  ${gray(s.reason)}`);
+        }
+        console.log('');
+    }
+    if (apply) {
+        applyTidy(plan);
+        console.log(green(`  Applied ${plan.moves.length} move(s).`));
+        console.log('');
+    }
+    else if (plan.moves.length > 0) {
+        console.log(`  ${yellow(`${plan.moves.length} move(s) planned.`)} Run with ${bold('--apply')} to execute.`);
+        console.log('');
+    }
+}
+// ─── Command: config ─────────────────────────────────────────────────────────
+function cmdConfig(args) {
+    const subCmd = args[0];
+    const cfg = loadConfig();
+    if (!subCmd || subCmd === 'path') {
+        console.log(CONFIG_PATH);
+        return;
+    }
+    if (subCmd === 'get') {
+        const key = args[1];
+        if (!key)
+            die('Usage: ashlr config get <key>', 2);
+        const val = getConfigValue(cfg, key);
+        if (val === undefined) {
+            die(`Key "${key}" not found in config.`);
+        }
+        if (isSensitiveKey(key)) {
+            console.log('<redacted>');
+        }
+        else {
+            console.log(typeof val === 'object' ? JSON.stringify(val, null, 2) : String(val));
+        }
+        return;
+    }
+    if (subCmd === 'set') {
+        const key = args[1];
+        // --json flag: the token immediately after --json is the JSON value
+        const jsonFlagIdx = args.indexOf('--json');
+        const hasJsonFlag = jsonFlagIdx !== -1;
+        const jsonValue = hasJsonFlag ? args[jsonFlagIdx + 1] : undefined;
+        // Plain scalar value: args[2] when --json is not present
+        const rawValue = hasJsonFlag ? undefined : args[2];
+        if (!key)
+            die('Usage: ashlr config set <key> <value>', 2);
+        assertSafeConfigKey(key);
+        const topKey = key.split('.')[0];
+        // Keys that must never be overwritten with a coerced scalar string.
+        const STRUCTURED_KEYS = new Set([
+            'keepers', 'tidyRules', 'roots', 'categories', 'models', 'telemetry', 'tools', 'phantom',
+        ]);
+        const existing = getConfigValue(cfg, key);
+        const isStructured = Array.isArray(existing) || (existing !== null && typeof existing === 'object');
+        if (STRUCTURED_KEYS.has(topKey) && isStructured) {
+            // Structured path — require --json with a value
+            if (!hasJsonFlag || jsonValue === undefined) {
+                die(`Key "${key}" holds a structured value (array/object) and cannot be ` +
+                    `set with a plain scalar.\n` +
+                    `Use --json to set it:\n` +
+                    `  ashlr config set ${key} --json '${JSON.stringify(existing)}'`, 2);
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(jsonValue);
+            }
+            catch {
+                die(`Invalid JSON for "${key}": ${jsonValue}`, 2);
+            }
+            // Walk to the parent object and set the leaf key
+            setByPath(cfg, key, parsed);
+            saveConfig(cfg);
+            const shown = isSensitiveKey(key) ? '<redacted>' : JSON.stringify(parsed);
+            console.log(`${green('set')} ${key} = ${shown}`);
+            return;
+        }
+        // Scalar path: --json is allowed but not required
+        if (hasJsonFlag && jsonValue !== undefined) {
+            let parsed;
+            try {
+                parsed = JSON.parse(jsonValue);
+            }
+            catch {
+                die(`Invalid JSON for "${key}": ${jsonValue}`, 2);
+            }
+            setByPath(cfg, key, parsed);
+            saveConfig(cfg);
+            const shown = isSensitiveKey(key) ? '<redacted>' : JSON.stringify(parsed);
+            console.log(`${green('set')} ${key} = ${shown}`);
+            return;
+        }
+        if (rawValue === undefined)
+            die(`Usage: ashlr config set <key> <value>`, 2);
+        setConfigValue(cfg, key, rawValue);
+        saveConfig(cfg);
+        const shown = isSensitiveKey(key) ? '<redacted>' : rawValue;
+        console.log(`${green('set')} ${key} = ${shown}`);
+        return;
+    }
+    // No sub-command: print a formatted summary
+    console.log('');
+    console.log(bold('  ashlr config') + gray(` — ${CONFIG_PATH}`));
+    console.log('');
+    console.log(`  ${bold(pad('editor', 20))}  ${cyan(cfg.editor)}`);
+    console.log(`  ${bold(pad('staleDays', 20))}  ${cfg.staleDays}`);
+    console.log(`  ${bold(pad('roots', 20))}  ${cfg.roots.map(r => r.replace(process.env['HOME'] ?? '', '~')).join(', ')}`);
+    console.log(`  ${bold(pad('categories', 20))}  ${Object.keys(cfg.categories).join(', ')}`);
+    console.log(`  ${bold(pad('keepers', 20))}  ${cfg.keepers.length} entries`);
+    console.log(`  ${bold(pad('tidyRules', 20))}  ${cfg.tidyRules.length} rules`);
+    console.log('');
+}
+// ─── Command: help ────────────────────────────────────────────────────────────
+/**
+ * M32: help moved to src/cli/help.ts (topic-grouped, searchable, --all).
+ * This thin wrapper keeps `ashlr help` working even if the module is missing.
+ */
+async function cmdHelp(rest = []) {
+    try {
+        const mod = await import('./help.js');
+        await mod.cmdHelp(rest);
+    }
+    catch {
+        console.log('ashlr — local-first command center. Run a command or see the README.');
+    }
+}
+// ─── Top-level dispatch ───────────────────────────────────────────────────────
+async function main() {
+    const argv = process.argv.slice(2);
+    // ── Internal background-worker entry point ──────────────────────────────
+    // When `cmdSwarm --background` spawns a detached worker it re-invokes the
+    // CLI as: `ashlr --_worker swarm --resume <id> [...]`
+    // Strip the flag and route as if the user typed `ashlr swarm --resume <id>`.
+    const workerFlagIdx = argv.indexOf('--_worker');
+    if (workerFlagIdx !== -1) {
+        argv.splice(workerFlagIdx, 1); // remove --_worker in-place
+    }
+    const cmd = argv[0] ?? 'help';
+    const rest = argv.slice(1);
+    try {
+        switch (cmd) {
+            case 'index':
+                cmdIndex(rest);
+                break;
+            case 'go':
+                await cmdGo(rest);
+                break;
+            case 'status':
+                await cmdStatus(rest);
+                break;
+            case 'ls':
+                cmdLs(rest);
+                break;
+            case 'open':
+                await cmdOpen(rest);
+                break;
+            case 'tidy':
+                cmdTidy(rest);
+                break;
+            case 'config':
+                cmdConfig(rest);
+                break;
+            case 'doctor':
+                process.exitCode = await cmdDoctor(rest);
+                break;
+            case 'init':
+                process.exitCode = await cmdInit(rest);
+                break;
+            case 'mcp': {
+                const cmdMcp = await loadMcpCmd();
+                process.exitCode = await cmdMcp(rest);
+                break;
+            }
+            case 'run': {
+                // --no-memory is passed through to cmdRun as-is; run.ts parses it
+                // into RunOptions.noMemory for the orchestrator's genome injection gate.
+                const cmdRun = await loadRunCmd();
+                process.exitCode = await cmdRun(rest);
+                break;
+            }
+            case 'runs': {
+                const cmdRuns = await loadRunsCmd();
+                process.exitCode = await cmdRuns(rest);
+                break;
+            }
+            case 'pulse': {
+                const cmdPulse = await loadPulseCmd();
+                process.exitCode = await cmdPulse(rest);
+                break;
+            }
+            case 'new': {
+                const cmdNew = await loadNewCmd();
+                process.exitCode = await cmdNew(rest);
+                break;
+            }
+            case 'ship': {
+                const cmdShip = await loadShipCmd();
+                process.exitCode = await cmdShip(rest);
+                break;
+            }
+            case 'recall': {
+                const cmdRecall = await loadRecallCmd();
+                process.exitCode = await cmdRecall(rest);
+                break;
+            }
+            case 'learn': {
+                const cmdLearn = await loadLearnCmd();
+                process.exitCode = await cmdLearn(rest);
+                break;
+            }
+            case 'genome': {
+                const cmdGenome = await loadGenomeCmd();
+                process.exitCode = await cmdGenome(rest);
+                break;
+            }
+            case 'update': {
+                const cmdUpdate = await loadUpdateCmd();
+                process.exitCode = await cmdUpdate(rest);
+                break;
+            }
+            case 'spec': {
+                const cmdSpec = await loadSpecCmd();
+                process.exitCode = await cmdSpec(rest);
+                break;
+            }
+            case 'swarm': {
+                // Internal --_worker flag: a detached background process spawned by
+                // cmdSwarm --background re-invokes the CLI with this flag to resume
+                // and drive the swarm without a TTY. Route directly to cmdSwarm which
+                // handles the --resume path (the worker argv is passed through as-is).
+                const cmdSwarm = await loadSwarmCmd();
+                process.exitCode = await cmdSwarm(rest);
+                break;
+            }
+            case 'swarms': {
+                const cmdSwarms = await loadSwarmsCmd();
+                process.exitCode = await cmdSwarms(rest);
+                break;
+            }
+            case 'tui':
+            case 'dash': {
+                const cmdTui = await loadTuiCmd();
+                process.exitCode = await cmdTui(rest);
+                break;
+            }
+            case 'serve': {
+                const cmdServe = await loadServeCmd();
+                process.exitCode = await cmdServe(rest);
+                break;
+            }
+            case 'models': {
+                const cmdModels = await loadModelsCmd();
+                process.exitCode = await cmdModels(rest);
+                break;
+            }
+            case 'gh': {
+                const cmdGh = await loadGhCmd();
+                process.exitCode = await cmdGh(rest);
+                break;
+            }
+            case 'vercel': {
+                const cmdVercel = await loadVercelCmd();
+                process.exitCode = await cmdVercel(rest);
+                break;
+            }
+            case 'wire': {
+                const cmdWire = await loadWireCmd();
+                process.exitCode = await cmdWire(rest);
+                break;
+            }
+            case 'notify': {
+                const cmdNotify = await loadNotifyCmd();
+                process.exitCode = await cmdNotify(rest);
+                break;
+            }
+            case 'telemetry': {
+                const cmdTelemetry = await loadTelemetryCmd();
+                process.exitCode = await cmdTelemetry(rest);
+                break;
+            }
+            case 'sandbox': {
+                const cmdSandbox = await loadSandboxCmd();
+                process.exitCode = await cmdSandbox(rest);
+                break;
+            }
+            case 'audit': {
+                const cmdAudit = await loadAuditCmd();
+                process.exitCode = await cmdAudit(rest);
+                break;
+            }
+            case 'enroll': {
+                const cmdEnroll = await loadEnrollCmd();
+                process.exitCode = await cmdEnroll(rest);
+                break;
+            }
+            case 'backlog': {
+                const cmdBacklog = await loadBacklogCmd();
+                process.exitCode = await cmdBacklog(rest);
+                break;
+            }
+            case 'inbox': {
+                const cmdInbox = await loadInboxCmd();
+                process.exitCode = await cmdInbox(rest);
+                break;
+            }
+            case 'daemon': {
+                const cmdDaemon = await loadDaemonCmd();
+                process.exitCode = await cmdDaemon(rest);
+                break;
+            }
+            case 'ask': {
+                const cmdAsk = await loadAskCmd();
+                process.exitCode = await cmdAsk(rest);
+                break;
+            }
+            case 'knowledge': {
+                const cmdKnowledge = await loadKnowledgeCmd();
+                process.exitCode = await cmdKnowledge(rest);
+                break;
+            }
+            case 'reflect': {
+                const cmdReflect = await loadReflectCmd();
+                process.exitCode = await cmdReflect(rest);
+                break;
+            }
+            case 'health': {
+                const cmdHealth = await loadHealthCmd();
+                process.exitCode = await cmdHealth(rest);
+                break;
+            }
+            case 'goals': {
+                const cmdGoals = await loadGoalsCmd();
+                process.exitCode = await cmdGoals(rest);
+                break;
+            }
+            case 'digest': {
+                const cmdDigest = await loadDigestCmd();
+                process.exitCode = await cmdDigest(rest);
+                break;
+            }
+            case 'seams': {
+                const cmdSeams = await loadSeamsCmd();
+                process.exitCode = await cmdSeams(rest);
+                break;
+            }
+            case 'verify-safety': {
+                const cmdVerifySafety = await loadVerifySafetyCmd();
+                process.exitCode = await cmdVerifySafety(rest);
+                break;
+            }
+            case 'preflight': {
+                const cmdPreflight = await loadPreflightCmd();
+                process.exitCode = await cmdPreflight(rest);
+                break;
+            }
+            case 'onboard': {
+                const cmdOnboard = await loadOnboardCmd();
+                process.exitCode = await cmdOnboard(rest);
+                break;
+            }
+            case 'demo': {
+                const cmdDemo = await loadDemoCmd();
+                process.exitCode = await cmdDemo(rest);
+                break;
+            }
+            case 'orient': {
+                const cmdOrient = await loadOrientCmd();
+                process.exitCode = await cmdOrient(rest);
+                break;
+            }
+            case 'docs': {
+                const cmdDocs = await loadDocsCmd();
+                process.exitCode = await cmdDocs(rest);
+                break;
+            }
+            case 'completions': {
+                const cmdCompletions = await loadCompletionsCmd();
+                process.exitCode = await cmdCompletions(rest);
+                break;
+            }
+            case 'plugins': {
+                const cmdPlugins = await loadPluginsCmd();
+                process.exitCode = await cmdPlugins(rest);
+                break;
+            }
+            case 'x': {
+                const cmdX = await loadXCmd();
+                process.exitCode = await cmdX(rest);
+                break;
+            }
+            case 'help':
+            case '--help':
+            case '-h':
+                await cmdHelp(rest);
+                break;
+            default: {
+                console.error(red(`Unknown command: ${cmd}`));
+                // M31: "did you mean" — best-effort, never blocks the error path.
+                try {
+                    const { didYouMean } = await import('./completions.js');
+                    const suggestion = didYouMean(cmd);
+                    if (suggestion)
+                        console.error(`Did you mean ${cyan(`ashlr ${suggestion}`)}?`);
+                }
+                catch { /* suggestion is best-effort */ }
+                console.error(dim('Run `ashlr help` for usage.'));
+                process.exit(2);
+            }
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        // Distinguish "not implemented" stubs from real errors
+        if (msg.includes('not implemented')) {
+            die(`Module not yet implemented: ${msg}\nThis command depends on a core module that hasn't been built yet.`);
+        }
+        die(msg);
+    }
+}
+// Run — top-level await is fine in ESM with Node 22
+await main();
+//# sourceMappingURL=index.js.map