aiden-runtime 4.1.5 → 4.5.0

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

@@ -0,0 +1,253 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/daemonStatus.ts — v4.5 Phase 8a.
+ *
+ * `/daemon status` — read-only slash variant of `aiden daemon
+ * status` (the top-level Phase 4b CLI surface). Renders an inline
+ * summary inside the REPL without leaving the chat. Points users
+ * at `aiden daemon install|start|stop` for any mutation.
+ *
+ * Q-P8a-3(a) inline format — five lines max when running, two
+ * lines when disabled. Reads daemon.db directly so the slash
+ * command works regardless of whether the daemon is the same
+ * process as the REPL.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.daemonStatus = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const daemon_1 = require("../../../core/v4/daemon");
+const paths_1 = require("../../../core/v4/paths");
+exports.daemonStatus = {
+    name: 'daemon',
+    description: 'Show v4.5 daemon status (read-only). Use `aiden daemon` for lifecycle.',
+    category: 'system',
+    icon: '⚙',
+    handler: async (ctx) => {
+        const sub = (ctx.args[0] ?? 'status').toLowerCase();
+        if (sub !== 'status') {
+            ctx.display.printError('Usage: /daemon status\n' +
+                'For lifecycle commands (install / start / stop / restart / logs), use the top-level CLI:\n' +
+                '  aiden daemon install\n' +
+                '  aiden daemon start\n' +
+                '  aiden daemon stop\n' +
+                '  aiden daemon status\n' +
+                '  aiden daemon logs');
+            return {};
+        }
+        try {
+            const snapshot = readSnapshot();
+            printSnapshot(snapshot, ctx);
+        }
+        catch (e) {
+            ctx.display.warn(`/daemon status: failed to read state (${e instanceof Error ? e.message : String(e)})`);
+        }
+        return {};
+    },
+};
+// ── Snapshot collector ─────────────────────────────────────────────────────
+function readSnapshot() {
+    const aidenRoot = (0, paths_1.resolveAidenRoot)();
+    const dbPath = (0, daemon_1.daemonDbPath)(aidenRoot);
+    const lockPath = (0, daemon_1.daemonRuntimeLockPath)(aidenRoot);
+    // ── Liveness via the in-process bootstrap handle first, then fall
+    // back to the runtime.lock PID check (covers the case where the
+    // daemon is another process and we're a REPL inspecting its db).
+    let running = false;
+    let instanceId = null;
+    let port = null;
+    let uptimeMs = null;
+    const handle = (0, daemon_1.getDaemonHandle)();
+    if (handle?.active && handle.instanceId) {
+        running = true;
+        instanceId = handle.instanceId;
+        port = (0, daemon_1.getDaemonConfig)().port;
+        if (handle.instanceTracker) {
+            // instanceTracker has a `getStartedAt` if exposed; otherwise
+            // derive from daemon_instances row below.
+        }
+    }
+    if (!running && node_fs_1.default.existsSync(lockPath)) {
+        try {
+            const lines = node_fs_1.default.readFileSync(lockPath, 'utf-8').split(/\r?\n/);
+            // runtime.lock format: [0]=instanceId, [1]=pid, [2]=port (Phase 1).
+            const lockedInstance = lines[0] ?? '';
+            const lockedPid = Number.parseInt(lines[1] ?? '', 10);
+            const lockedPort = Number.parseInt(lines[2] ?? '', 10);
+            if (Number.isFinite(lockedPid) && pidAlive(lockedPid)) {
+                running = true;
+                instanceId = lockedInstance || null;
+                if (Number.isFinite(lockedPort))
+                    port = lockedPort;
+            }
+        }
+        catch { /* stale or unreadable */ }
+    }
+    if (!node_fs_1.default.existsSync(dbPath)) {
+        return {
+            running: false,
+            port: null,
+            instanceId: null,
+            uptimeMs: null,
+            triggerCounts: { file: 0, webhook: 0, email: 0, schedule: 0, manual: 0 },
+            recentRuns: [],
+            bus: { pending: 0, claimed: 0, deadLetter: 0 },
+            dailyBudget: null,
+        };
+    }
+    const db = (0, daemon_1.openDaemonDb)(dbPath);
+    // Uptime from the instance row when we have an instanceId.
+    if (running && instanceId) {
+        try {
+            const row = db
+                .prepare('SELECT started_at, last_heartbeat FROM daemon_instances WHERE instance_id = ?')
+                .get(instanceId);
+            if (row)
+                uptimeMs = Date.now() - row.started_at;
+        }
+        catch { /* noop */ }
+    }
+    // Trigger counts by source.
+    const triggerCounts = { file: 0, webhook: 0, email: 0, schedule: 0, manual: 0 };
+    try {
+        const rows = db.prepare(`SELECT source, COUNT(*) AS c FROM triggers WHERE enabled = 1 GROUP BY source`).all();
+        for (const r of rows) {
+            if (r.source in triggerCounts) {
+                triggerCounts[r.source] = r.c;
+            }
+        }
+    }
+    catch { /* triggers table missing — schema v1 not applied */ }
+    // Recent runs (last 3).
+    const recentRuns = (() => {
+        try {
+            const rows = db.prepare(`SELECT id, status, finish_reason, started_at, completed_at FROM runs
+          ORDER BY id DESC LIMIT 3`).all();
+            return rows.map((r) => ({
+                id: r.id,
+                status: r.status,
+                finishReason: r.finish_reason,
+                durationMs: r.completed_at !== null ? r.completed_at - r.started_at : null,
+            }));
+        }
+        catch {
+            return [];
+        }
+    })();
+    // Bus stats.
+    const bus = (() => {
+        try {
+            const rows = db.prepare(`SELECT status, COUNT(*) AS c FROM trigger_events GROUP BY status`).all();
+            const m = {};
+            for (const r of rows)
+                m[r.status] = r.c;
+            return {
+                pending: m.pending ?? 0,
+                claimed: m.claimed ?? 0,
+                deadLetter: m.dead_letter ?? 0,
+            };
+        }
+        catch {
+            return { pending: 0, claimed: 0, deadLetter: 0 };
+        }
+    })();
+    // Daily budget (piggybacked on idempotency_keys per Phase 7).
+    const dailyBudget = (() => {
+        const budgetRaw = process.env.AIDEN_DAEMON_DAILY_BUDGET;
+        if (!budgetRaw)
+            return null;
+        const budget = Number.parseInt(budgetRaw, 10);
+        if (!Number.isFinite(budget) || budget <= 0)
+            return null;
+        try {
+            const today = new Date().toISOString().slice(0, 10);
+            const row = db.prepare(`SELECT response_json FROM idempotency_keys WHERE scope = ? AND key = ?`).get('daemon_budget', today);
+            let used = 0;
+            if (row) {
+                try {
+                    const parsed = JSON.parse(row.response_json);
+                    used = typeof parsed.used === 'number' ? parsed.used : 0;
+                }
+                catch { /* noop */ }
+            }
+            return { used, budget, exhausted: used >= budget };
+        }
+        catch {
+            return { used: 0, budget, exhausted: false };
+        }
+    })();
+    return {
+        running,
+        port,
+        instanceId,
+        uptimeMs,
+        triggerCounts,
+        recentRuns,
+        bus,
+        dailyBudget,
+    };
+}
+// ── Renderer ───────────────────────────────────────────────────────────────
+function printSnapshot(s, ctx) {
+    if (!s.running) {
+        ctx.display.write('Daemon: disabled.\n');
+        ctx.display.write('To enable: `aiden daemon install` (systemd / launchd) or `AIDEN_DAEMON=1` before `aiden`.\n');
+        return;
+    }
+    const uptime = s.uptimeMs !== null ? formatUptime(s.uptimeMs) : 'unknown';
+    const instanceShort = s.instanceId ? s.instanceId.slice(0, 8) : '?';
+    ctx.display.write(`Daemon: running (port ${s.port ?? '?'}, instance ${instanceShort}, uptime ${uptime})\n`);
+    const tc = s.triggerCounts;
+    ctx.display.write(`Triggers: ${tc.file} file · ${tc.webhook} webhook · ${tc.email} email · ${tc.schedule} schedule\n`);
+    if (s.recentRuns.length === 0) {
+        ctx.display.write('Recent runs (last 3): (none)\n');
+    }
+    else {
+        const parts = s.recentRuns.map((r) => {
+            const dur = r.durationMs !== null ? `(${(r.durationMs / 1000).toFixed(1)}s)` : '';
+            return `${r.status}${dur ? ' ' + dur : ''}`;
+        });
+        ctx.display.write(`Recent runs (last ${s.recentRuns.length}): ${parts.join(' · ')}\n`);
+    }
+    ctx.display.write(`Bus: ${s.bus.pending} pending · ${s.bus.claimed} claimed · ${s.bus.deadLetter} dead-letter\n`);
+    if (s.dailyBudget) {
+        const d = s.dailyBudget;
+        const exhaustedTag = d.exhausted ? ' EXHAUSTED' : '';
+        ctx.display.write(`Daily budget: ${d.used} / ${d.budget} tokens used (UTC ${new Date().toISOString().slice(0, 10)})${exhaustedTag}\n`);
+    }
+}
+function formatUptime(ms) {
+    const s = Math.floor(ms / 1000);
+    const days = Math.floor(s / 86400);
+    const hours = Math.floor((s % 86400) / 3600);
+    const mins = Math.floor((s % 3600) / 60);
+    if (days > 0)
+        return `${days}d ${hours}h`;
+    if (hours > 0)
+        return `${hours}h ${mins}m`;
+    return `${mins}m ${s % 60}s`;
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        // ESRCH = no such process; EPERM = process exists but we lack
+        // permission to signal it (still counts as alive).
+        return e.code === 'EPERM';
+    }
+}
+// Keep unused-import linter happy.
+void node_os_1.default;
+void node_path_1.default;

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

@@ -58,6 +58,13 @@ exports.SUBSECTION_MAP = {
     history: 'System',
     // Phase v4.1.2-update — npm self-update for the running install.
     update: 'System',
+    // v4.5 Phase 8a — subsystem live-flip slash commands.
+    sandbox: 'System',
+    tce: 'System',
+    'browser-depth': 'System',
+    daemon: 'System',
+    // v4.5 Phase 8b — contextual capability suggestions.
+    suggestions: 'System',
     // ── Authentication ──
     auth: 'Authentication',
     // ── Help ──

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

@@ -12,7 +12,7 @@
  * and registers each on the global CommandRegistry at boot.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.allCommands = exports.update = exports.reloadSoul = exports.history = exports.show = exports.status = exports.voice = exports.channel = exports.setup = exports.cron = exports.doctor = exports.license = exports.auth = exports.plugins = exports.streaming = exports.debugPrompt = exports.identity = exports.providers = exports.quit = exports.clear = exports.verbose = exports.reasoning = exports.reloadMcp = exports.skills = exports.skin = exports.yolo = exports.usage = exports.compress = exports.title = exports.save = exports.personality = exports.model = exports.tools = exports.help = void 0;
+exports.allCommands = exports.suggestions = exports.daemonStatus = exports.browserDepth = exports.tce = exports.sandbox = exports.update = exports.reloadSoul = exports.history = exports.show = exports.status = exports.voice = exports.channel = exports.setup = exports.cron = exports.doctor = exports.license = exports.auth = exports.plugins = exports.streaming = exports.debugPrompt = exports.identity = exports.providers = exports.quit = exports.clear = exports.verbose = exports.reasoning = exports.reloadMcp = exports.skills = exports.skin = exports.yolo = exports.usage = exports.compress = exports.title = exports.save = exports.personality = exports.model = exports.tools = exports.help = void 0;
 const help_1 = require("./help");
 Object.defineProperty(exports, "help", { enumerable: true, get: function () { return help_1.help; } });
 const tools_1 = require("./tools");
@@ -79,6 +79,18 @@ const reloadSoul_1 = require("./reloadSoul");
 Object.defineProperty(exports, "reloadSoul", { enumerable: true, get: function () { return reloadSoul_1.reloadSoul; } });
 const update_1 = require("./update");
 Object.defineProperty(exports, "update", { enumerable: true, get: function () { return update_1.update; } });
+// v4.5 Phase 8a — subsystem live-flip slash commands.
+const sandbox_1 = require("./sandbox");
+Object.defineProperty(exports, "sandbox", { enumerable: true, get: function () { return sandbox_1.sandbox; } });
+const tce_1 = require("./tce");
+Object.defineProperty(exports, "tce", { enumerable: true, get: function () { return tce_1.tce; } });
+const browserDepth_1 = require("./browserDepth");
+Object.defineProperty(exports, "browserDepth", { enumerable: true, get: function () { return browserDepth_1.browserDepth; } });
+const daemonStatus_1 = require("./daemonStatus");
+Object.defineProperty(exports, "daemonStatus", { enumerable: true, get: function () { return daemonStatus_1.daemonStatus; } });
+// v4.5 Phase 8b — contextual capability suggestions toggle.
+const suggestions_1 = require("./suggestions");
+Object.defineProperty(exports, "suggestions", { enumerable: true, get: function () { return suggestions_1.suggestions; } });
 /** All built-in system commands, in canonical order. */
 exports.allCommands = [
     help_1.help,
@@ -115,6 +127,13 @@ exports.allCommands = [
     // probe + shared executeInstall executor (also wired into
     // aiden_self_update tool for natural-language requests).
     update_1.update,
+    // v4.5 Phase 8a — subsystem live-flip slash commands.
+    sandbox_1.sandbox,
+    tce_1.tce,
+    browserDepth_1.browserDepth,
+    daemonStatus_1.daemonStatus,
+    // v4.5 Phase 8b — contextual suggestions toggle.
+    suggestions_1.suggestions,
     clear_1.clear,
     quit_1.quit,
 ];

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

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/runs.ts — v4.5 Phase 6: `aiden runs` command set.
+ *
+ * Surfaces the daemon's `runs` + `run_events` tables (Phase 1
+ * runStore) so operators can inspect daemon-fired turn history
+ * outside the REPL.
+ *
+ * Subcommands:
+ *   list    — recent runs; optional --limit / --source / --status filters
+ *   show    — full run row + all run_events for one runId
+ *   interrupt — request cancellation of a running turn (Q-P6-4a:
+ *               SIGUSR1 + marker file pattern)
+ *   stats   — aggregate counts by status + mean duration
+ *
+ * The `interrupt` path writes
+ * `~/.aiden/daemon/interrupt-<runId>.req` and signals the daemon
+ * via SIGUSR1. The dispatcher polls the marker directory on each
+ * lease-renew tick (~60s) and cancels runs whose marker exists.
+ * This matches the existing SIGUSR1 → exit 75 restart contract
+ * and keeps cancellation signal-driven rather than DB-poll.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRunsSubcommand = runRunsSubcommand;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const daemon_1 = require("../../../core/v4/daemon");
+const paths_1 = require("../../../core/v4/paths");
+const noopOut = (s) => { process.stdout.write(s); };
+const noopErr = (s) => { process.stderr.write(s); };
+async function runRunsSubcommand(action, args, argv, opts = {}) {
+    const out = opts.writeOut ?? noopOut;
+    const err = opts.writeErr ?? noopErr;
+    const aidenRoot = (0, paths_1.resolveAidenRoot)();
+    const db = (0, daemon_1.openDaemonDb)((0, daemon_1.daemonDbPath)(aidenRoot));
+    const runStore = (0, daemon_1.createRunStore)({ db });
+    switch (action) {
+        case 'list': return cmdList(runStore, argv, out);
+        case 'show': return cmdShow(runStore, args[0], out, err);
+        case 'interrupt': return cmdInterrupt(args[0], aidenRoot, out, err);
+        case 'stats': return cmdStats(db, out);
+        default:
+            err(`Unknown runs action: ${action}\n`);
+            err('Actions: list, show <runId>, interrupt <runId>, stats\n');
+            return 2;
+    }
+}
+// ── list ──────────────────────────────────────────────────────────────────
+function cmdList(runStore, argv, out) {
+    const allowedStatuses = new Set([
+        'queued', 'running', 'completed', 'failed', 'cancelled', 'interrupted',
+    ]);
+    const status = argv.status && allowedStatuses.has(argv.status)
+        ? argv.status
+        : undefined;
+    const rows = runStore.listRecent({
+        limit: argv.limit ?? 50,
+        status,
+        source: argv.source,
+        sessionIdPrefix: argv.trigger,
+    });
+    if (rows.length === 0) {
+        out('No runs match the filter.\n');
+        return 0;
+    }
+    out(`${'runId'.padEnd(6)}  ${'status'.padEnd(11)}  ${'finish'.padEnd(11)}  ${'started'.padEnd(20)}  sessionId\n`);
+    for (const r of rows) {
+        const started = new Date(r.startedAt).toISOString().slice(0, 19) + 'Z';
+        const finish = r.finishReason ?? '-';
+        out(`${String(r.id).padEnd(6)}  ${r.status.padEnd(11)}  ${finish.padEnd(11)}  ${started.padEnd(20)}  ${r.sessionId}\n`);
+    }
+    out(`\n${rows.length} run${rows.length === 1 ? '' : 's'} shown\n`);
+    return 0;
+}
+// ── show ──────────────────────────────────────────────────────────────────
+function cmdShow(runStore, rawId, out, err) {
+    if (!rawId) {
+        err('runs show: runId required\n');
+        return 2;
+    }
+    const runId = Number.parseInt(rawId, 10);
+    if (!Number.isFinite(runId) || runId <= 0) {
+        err(`runs show: invalid runId: ${rawId}\n`);
+        return 2;
+    }
+    const row = runStore.get(runId);
+    if (!row) {
+        err(`runs show: not found: ${runId}\n`);
+        return 1;
+    }
+    const events = runStore.listEvents(runId, 500);
+    out(JSON.stringify({
+        run: row,
+        events: events.map((e) => ({
+            ts: new Date(e.ts).toISOString(),
+            kind: e.kind,
+            payload: safeParse(e.payload),
+        })),
+    }, null, 2) + '\n');
+    return 0;
+}
+function safeParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+// ── interrupt ─────────────────────────────────────────────────────────────
+function cmdInterrupt(rawId, aidenRoot, out, err) {
+    if (!rawId) {
+        err('runs interrupt: runId required\n');
+        return 2;
+    }
+    const runId = Number.parseInt(rawId, 10);
+    if (!Number.isFinite(runId) || runId <= 0) {
+        err(`runs interrupt: invalid runId: ${rawId}\n`);
+        return 2;
+    }
+    const markerDir = node_path_1.default.join(aidenRoot, 'daemon', 'interrupt');
+    try {
+        node_fs_1.default.mkdirSync(markerDir, { recursive: true });
+    }
+    catch (e) {
+        err(`runs interrupt: failed to create marker dir: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    const markerPath = node_path_1.default.join(markerDir, `${runId}.req`);
+    try {
+        node_fs_1.default.writeFileSync(markerPath, JSON.stringify({ runId, requestedAt: Date.now() }));
+    }
+    catch (e) {
+        err(`runs interrupt: failed to write marker: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    // Best-effort SIGUSR1 to the daemon. If the daemon isn't running,
+    // the marker is still there for whoever boots next — they'll find
+    // the run in `interrupted` state via the boot crash-recovery pass.
+    const lockPath = (0, daemon_1.daemonRuntimeLockPath)(aidenRoot);
+    let pid = null;
+    try {
+        if (node_fs_1.default.existsSync(lockPath)) {
+            const lines = node_fs_1.default.readFileSync(lockPath, 'utf-8').split(/\r?\n/);
+            // runtime.lock format: line 0 = instanceId, line 1 = pid, line 2 = port
+            const candidate = Number.parseInt(lines[1] ?? '', 10);
+            if (Number.isFinite(candidate))
+                pid = candidate;
+        }
+    }
+    catch { /* noop */ }
+    if (pid !== null && process.platform !== 'win32') {
+        try {
+            process.kill(pid, 'SIGUSR1');
+        }
+        catch { /* daemon may have died; marker still wins on next boot */ }
+    }
+    out(`runs interrupt: marker written at ${markerPath}\n`);
+    if (pid !== null && process.platform !== 'win32') {
+        out(`runs interrupt: SIGUSR1 sent to daemon pid=${pid}\n`);
+    }
+    else if (process.platform === 'win32') {
+        out('runs interrupt: SIGUSR1 not available on Windows — daemon picks up marker on next renew tick\n');
+    }
+    else {
+        out('runs interrupt: no live daemon found — marker will be honoured on next boot\n');
+    }
+    return 0;
+}
+// ── stats ─────────────────────────────────────────────────────────────────
+function cmdStats(db, out) {
+    const counts = db.prepare(`SELECT status, COUNT(*) AS c FROM runs GROUP BY status`).all();
+    const completed = db.prepare(`SELECT AVG(completed_at - started_at) AS mean,
+            MIN(completed_at - started_at) AS min,
+            MAX(completed_at - started_at) AS max,
+            COUNT(*) AS n
+       FROM runs
+      WHERE status = 'completed' AND completed_at IS NOT NULL`).get();
+    out('Run status counts:\n');
+    if (counts.length === 0) {
+        out('  (no runs recorded)\n');
+    }
+    for (const r of counts) {
+        out(`  ${r.status.padEnd(12)}  ${r.c}\n`);
+    }
+    if (completed.n > 0 && completed.mean !== null) {
+        out('\nCompleted-run duration (ms):\n');
+        out(`  mean  ${Math.round(completed.mean)}\n`);
+        out(`  min   ${completed.min}\n`);
+        out(`  max   ${completed.max}\n`);
+        out(`  n     ${completed.n}\n`);
+    }
+    return 0;
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/sandbox.ts — v4.5 Phase 8a.
+ *
+ * `/sandbox on|off|status` — flip the v4.4 execution sandbox
+ * (filesystem allow/deny + docker session backend + dryRun
+ * preflight) without restart. Persists to config.yaml
+ * (runtime_toggles.sandbox). Env var AIDEN_SANDBOX always wins
+ * over both — see runtimeToggles.ts for precedence rules.
+ *
+ * Q-P8a-4(a): /sandbox off flips silently. User explicitly typed
+ * the command and the status output makes the flip visible. The
+ * sandbox denylist (fs.sensitive_path) remains in effect for
+ * unmistakably dangerous paths regardless of the toggle —
+ * disabling the sandbox does NOT remove the always-on denylist.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandbox = void 0;
+const _runtimeToggleHelpers_1 = require("./_runtimeToggleHelpers");
+exports.sandbox = {
+    name: 'sandbox',
+    description: 'Toggle the v4.4 execution sandbox (file ACLs + docker tools).',
+    category: 'system',
+    icon: '🛡',
+    handler: async (ctx) => {
+        const sub = (0, _runtimeToggleHelpers_1.parseSubcommand)(ctx.args[0]);
+        if (sub === 'on') {
+            await (0, _runtimeToggleHelpers_1.flip)('sandbox', true, ctx);
+            return {};
+        }
+        if (sub === 'off') {
+            await (0, _runtimeToggleHelpers_1.flip)('sandbox', false, ctx);
+            return {};
+        }
+        if (sub === 'status') {
+            (0, _runtimeToggleHelpers_1.printStatus)('sandbox', ctx);
+            return {};
+        }
+        ctx.display.printError('Usage: /sandbox on|off|status');
+        return {};
+    },
+};

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

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/suggestions.ts — v4.5 Phase 8b.
+ *
+ * `/suggestions on|off|status` — flip the contextual capability
+ * suggestions surfaced by the suggestionEngine (Phase 8b). Reuses
+ * the Phase 8a `_runtimeToggleHelpers` since 'suggestions' is now
+ * a fourth ToggleKey on the runtimeToggles singleton.
+ *
+ *   /suggestions on      — re-enable tips (default).
+ *   /suggestions off     — silence tips for this REPL + persist to
+ *                          config.yaml (runtime_toggles.suggestions
+ *                          = false). Subsequent boots stay quiet
+ *                          until /suggestions on flips it back.
+ *   /suggestions status  — single-line state with source +
+ *                          fired-this-session count + budget remaining.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestions = void 0;
+const _runtimeToggleHelpers_1 = require("./_runtimeToggleHelpers");
+const runtimeToggles_1 = require("../../../core/v4/runtimeToggles");
+const suggestionEngine_1 = require("../../../core/v4/suggestionEngine");
+exports.suggestions = {
+    name: 'suggestions',
+    description: 'Toggle contextual one-line capability tips.',
+    category: 'system',
+    icon: '💡',
+    handler: async (ctx) => {
+        const sub = (0, _runtimeToggleHelpers_1.parseSubcommand)(ctx.args[0]);
+        if (sub === 'on') {
+            await (0, _runtimeToggleHelpers_1.flip)('suggestions', true, ctx);
+            return {};
+        }
+        if (sub === 'off') {
+            await (0, _runtimeToggleHelpers_1.flip)('suggestions', false, ctx);
+            // Also session-dismiss so the in-process engine stops firing
+            // immediately, not just after the next REPL restart picks up
+            // the new config value.
+            try {
+                (0, suggestionEngine_1.getSuggestionEngine)().dismissAll();
+            }
+            catch { /* defensive */ }
+            return {};
+        }
+        if (sub === 'status') {
+            const tog = (0, runtimeToggles_1.getRuntimeToggles)().snapshot().suggestions;
+            const snap = (0, suggestionEngine_1.getSuggestionEngine)().snapshot();
+            const state = tog.value ? 'ON' : 'OFF';
+            const dismissTag = snap.dismissedSession && tog.value ? ' (dismissed this session)' : '';
+            ctx.display.write(`Suggestions: ${state}   (source: ${tog.source})${dismissTag}\n`);
+            if (snap.firedSlots.length > 0) {
+                ctx.display.write(`  fired this session: ${snap.firedSlots.join(', ')} · budget remaining: ${snap.budgetRemaining}\n`);
+            }
+            else {
+                ctx.display.write(`  fired this session: (none) · budget remaining: ${snap.budgetRemaining}\n`);
+            }
+            return {};
+        }
+        ctx.display.printError('Usage: /suggestions on|off|status');
+        return {};
+    },
+};

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

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/tce.ts — v4.5 Phase 8a.
+ *
+ * `/tce on|off|status` — flip the v4.2 Tool-Call Effort recovery
+ * pipeline (verifier + failure classifier + recovery report)
+ * without restart. Persists to config.yaml. Env var AIDEN_TCE
+ * always wins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tce = void 0;
+const _runtimeToggleHelpers_1 = require("./_runtimeToggleHelpers");
+exports.tce = {
+    name: 'tce',
+    description: 'Toggle the v4.2 Tool-Call Effort recovery pipeline.',
+    category: 'system',
+    icon: '🔁',
+    handler: async (ctx) => {
+        const sub = (0, _runtimeToggleHelpers_1.parseSubcommand)(ctx.args[0]);
+        if (sub === 'on') {
+            await (0, _runtimeToggleHelpers_1.flip)('tce', true, ctx);
+            return {};
+        }
+        if (sub === 'off') {
+            await (0, _runtimeToggleHelpers_1.flip)('tce', false, ctx);
+            return {};
+        }
+        if (sub === 'status') {
+            (0, _runtimeToggleHelpers_1.printStatus)('tce', ctx);
+            return {};
+        }
+        ctx.display.printError('Usage: /tce on|off|status');
+        return {};
+    },
+};