aiden-runtime 4.5.0 → 4.6.1

package/dist/cli/v4/commands/spawnPause.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/spawnPause.ts — v4.6 Phase 3A.
+ *
+ * `/spawn-pause on|off|status [reason...]` — operator kill-switch
+ * for sub-agent spawning. Backed by a file marker at
+ * `$aidenHome/spawn.paused` (see `core/v4/subagent/spawnPause.ts`)
+ * so REPL + daemon + MCP server all coordinate via the same state.
+ *
+ *   /spawn-pause on                  — pause, no reason
+ *   /spawn-pause on runaway-fanout   — pause, reason="runaway-fanout"
+ *   /spawn-pause on deploy window    — pause, reason="deploy window"
+ *   /spawn-pause off                 — resume
+ *   /spawn-pause status              — current state + reason + duration
+ *
+ * Unlike `/planner-guard`, `/sandbox`, etc., this command does NOT
+ * route through `runtimeToggles` — pause state is file-marker-
+ * backed (cross-process visibility) with first-class
+ * reason/pausedAt/pausedBy metadata that the boolean toggle surface
+ * can't carry. Mirrors plannerGuard.ts's command shape; diverges
+ * from `_runtimeToggleHelpers` because the storage backend is
+ * different.
+ *
+ * Hard contract: in-flight children are NEVER cancelled by this
+ * command. Pause affects only NEW spawns. Operators who want to
+ * stop in-flight runs use `aiden runs interrupt <runId>` (the
+ * existing per-run cancellation surface from v4.5 Phase 6).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnPause = void 0;
+const spawnPause_1 = require("../../../core/v4/subagent/spawnPause");
+/** Format a duration in ms as a compact `Xs` / `Xm` / `Xh` string. */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${Math.round(ms / 1000)}s`;
+    if (ms < 3600000)
+        return `${Math.round(ms / 60000)}m`;
+    return `${Math.round(ms / 3600000)}h`;
+}
+exports.spawnPause = {
+    name: 'spawn-pause',
+    description: 'Pause/resume sub-agent spawning (in-flight children continue).',
+    category: 'system',
+    icon: '⏸',
+    handler: async (ctx) => {
+        const action = (ctx.args[0] ?? 'status').toLowerCase();
+        const reasonArg = ctx.args.slice(1).join(' ').trim() || null;
+        let state;
+        try {
+            state = (0, spawnPause_1.getSpawnPause)();
+        }
+        catch (e) {
+            ctx.display.printError('spawn-pause: not initialized — REPL boot did not wire the singleton.', e instanceof Error ? e.message : String(e));
+            return {};
+        }
+        if (action === 'on' || action === 'enable' || action === 'true' || action === '1') {
+            state.pause({ reason: reasonArg, pausedBy: 'repl' });
+            const s = state.status();
+            const reasonLine = s.reason ? `   reason: ${s.reason}\n` : '';
+            ctx.display.write(`spawn-pause: ON\n${reasonLine}`);
+            ctx.display.dim('  in-flight children continue. New spawn_sub_agent / subagent_fanout calls will reject.');
+            return {};
+        }
+        if (action === 'off' || action === 'disable' || action === 'false' || action === '0' || action === 'resume') {
+            state.resume();
+            ctx.display.write('spawn-pause: OFF (resumed)\n');
+            return {};
+        }
+        if (action === 'status' || action === '') {
+            const s = state.status();
+            if (!s.paused) {
+                ctx.display.write('spawn-pause: OFF\n');
+                return {};
+            }
+            const reasonLine = s.reason ? `   reason:    ${s.reason}\n` : '';
+            const durationLine = s.durationMs !== undefined ? `   duration:  ${formatDuration(s.durationMs)}\n` : '';
+            const pausedAtLine = s.pausedAt ? `   pausedAt:  ${new Date(s.pausedAt).toISOString()}\n` : '';
+            const pausedByLine = s.pausedBy ? `   pausedBy:  ${s.pausedBy}\n` : '';
+            ctx.display.write(`spawn-pause: ON\n${reasonLine}${durationLine}${pausedAtLine}${pausedByLine}`);
+            return {};
+        }
+        ctx.display.printError('Usage: /spawn-pause on [reason...] | off | status');
+        return {};
+    },
+};

package/dist/cli/v4/commands/walkthrough.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/walkthrough.ts — ONB1 slice 10.
+ *
+ * `/walkthrough` — 5-screen guided tour of what Aiden can do. Pointed
+ * at by the first-run hint banner (slice 9) but available any time.
+ *
+ * Each screen:
+ *   1. A short title + one paragraph describing a capability area.
+ *   2. A "Try this now" example prompt the user can run verbatim.
+ *   3. A muted line on what tools/skills will fire.
+ *
+ * Screens:
+ *   1. Files & shell
+ *   2. Browser & web
+ *   3. Memory & SOUL
+ *   4. Skills & MCP
+ *   5. Operator controls
+ *
+ * Navigation: the command renders all five screens in order with
+ * separator lines between, then drops back to the REPL. No interactive
+ * paging — the user can scroll the buffer if they want to revisit
+ * something. Re-running `/walkthrough` is cheap.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkthrough = void 0;
+const theme_1 = require("../../../core/v4/ui/theme");
+const SCREENS = [
+    {
+        title: 'Files & shell',
+        body: [
+            'Aiden can read, patch, and organise files on your machine, and run',
+            'shell commands when a task needs the OS. Patches go through a diff',
+            'preview before anything writes to disk.',
+        ],
+        tryThis: 'summarize the files in this folder and flag anything stale',
+        fires: 'file_read · shell · diff_preview',
+    },
+    {
+        title: 'Browser & web',
+        body: [
+            'Persistent Chromium session for navigation, screenshots, form fill,',
+            'and content extraction. The browser stays warm across turns so the',
+            'agent can chain research steps without re-logging in.',
+        ],
+        tryThis: 'research the top three local-first AI tools and save a comparison to notes.md',
+        fires: 'open_browser · browser_extract · file_write',
+    },
+    {
+        title: 'Memory & SOUL',
+        body: [
+            'Aiden remembers across sessions via SOUL.md (identity), MEMORY.md',
+            '(curated notes), and the sessions database. `/identity` shows what',
+            'persona is loaded; edit SOUL.md to shape it.',
+        ],
+        tryThis: 'remember that I prefer concise replies and Python over TypeScript',
+        fires: 'memory_write · session_log',
+    },
+    {
+        title: 'Skills & MCP',
+        body: [
+            'Skills are bundled workflows (graphify, voice, kanban, more). MCP',
+            'servers extend the toolset further — each MCP exposes its own tools',
+            'as if they were native. `/skills` lists what is loaded; `/tools` lists',
+            'every active tool.',
+        ],
+        tryThis: '/skills',
+        fires: '(no agent call — local registry walk)',
+    },
+    {
+        title: 'Operator controls',
+        body: [
+            'You stay in charge. `/spawn-pause on` halts sub-agent spawning;',
+            '`/recovery list` shows what Aiden has learned from past failures;',
+            '`/doctor` prints a health snapshot; `/quit` exits cleanly.',
+        ],
+        tryThis: '/doctor',
+        fires: '(no agent call — local self-check)',
+    },
+];
+function wrap(text, width) {
+    const words = text.split(/\s+/);
+    const lines = [];
+    let cur = '';
+    for (const w of words) {
+        if (!cur) {
+            cur = w;
+            continue;
+        }
+        if (cur.length + 1 + w.length > width) {
+            lines.push(cur);
+            cur = w;
+        }
+        else
+            cur += ' ' + w;
+    }
+    if (cur)
+        lines.push(cur);
+    return lines;
+}
+function renderScreen(ctx, screen, idx, total) {
+    const out = ctx.display;
+    const w = (0, theme_1.termWidth)();
+    const bodyW = Math.min(w - 6, 72);
+    out.write('\n  ' + (0, theme_1.separator)(Math.min(w - 4, 64)) + '\n\n');
+    out.write('  ' + theme_1.c.muted(`(${idx + 1}/${total})`) + '  ' + (0, theme_1.bold)(theme_1.c.primary(screen.title)) + '\n\n');
+    const joined = screen.body.join(' ');
+    for (const line of wrap(joined, bodyW)) {
+        out.write('  ' + theme_1.c.text(line) + '\n');
+    }
+    out.write('\n');
+    out.write('  ' + theme_1.c.muted('Try this now:') + '\n');
+    out.write('  ' + theme_1.c.accent('▸ ') + theme_1.c.accent(screen.tryThis) + '\n');
+    out.write('  ' + (0, theme_1.italic)(theme_1.c.muted(`fires: ${screen.fires}`)) + '\n');
+}
+exports.walkthrough = {
+    name: 'walkthrough',
+    description: '5-screen guided tour of what Aiden can do.',
+    category: 'system',
+    icon: '🧭',
+    aliases: ['tour', 'tutorial'],
+    handler: async (ctx) => {
+        const w = (0, theme_1.termWidth)();
+        ctx.display.write('\n');
+        ctx.display.write('  ' + (0, theme_1.bold)(theme_1.c.primary('Aiden walkthrough')) + '\n');
+        ctx.display.write('  ' + theme_1.c.muted('Five short screens. Each ends with a prompt you can copy-paste into chat.') + '\n');
+        for (let i = 0; i < SCREENS.length; i++) {
+            renderScreen(ctx, SCREENS[i], i, SCREENS.length);
+        }
+        ctx.display.write('\n  ' + (0, theme_1.separator)(Math.min(w - 4, 64)) + '\n');
+        ctx.display.write('  ' + theme_1.c.muted('That\'s the tour. Type something — Aiden is listening.') + '\n\n');
+        return {};
+    },
+};

package/dist/cli/v4/daemonAgentBuilder.js

@@ -87,7 +87,10 @@ function buildDaemonAgentBuilder(deps) {
         };
         const agent = new aidenAgent_1.AidenAgent({
             provider: adapter,
-            tools: deps.toolRegistry.getSchemas(),
+            // v4.6 Phase 1 — 'daemon' context filter excludes REPL-only
+            // tools (`spawn_sub_agent` per Q6). Tools without an explicit
+            // `contexts` field stay visible to both REPL and daemon.
+            tools: deps.toolRegistry.getSchemas(undefined, 'daemon'),
             toolExecutor: deps.toolExecutor,
             maxTurns,
             auxiliaryClient: deps.auxiliaryClient,

package/dist/cli/v4/defaultSoul.js

@@ -30,7 +30,7 @@ exports.PREVIOUS_BUNDLED_SOULS = exports.DEFAULT_SOUL_MD = exports.BUNDLED_SOUL_
 // <act_dont_ask>. ensureSoulMdSeeded compares this against the user's
 // on-disk SOUL.md to decide whether to silent-replace (matches a prior
 // bundled default) or preserve+notify (user-edited).
-exports.BUNDLED_SOUL_VERSION = 'v4.5.0';
+exports.BUNDLED_SOUL_VERSION = 'v4.6.0';
 exports.DEFAULT_SOUL_MD = `You are Aiden — a local-first AI agent built by Shiva Deore at Taracod.
 
 Identity:

package/dist/cli/v4/onboarding/disclaimer.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/onboarding/disclaimer.ts — ONB1 slice 3.
+ *
+ * First screen of the redesigned first-run experience. Renders the
+ * framed AIDEN banner + tagline + credits + a single-paragraph
+ * disclaimer paragraph + Y/n prompt. Default Y. Typing 'n' or 'N'
+ * exits with a friendly goodbye line; ENTER (or 'y'/'Y') advances.
+ *
+ * Caller is responsible for branching on the returned `ok` boolean.
+ * This function NEVER calls process.exit — keeps it testable, and
+ * the parent (aidenCLI) controls the exit code centrally.
+ *
+ * TTY guard: non-TTY callers (systemd / launchd / CI / pipe) return
+ * `{ ok: true, skipped: true }` immediately so the wider boot path
+ * falls through to explore-mode wiring as today.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showDisclaimer = showDisclaimer;
+const readline = __importStar(require("node:readline"));
+const banner_1 = require("../../../core/v4/ui/banner");
+const theme_1 = require("../../../core/v4/ui/theme");
+const version_1 = require("../../../core/version");
+const DISCLAIMER_PARA = 'Aiden is a semi-autonomous AI agent that can touch your files, ' +
+    'browser, and shell. Open source — read the code if you want. ' +
+    'Started as a hobby project, built solo, still rough in spots.';
+/**
+ * Word-wrap `text` to `width` columns. Preserves single spaces; does
+ * not handle ANSI codes (callers pass plain text here).
+ */
+function wrap(text, width) {
+    const words = text.split(/\s+/);
+    const lines = [];
+    let current = '';
+    for (const w of words) {
+        if (!current) {
+            current = w;
+            continue;
+        }
+        if (current.length + 1 + w.length > width) {
+            lines.push(current);
+            current = w;
+        }
+        else {
+            current += ' ' + w;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines;
+}
+/**
+ * Clear the screen if stdout is a TTY. No-op otherwise.
+ */
+function clearScreen(out) {
+    if (!out.isTTY)
+        return;
+    out.write('\x1b[2J\x1b[H');
+}
+/**
+ * Render the disclaimer body — banner + separator + wrapped paragraph.
+ * Pure renderer; caller owns the write.
+ */
+function renderDisclaimerBody(version) {
+    const w = (0, theme_1.termWidth)();
+    const body = [];
+    body.push((0, banner_1.renderBanner)({ version }));
+    body.push('  ' + (0, theme_1.separator)(Math.min(w - 4, 64)) + '\n');
+    body.push('\n');
+    const indent = '  ';
+    for (const line of wrap(DISCLAIMER_PARA, Math.min(w - 4, 70))) {
+        body.push(indent + theme_1.c.text(line) + '\n');
+    }
+    body.push('\n');
+    return body.join('');
+}
+/**
+ * Read a single line from stdin. Resolves with the trimmed input.
+ * Rejects on close-without-input (typical when stdin is closed under us).
+ */
+function promptYesNo(inStream, outStream, question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: inStream, output: outStream });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve((answer ?? '').trim());
+        });
+    });
+}
+/**
+ * Show the disclaimer screen and collect Y/n. ENTER == accept; 'n'/'N'
+ * == decline. Anything else also counts as accept (matches Claude
+ * Code / Codex defaults — users hammer enter and expect to advance).
+ */
+async function showDisclaimer(opts = {}) {
+    const out = opts.out ?? process.stdout;
+    const inStream = opts.in ?? process.stdin;
+    const version = opts.version ?? version_1.VERSION;
+    // Non-TTY: skip the prompt entirely. Caller falls through to whatever
+    // non-interactive path is appropriate (explore mode in aidenCLI today).
+    if (!out.isTTY || !inStream.isTTY) {
+        return { ok: true, skipped: true };
+    }
+    clearScreen(out);
+    out.write(renderDisclaimerBody(version));
+    const question = '  ' + theme_1.c.accent('Continue?') + ' ' + theme_1.c.muted('[Y/n] ');
+    const answer = await promptYesNo(inStream, out, question);
+    if (answer === 'n' || answer === 'N' || answer.toLowerCase() === 'no') {
+        out.write('\n  ' + theme_1.c.muted('No problem — run `aiden` anytime to come back.') + '\n\n');
+        return { ok: false, reason: 'user-declined' };
+    }
+    return { ok: true };
+}
+// ---------------------------------------------------------------------------
+// Direct invocation for visual smoke test:
+//   npx ts-node cli/v4/onboarding/disclaimer.ts
+// ---------------------------------------------------------------------------
+if (require.main === module) {
+    showDisclaimer().then((r) => {
+        process.stdout.write(`\n[result] ${JSON.stringify(r)}\n`);
+        process.exit(r.ok ? 0 : 1);
+    });
+}

package/dist/cli/v4/onboarding/loading.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/onboarding/loading.ts — ONB1 slice 4.
+ *
+ * Animated multi-step loading screen rendered AFTER the disclaimer
+ * accept and BEFORE the provider picker. Each step does real work
+ * (no sleep-only fakery); the spinner shows for at least 300ms per
+ * step so the user actually perceives motion. Spinner replaces with
+ * a green ✓ on success or red ✗ on failure; right-aligned status
+ * text gives the answer (e.g. "Node v22 · Windows 11", "74 loaded").
+ *
+ *     Setting up Aiden...
+ *
+ *       ✓ Checking system           Node v22 · Windows 11      [180ms]
+ *       ✓ Loading skills            74 loaded                  [640ms]
+ *       ✓ Initializing tools        60 tools                   [310ms]
+ *       ✓ Configuring memory        ~/.aiden/ created          [420ms]
+ *
+ *       ────────────────────────────────────────────────────────────
+ *
+ * Step contract: each step is a sync-or-async function returning
+ * `{ status: string }` (the right-aligned answer). Throwing converts
+ * to ✗ with the error message as status; the runner continues to
+ * subsequent steps so a single failure doesn't strand the user.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLoadingSequence = runLoadingSequence;
+exports.defaultLoadingSteps = defaultLoadingSteps;
+const node_os_1 = __importDefault(require("node:os"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const theme_1 = require("../../../core/v4/ui/theme");
+const paths_1 = require("../../../core/v4/paths");
+const MIN_SPINNER_MS = 300;
+const SPIN_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPIN_INTERVAL = 80;
+function rowGeom(width) {
+    const inner = Math.min(width - 4, 70);
+    const labelCol = Math.floor(inner * 0.45);
+    const statusCol = inner - labelCol;
+    return { labelCol, statusCol };
+}
+function rpad(s, n) {
+    return s.length >= n ? s : s + ' '.repeat(n - s.length);
+}
+function lpad(s, n) {
+    return s.length >= n ? s : ' '.repeat(n - s.length) + s;
+}
+/**
+ * Run all steps sequentially and render the live multi-row pane.
+ * Non-TTY: emits one line per step on completion with no spinner.
+ */
+async function runLoadingSequence(steps, opts = {}) {
+    const out = opts.out ?? process.stdout;
+    const heading = opts.heading ?? 'Setting up Aiden...';
+    const w = (0, theme_1.termWidth)();
+    const { labelCol, statusCol } = rowGeom(w);
+    const isTty = !!out.isTTY;
+    const results = [];
+    if (!isTty) {
+        out.write(`${heading}\n`);
+        for (const step of steps) {
+            const t0 = Date.now();
+            try {
+                const r = await step.run();
+                const ms = Date.now() - t0;
+                results.push({ label: step.label, ok: true, status: r.status, ms });
+                out.write(`  ok  ${step.label}  ${r.status}  [${ms}ms]\n`);
+            }
+            catch (err) {
+                const ms = Date.now() - t0;
+                const msg = err instanceof Error ? err.message : String(err);
+                results.push({ label: step.label, ok: false, status: msg, ms });
+                out.write(`  err ${step.label}  ${msg}  [${ms}ms]\n`);
+            }
+        }
+        return { ok: results.every((r) => r.ok), steps: results };
+    }
+    out.write('\n  ' + theme_1.c.text(heading) + '\n\n');
+    // Pre-paint placeholder rows so the spinner overwrites in place.
+    for (const step of steps) {
+        const line = '  ' + theme_1.c.muted('·') + ' ' + rpad(step.label, labelCol) +
+            ' ' + theme_1.c.muted(lpad('—', statusCol));
+        out.write(line + '\n');
+    }
+    // Walk back up to the top of the block.
+    out.write(`\x1b[${steps.length}A`);
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const t0 = Date.now();
+        let frame = 0;
+        const spinner = setInterval(() => {
+            const glyph = theme_1.c.primary(SPIN_FRAMES[frame % SPIN_FRAMES.length]);
+            out.write('\x1b[2K\r  ' + glyph + ' ' + theme_1.c.text(rpad(step.label, labelCol)));
+            frame += 1;
+        }, SPIN_INTERVAL);
+        let ok = true;
+        let status = '';
+        try {
+            const r = await step.run();
+            status = r.status;
+        }
+        catch (err) {
+            ok = false;
+            status = err instanceof Error ? err.message : String(err);
+        }
+        // Enforce a minimum perceptible spinner duration.
+        const elapsed = Date.now() - t0;
+        if (elapsed < MIN_SPINNER_MS) {
+            await new Promise((r) => setTimeout(r, MIN_SPINNER_MS - elapsed));
+        }
+        clearInterval(spinner);
+        const ms = Date.now() - t0;
+        const glyph = ok ? theme_1.c.success('✓') : theme_1.c.error('✗');
+        const statusText = ok ? theme_1.c.muted(status) : theme_1.c.error(status);
+        const timing = theme_1.c.muted(`[${ms}ms]`);
+        const row = '  ' + glyph + ' ' + theme_1.c.text(rpad(step.label, labelCol)) +
+            ' ' + lpad(statusText, statusCol) + '  ' + timing;
+        out.write('\x1b[2K\r' + row + '\n');
+        results.push({ label: step.label, ok, status, ms });
+    }
+    out.write('\n  ' + (0, theme_1.separator)(Math.min(w - 4, 64)) + '\n');
+    return { ok: results.every((r) => r.ok), steps: results };
+}
+// ---------------------------------------------------------------------------
+// Default step set — the real-work pipeline used by the wizard entry point.
+// Exported so the wizard composer can extend / reorder; the smoke test
+// also reuses these to verify the real numbers shown match disk state.
+// ---------------------------------------------------------------------------
+function defaultLoadingSteps(paths) {
+    const resolved = paths ?? (0, paths_1.resolveAidenPaths)();
+    return [
+        {
+            label: 'Checking system',
+            run: () => {
+                const nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
+                if (!Number.isFinite(nodeMajor) || nodeMajor < 18) {
+                    throw new Error(`Node ${process.versions.node} (need 18+)`);
+                }
+                const plat = process.platform === 'win32'
+                    ? `Windows ${node_os_1.default.release().split('.')[0]}`
+                    : process.platform === 'darwin'
+                        ? `macOS ${node_os_1.default.release()}`
+                        : `${process.platform} ${node_os_1.default.release()}`;
+                return { status: `Node v${nodeMajor} · ${plat}` };
+            },
+        },
+        {
+            label: 'Loading skills',
+            run: async () => {
+                // Walk skills/ at repo root + user dir; count SKILL.md files.
+                let count = 0;
+                const dirs = [
+                    node_path_1.default.join(process.cwd(), 'skills'),
+                    resolved.skillsDir,
+                ];
+                for (const d of dirs) {
+                    try {
+                        const entries = await node_fs_1.promises.readdir(d, { withFileTypes: true });
+                        for (const e of entries) {
+                            if (!e.isDirectory())
+                                continue;
+                            try {
+                                await node_fs_1.promises.access(node_path_1.default.join(d, e.name, 'SKILL.md'));
+                                count += 1;
+                            }
+                            catch { /* not a skill — skip */ }
+                        }
+                    }
+                    catch { /* directory missing — skip */ }
+                }
+                return { status: `${count} available` };
+            },
+        },
+        {
+            label: 'Initializing tools',
+            run: async () => {
+                // Best-effort tool count: read the tools/v4/index source as a
+                // text count of registrations. Cheap and good enough for the
+                // "60 tools" status — avoids loading the tool registry itself.
+                try {
+                    const src = await node_fs_1.promises.readFile(node_path_1.default.join(process.cwd(), 'tools', 'v4', 'index.ts'), 'utf8');
+                    const matches = src.match(/registerTool\s*\(/g) ?? [];
+                    return { status: `${matches.length || 0} registered` };
+                }
+                catch {
+                    return { status: 'registry ready' };
+                }
+            },
+        },
+        {
+            label: 'Configuring memory',
+            run: async () => {
+                await (0, paths_1.ensureAidenDirsExist)(resolved);
+                return { status: `${resolved.root} ready` };
+            },
+        },
+    ];
+}