aiden-runtime 4.1.5 → 4.6.0

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

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/plannerGuard.ts — v4.6 Phase 2M.
+ *
+ * `/planner-guard on|off|status` — flip the keyword-based per-turn
+ * tool narrower (`moat/plannerGuard.ts`) live, no restart needed.
+ *
+ * Default: OFF. Smart models (GPT-5.5, Claude Sonnet 4.5+, Opus)
+ * select tools fine from the full catalog every turn, the way the
+ * reference multi-agent systems do. Per-turn narrowing was a
+ * v4.1-era workaround for smaller local models that got overwhelmed
+ * by 50+ tool schemas — opt in for that case via env (set
+ * `AIDEN_PLANNER_GUARD=1` at boot) or this slash command.
+ *
+ * Persists to `runtime_toggles.planner_guard` in config.yaml when
+ * a ConfigManager is wired (the normal REPL path). Env var
+ * `AIDEN_PLANNER_GUARD` always wins over both — see runtimeToggles.ts.
+ *
+ * Mirrors `/sandbox`, `/tce`, `/browser-depth`, `/suggestions`
+ * verbatim — same helpers, same output shape.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plannerGuard = void 0;
+const _runtimeToggleHelpers_1 = require("./_runtimeToggleHelpers");
+exports.plannerGuard = {
+    name: 'planner-guard',
+    description: 'Toggle keyword-based per-turn tool narrowing (default OFF, opt-in).',
+    category: 'system',
+    icon: '🧭',
+    handler: async (ctx) => {
+        const sub = (0, _runtimeToggleHelpers_1.parseSubcommand)(ctx.args[0]);
+        if (sub === 'on') {
+            await (0, _runtimeToggleHelpers_1.flip)('planner_guard', true, ctx);
+            return {};
+        }
+        if (sub === 'off') {
+            await (0, _runtimeToggleHelpers_1.flip)('planner_guard', false, ctx);
+            return {};
+        }
+        if (sub === 'status') {
+            (0, _runtimeToggleHelpers_1.printStatus)('planner_guard', ctx);
+            return {};
+        }
+        ctx.display.printError('Usage: /planner-guard on|off|status');
+        return {};
+    },
+};

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

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/recovery.ts — v4.6 Phase 3b.
+ *
+ * `/recovery list [limit]`        — top N recurring failure patterns
+ * `/recovery show <signature>`    — details for one signature + reports
+ * `/recovery clear <signature>`   — operator says "fixed; stop counting"
+ *
+ * Backed by the v7 `failure_signatures` + `recovery_reports` tables
+ * via the `RecoveryStore` singleton (initialised at REPL/daemon/MCP
+ * boot). All three sub-actions degrade cleanly when the store isn't
+ * initialised — print a non-fatal error and return.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recovery = void 0;
+const recoveryStore_1 = require("../../../core/v4/selfimprovement/recoveryStore");
+/** Format a wall-clock ms timestamp as a compact UTC label. */
+function formatTs(ms) {
+    return new Date(ms).toISOString().slice(0, 19) + 'Z';
+}
+/** Right-pad to width; truncate with ellipsis when too long. */
+function pad(value, width) {
+    const s = String(value);
+    if (s.length === width)
+        return s;
+    if (s.length < width)
+        return s + ' '.repeat(width - s.length);
+    return s.slice(0, Math.max(0, width - 1)) + '…';
+}
+exports.recovery = {
+    name: 'recovery',
+    description: 'Inspect recurring failure patterns + recoveries (v4.6 Phase 3b).',
+    category: 'system',
+    icon: '🩹',
+    handler: async (ctx) => {
+        const action = (ctx.args[0] ?? 'list').toLowerCase();
+        const store = (0, recoveryStore_1.getRecoveryStore)();
+        if (!store) {
+            ctx.display.printError('recovery: recovery store not initialised — daemon DB unavailable?');
+            return {};
+        }
+        if (action === 'list') {
+            const limitArg = ctx.args[1];
+            const parsed = limitArg !== undefined ? Number.parseInt(limitArg, 10) : NaN;
+            const limit = Number.isFinite(parsed) && parsed > 0 ? parsed : 10;
+            const rows = store.listTopFailures(limit);
+            if (rows.length === 0) {
+                ctx.display.write('No recurring failures recorded yet.\n');
+                ctx.display.dim('  TCE writes failure signatures on classify; recoveries on failure→success transition.');
+                return {};
+            }
+            ctx.display.write(`${pad('signature', 50)}  ${pad('occur', 6)}  ${pad('recov', 6)}  last_strategy\n`);
+            for (const r of rows) {
+                ctx.display.write(`${pad(r.signature, 50)}  ${pad(r.occurrences, 6)}  ${pad(r.recoveredCount, 6)}  ${r.lastRecoveryStrategy ?? '-'}\n`);
+            }
+            ctx.display.write(`\n${rows.length} signature${rows.length === 1 ? '' : 's'} shown\n`);
+            return {};
+        }
+        if (action === 'show') {
+            const sig = ctx.args[1];
+            if (!sig) {
+                ctx.display.printError('Usage: /recovery show <signature>');
+                return {};
+            }
+            const row = store.getBySignature(sig);
+            if (!row) {
+                ctx.display.printError(`recovery: signature not found: ${sig}`);
+                return {};
+            }
+            ctx.display.write(`signature:        ${row.signature}\n`);
+            ctx.display.write(`tool_name:        ${row.toolName}\n`);
+            ctx.display.write(`failure_category: ${row.failureCategory}\n`);
+            ctx.display.write(`occurrences:      ${row.occurrences}\n`);
+            ctx.display.write(`recovered_count:  ${row.recoveredCount}\n`);
+            ctx.display.write(`first_seen:       ${formatTs(row.firstSeenAt)}\n`);
+            ctx.display.write(`last_seen:        ${formatTs(row.lastSeenAt)}\n`);
+            const reports = store.listReportsForSignature(row.id, 20);
+            if (reports.length === 0) {
+                ctx.display.dim('  (no recovery reports yet for this signature)');
+                return {};
+            }
+            ctx.display.write(`\nrecovery reports (${reports.length}, newest first):\n`);
+            for (const r of reports) {
+                ctx.display.write(`  [${formatTs(r.createdAt)}] strategy=${r.successfulStrategy}`);
+                if (r.failedAttempts !== undefined) {
+                    ctx.display.write(` failed=${r.failedAttempts}`);
+                }
+                if (r.sessionId)
+                    ctx.display.write(` session=${r.sessionId}`);
+                ctx.display.write('\n');
+                if (r.notes)
+                    ctx.display.dim(`    ${r.notes}`);
+                if (r.verification)
+                    ctx.display.dim(`    verified: ${r.verification}`);
+            }
+            return {};
+        }
+        if (action === 'clear') {
+            const sig = ctx.args[1];
+            if (!sig) {
+                ctx.display.printError('Usage: /recovery clear <signature>');
+                return {};
+            }
+            const ok = store.clearSignature(sig);
+            if (ok) {
+                ctx.display.write(`recovery: cleared signature ${sig}\n`);
+            }
+            else {
+                ctx.display.printError(`recovery: signature not found: ${sig}`);
+            }
+            return {};
+        }
+        ctx.display.printError('Usage: /recovery list [limit] | show <signature> | clear <signature>');
+        return {};
+    },
+};

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

@@ -0,0 +1,223 @@
+"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;
+    // v4.6 Phase 2Q-B — default `topLevelOnly: true` hides children.
+    // `--include-children` flag (parsed by the CLI argv layer into
+    // `includeChildren: true`) flips the predicate to drop the IS NULL
+    // filter so child rows appear inline with parents.
+    const includeChildren = argv.includeChildren === true;
+    const rows = runStore.listRecent({
+        limit: argv.limit ?? 50,
+        status,
+        source: argv.source,
+        sessionIdPrefix: argv.trigger,
+        topLevelOnly: !includeChildren,
+    });
+    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 ?? '-';
+        // v4.6 Phase 2Q-B — child-count badge. Only relevant for the
+        // top-level view (when --include-children is OFF). Skipped on
+        // the flat view to avoid double-counting visual weight: in flat
+        // mode the children are already on screen as their own rows.
+        let badge = '';
+        if (!includeChildren) {
+            const { total, completed } = runStore.countChildren(r.id);
+            if (total > 0) {
+                badge = `  (${total} ${total === 1 ? 'child' : 'children'}, ${completed} OK)`;
+            }
+        }
+        out(`${String(r.id).padEnd(6)}  ${r.status.padEnd(11)}  ${finish.padEnd(11)}  ${started.padEnd(20)}  ${r.sessionId}${badge}\n`);
+    }
+    const hint = includeChildren
+        ? ' (parents + sub-agent children)'
+        : ' (top-level; use --include-children for sub-agents)';
+    out(`\n${rows.length} run${rows.length === 1 ? '' : 's'} shown${hint}\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/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/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 {};
+    },
+};