@kinqs/brainrouter-cli 0.3.4

package/dist/cli/cliPrompt.d.ts

@@ -0,0 +1,15 @@
+import readline from 'node:readline';
+export declare function setActiveReadline(rl: readline.Interface | undefined): void;
+export declare function getActiveReadline(): readline.Interface | undefined;
+/**
+ * One-shot yes/no question. Returns true only when the user types y/yes
+ * (case-insensitive). Returns the supplied default when stdin isn't a TTY
+ * (e.g. piped non-interactive runs).
+ */
+export declare function askYesNo(question: string, defaultValue?: boolean): Promise<boolean>;
+/**
+ * Print a line of output while the prompt is showing, then redraw the prompt
+ * with whatever the user was mid-typing. Used by callbacks that fire while the
+ * REPL is idle (child agents that complete async after the parent turn ended).
+ */
+export declare function safePrintAbovePrompt(msg: string): void;

package/dist/cli/cliPrompt.js

@@ -0,0 +1,62 @@
+/**
+ * Shared bridge between the REPL's readline interface and modules outside
+ * repl.ts that need to (a) write above the prompt without scrambling input,
+ * or (b) ask the user a one-shot question while a turn is in progress
+ * (e.g. run_command approval).
+ *
+ * Previously this used `inquirer.prompt`. Inquirer creates its OWN readline
+ * interface attached to the same `process.stdin`, and on exit it leaves stray
+ * `line` events that the parent REPL then sees as "the user typed a new
+ * prompt while a turn is still running". Using the parent rl directly avoids
+ * that.
+ *
+ * Only one REPL exists per process, so a module-level pointer is fine.
+ */
+let activeReadline;
+export function setActiveReadline(rl) {
+    activeReadline = rl;
+}
+export function getActiveReadline() {
+    return activeReadline;
+}
+/**
+ * One-shot yes/no question. Returns true only when the user types y/yes
+ * (case-insensitive). Returns the supplied default when stdin isn't a TTY
+ * (e.g. piped non-interactive runs).
+ */
+export function askYesNo(question, defaultValue = false) {
+    if (!activeReadline || !process.stdin.isTTY) {
+        return Promise.resolve(defaultValue);
+    }
+    return new Promise((resolve) => {
+        const rl = activeReadline;
+        // The parent rl was paused by runAgentTurn; resume so it actually reads
+        // keystrokes. We re-pause once we have the answer.
+        rl.resume();
+        rl.question(question, (answer) => {
+            const lower = (answer ?? '').trim().toLowerCase();
+            const yes = lower === 'y' || lower === 'yes';
+            rl.pause();
+            resolve(yes);
+        });
+    });
+}
+/**
+ * Print a line of output while the prompt is showing, then redraw the prompt
+ * with whatever the user was mid-typing. Used by callbacks that fire while the
+ * REPL is idle (child agents that complete async after the parent turn ended).
+ */
+export function safePrintAbovePrompt(msg) {
+    if (!process.stdout.isTTY || !activeReadline) {
+        console.log(msg);
+        return;
+    }
+    process.stdout.write('\r\x1b[2K');
+    console.log(msg);
+    try {
+        activeReadline._refreshLine?.();
+    }
+    catch {
+        activeReadline.prompt(true);
+    }
+}

package/dist/cli/commands/_context.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared types + helper context that every slash-command handler receives.
+ *
+ * Split out from repl.ts so individual command files can be small and
+ * topical. Each category file (session/memory/workflow/orchestration/…)
+ * exports a `tryHandle*(ctx)` function that returns true iff it matched
+ * `ctx.command`. The dispatch table in repl.ts walks them in order until
+ * one returns true; if none do, the user gets the "unknown command"
+ * message.
+ *
+ * Adding a new command means: pick the right category file, add a
+ * `case '/foo':` to its switch, done. No need to edit repl.ts at all.
+ */
+import type readline from 'node:readline';
+import type { Agent } from '../../agent/agent.js';
+import type { McpClientWrapper } from '../../runtime/mcpClient.js';
+import type { Config } from '../../config/config.js';
+/**
+ * Lifecycle / REPL-scoped state that command handlers can read or mutate.
+ * Defined here (rather than inside the REPL closure) so commands stay in
+ * separate files without crossing closure boundaries. The REPL constructs
+ * one instance per session and threads it through every dispatch call.
+ */
+export interface ReplContext {
+    /** Refresh the readline prompt (color reflects access mode + status segments). */
+    refreshPromptForMode: () => void;
+    /** True while the REPL is mid-turn; loop ticks should defer when set. */
+    isProcessing: () => boolean;
+    /** Programmatically run an agent turn (used by /continue and friends). */
+    runAgentTurn: (prompt: string) => void;
+    /**
+     * Awaitable variant — same semantics but the caller can attach a .finally
+     * to do post-turn cleanup. Used by /side and /btw to restore the parent
+     * sessionKey after the side conversation finishes.
+     */
+    runAgentTurnAsync: (prompt: string) => Promise<void>;
+}
+/**
+ * Everything a command handler needs. Constructed once per dispatch in
+ * the REPL line handler and passed by reference into every category's
+ * try-handler.
+ */
+export interface CommandContext {
+    /** The raw slash command (e.g. `/spawn`), lowercased. */
+    command: string;
+    /** Arguments after the command, already split on whitespace. */
+    args: string[];
+    agent: Agent;
+    mcpClient: McpClientWrapper;
+    config: Config;
+    rl: readline.Interface;
+    repl: ReplContext;
+}

package/dist/cli/commands/_context.js

@@ -0,0 +1,14 @@
+/**
+ * Shared types + helper context that every slash-command handler receives.
+ *
+ * Split out from repl.ts so individual command files can be small and
+ * topical. Each category file (session/memory/workflow/orchestration/…)
+ * exports a `tryHandle*(ctx)` function that returns true iff it matched
+ * `ctx.command`. The dispatch table in repl.ts walks them in order until
+ * one returns true; if none do, the user gets the "unknown command"
+ * message.
+ *
+ * Adding a new command means: pick the right category file, add a
+ * `case '/foo':` to its switch, done. No need to edit repl.ts at all.
+ */
+export {};

package/dist/cli/commands/_helpers.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Helpers shared across multiple slash-command handler files.
+ *
+ * Stays small on purpose — anything used by only one category file should
+ * live in that file. The functions here are the cross-cutting bits that
+ * 3+ categories reach for: print-an-MCP-call helpers, the goal-kickoff
+ * prompt builder, the transcript content formatter, and the skill runner
+ * wrapper.
+ */
+import type { Agent } from '../../agent/agent.js';
+import type { McpClientWrapper } from '../../runtime/mcpClient.js';
+/**
+ * Memory-aware variant of printMcpCall. Calls the tool, extracts the flat
+ * record list from whatever shape it returns, and renders compact cards
+ * (recordId, type, scene, content preview). Falls back to printMcpCall's
+ * raw output only when no records can be parsed.
+ */
+export declare function printMemoryCards(mcpClient: McpClientWrapper, toolName: string, args: Record<string, unknown>, heading: string): Promise<void>;
+/**
+ * Generic MCP call printer — used by /handover, /explain, /failed, /verify,
+ * /audit, /persona, /skill-hints, and anywhere else we just want to dump
+ * the tool's text output under a heading.
+ */
+export declare function printMcpCall(mcpClient: McpClientWrapper, toolName: string, args: Record<string, unknown>, heading: string): Promise<void>;
+/**
+ * Format a transcript entry's content for compact display in /transcript
+ * and /agent. Strips whitespace, JSON-stringifies non-strings, caps at 240
+ * chars so long tool payloads don't blow scrollback.
+ */
+export declare function formatTranscriptContent(value: unknown): string;
+/**
+ * Prompt the agent receives for the FIRST turn after /goal <text> or
+ * /goal resume. Once this turn finishes, runAgentTurn's continuation loop
+ * keeps firing iterations 2..N until the agent calls goal_complete or
+ * goal_blocked, the budget runs out, or the user interrupts.
+ */
+export declare function buildGoalKickoffPrompt(goal: import('../../state/goalStore.js').Goal, mode: 'start' | 'resume'): string;
+/**
+ * Resolve a slash-mapped skill (/spec, /feature-dev, /review, /implement-plan)
+ * to a SKILL.md body, refuse fallback placeholders, latch activeSkill on the
+ * agent, and hand the assembled prompt to the supplied runTurn callback.
+ * Centralized here so /skill itself and the workflow shortcuts share one path.
+ */
+export declare function runSkillCommand(agent: Agent, mcpClient: McpClientWrapper, slashCommand: string, userInput: string, orchestration: string | undefined, runTurn: (prompt: string) => void): Promise<void>;
+export declare function runSkillByName(agent: Agent, mcpClient: McpClientWrapper, skillName: string, userInput: string, orchestration: string | undefined, runTurn: (prompt: string) => void): Promise<void>;

package/dist/cli/commands/_helpers.js

@@ -0,0 +1,140 @@
+/**
+ * Helpers shared across multiple slash-command handler files.
+ *
+ * Stays small on purpose — anything used by only one category file should
+ * live in that file. The functions here are the cross-cutting bits that
+ * 3+ categories reach for: print-an-MCP-call helpers, the goal-kickoff
+ * prompt builder, the transcript content formatter, and the skill runner
+ * wrapper.
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import { callMcpTool } from '../../runtime/mcpUtils.js';
+import { clampPayload, extractMemories, renderMemoryCards } from '../../memory/formatters.js';
+import { buildSkillPrompt, resolveSkill, SLASH_TO_SKILL } from '../../prompt/skillRunner.js';
+/**
+ * Memory-aware variant of printMcpCall. Calls the tool, extracts the flat
+ * record list from whatever shape it returns, and renders compact cards
+ * (recordId, type, scene, content preview). Falls back to printMcpCall's
+ * raw output only when no records can be parsed.
+ */
+export async function printMemoryCards(mcpClient, toolName, args, heading) {
+    const spinner = ora(chalk.gray(`${toolName}…`)).start();
+    const res = await callMcpTool(mcpClient, toolName, args);
+    spinner.stop();
+    console.log();
+    if (res.isError) {
+        console.log(chalk.red(`${heading}: tool error — ${res.text || '(no message)'}`));
+        return;
+    }
+    const cards = extractMemories(res.parsed);
+    if (cards.length > 0) {
+        console.log(renderMemoryCards(cards, heading));
+    }
+    else {
+        console.log(chalk.bold(heading));
+        const preview = clampPayload(res.text, 2000).trim();
+        console.log(preview ? chalk.gray(preview) : chalk.yellow('  (empty result)'));
+        console.log();
+    }
+}
+/**
+ * Generic MCP call printer — used by /handover, /explain, /failed, /verify,
+ * /audit, /persona, /skill-hints, and anywhere else we just want to dump
+ * the tool's text output under a heading.
+ */
+export async function printMcpCall(mcpClient, toolName, args, heading) {
+    const spinner = ora(chalk.gray(`${toolName}…`)).start();
+    const res = await callMcpTool(mcpClient, toolName, args);
+    spinner.stop();
+    console.log(chalk.bold(`\n${heading}`));
+    if (res.isError) {
+        console.log(chalk.red(`  Tool error: ${res.text || '(no message)'}`));
+        console.log();
+        return;
+    }
+    if (!res.text.trim()) {
+        console.log(chalk.yellow('  (empty result)'));
+        console.log();
+        return;
+    }
+    const preview = res.text.length > 4000
+        ? res.text.slice(0, 4000) + chalk.gray(`\n…(${res.text.length - 4000} chars truncated)`)
+        : res.text;
+    console.log(chalk.gray(preview));
+    console.log();
+}
+/**
+ * Format a transcript entry's content for compact display in /transcript
+ * and /agent. Strips whitespace, JSON-stringifies non-strings, caps at 240
+ * chars so long tool payloads don't blow scrollback.
+ */
+export function formatTranscriptContent(value) {
+    const raw = typeof value === 'string' ? value : JSON.stringify(value);
+    return raw.replace(/\s+/g, ' ').trim().slice(0, 240);
+}
+/**
+ * Prompt the agent receives for the FIRST turn after /goal <text> or
+ * /goal resume. Once this turn finishes, runAgentTurn's continuation loop
+ * keeps firing iterations 2..N until the agent calls goal_complete or
+ * goal_blocked, the budget runs out, or the user interrupts.
+ */
+export function buildGoalKickoffPrompt(goal, mode) {
+    const header = mode === 'start' ? '[GOAL KICKOFF — iteration 1]' : '[GOAL RESUME]';
+    return [
+        header,
+        '',
+        `Your active goal is: ${goal.text}`,
+        `Iteration budget: ${goal.budget.iterationsUsed}/${goal.budget.maxIterations} used.`,
+        '',
+        '## What to do right now',
+        mode === 'start'
+            ? '1. **Open with memory.** Run `memory_search` / `memory_recall` for prior work in this workspace. Cite the recordIds you find.'
+            : '1. **Reload context.** Check what was already done by reading the last few transcript entries, the current plan, and any open child agents (`list_agents`).',
+        '2. **Plan briefly.** If the work has 3+ vertical slices, call `update_plan` with statuses (pending / in_progress / completed; ≤ 1 in_progress).',
+        '3. **Take the first concrete tool action** toward the outcome. Read a file, write code, spawn an explorer child, run a verifier — whatever produces evidence the goal is satisfied.',
+        '4. The CLI will auto-continue you with another turn after this one finishes. Iterate until you can call `goal_complete(proof)` with concrete evidence (test pass / file written / benchmark hit) or `goal_blocked(reason)` if no path remains.',
+        '',
+        'Do NOT respond with prose-only "I will get started" — the CLI suppresses the next auto-continuation after a turn with zero tool calls. Begin executing tools now.',
+    ].join('\n');
+}
+/**
+ * Resolve a slash-mapped skill (/spec, /feature-dev, /review, /implement-plan)
+ * to a SKILL.md body, refuse fallback placeholders, latch activeSkill on the
+ * agent, and hand the assembled prompt to the supplied runTurn callback.
+ * Centralized here so /skill itself and the workflow shortcuts share one path.
+ */
+export async function runSkillCommand(agent, mcpClient, slashCommand, userInput, orchestration, runTurn) {
+    const skillName = SLASH_TO_SKILL[slashCommand];
+    if (!skillName) {
+        console.log(chalk.red(`\nNo skill mapped to ${slashCommand}.\n`));
+        return;
+    }
+    await runSkillByName(agent, mcpClient, skillName, userInput, orchestration, runTurn);
+}
+export async function runSkillByName(agent, mcpClient, skillName, userInput, orchestration, runTurn) {
+    const loader = ora(chalk.gray(`Loading skill: ${skillName}...`)).start();
+    let prompt;
+    try {
+        const skill = await resolveSkill(mcpClient, skillName, agent.workspaceRoot, 'full');
+        if (skill.source === 'fallback') {
+            // resolveSkill returns a placeholder body for unknown names; running it
+            // burns an LLM call on nothing. Refuse early and tell the user what's
+            // actually installed.
+            loader.fail(chalk.red(`Unknown skill "${skillName}".`));
+            console.log(chalk.gray('  Run `/skills` to list installed skills, or call `search_skills` for fuzzy matches.\n'));
+            return;
+        }
+        loader.succeed(chalk.green(`Skill loaded: ${skillName} (${skill.source})`));
+        prompt = buildSkillPrompt(skill, { input: userInput, orchestration });
+    }
+    catch (err) {
+        loader.fail(chalk.red(`Failed to resolve skill "${skillName}": ${err.message}`));
+        return;
+    }
+    // Mark the skill active so memory_recall / memory_capture_turn see it.
+    // The activeSkill stays latched while the turn runs; runAgentTurn's
+    // continuation loop will clear it via the post-turn hook.
+    agent.activeSkill = skillName;
+    runTurn(prompt);
+}

package/dist/cli/commands/guard.d.ts

@@ -0,0 +1,6 @@
+/**
+ * AUTO-EXTRACTED from cli/repl.ts as part of the slash-command split.
+ * Hand-tune imports if the compiler complains.
+ */
+import type { CommandContext } from './_context.js';
+export declare function tryHandleGuardCommand(ctx: CommandContext): Promise<boolean>;

package/dist/cli/commands/guard.js

@@ -0,0 +1,292 @@
+/**
+ * AUTO-EXTRACTED from cli/repl.ts as part of the slash-command split.
+ * Hand-tune imports if the compiler complains.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { readPreferences, writePreferences } from '../../state/preferencesStore.js';
+import { addHook, readHooks, removeHook, setHookEnabled } from '../../state/hooksStore.js';
+import { createHookifyRule, deleteHookifyRule, listHookifyRules, toggleHookifyRule } from '../../state/hookifyStore.js';
+export async function tryHandleGuardCommand(ctx) {
+    const { command, args, agent, mcpClient, config, rl, repl } = ctx;
+    // 'ctx' alias to keep references to the old ReplContext name working
+    const replCtx = repl;
+    switch (command) {
+        case '/permissions':
+            {
+                const sub = args[0];
+                if (!sub) {
+                    const mode = agent.getAccessMode();
+                    console.log(chalk.bold(`\nCurrent access mode: ${chalk.cyan(mode)}`));
+                    console.log(chalk.gray('  read   — list/grep/read/web only. No file writes, no shell.'));
+                    console.log(chalk.gray('  write  — read + write_file / edit_file / apply_patch. No shell.'));
+                    console.log(chalk.gray('  shell  — write + run_command (still confirmed in the REPL).'));
+                    console.log(chalk.gray('\nSwitch with: /permissions read | write | shell  (or use Shift+Tab to cycle)\n'));
+                    return true;
+                }
+                if (!['read', 'write', 'shell'].includes(sub)) {
+                    console.log(chalk.red(`\nUnknown mode "${sub}". Choose: read, write, shell.\n`));
+                    return true;
+                }
+                agent.setAccessMode(sub);
+                ctx.repl.refreshPromptForMode();
+                console.log(chalk.green(`\n✓ Access mode → ${chalk.cyan(sub)}\n`));
+                return true;
+            }
+        case '/hooks':
+            {
+                const sub = args[0];
+                if (!sub || sub === 'list') {
+                    const hooks = readHooks(agent.workspaceRoot);
+                    console.log(chalk.bold('\nLifecycle hooks'));
+                    if (hooks.length === 0) {
+                        console.log(chalk.yellow('  (none)'));
+                        console.log(chalk.gray('  Add one with: /hooks add <event> <shell-command>  (events: pre-turn, post-turn, pre-tool, post-tool, session-start, session-end)\n'));
+                    }
+                    else {
+                        for (const h of hooks) {
+                            const tag = h.enabled ? chalk.green('●') : chalk.gray('○');
+                            console.log(`  ${tag} ${chalk.cyan(h.id)} ${chalk.gray(h.event)}${h.match ? chalk.gray(` (match: ${h.match})`) : ''}`);
+                            console.log(`    ${chalk.gray(h.command)}`);
+                        }
+                        console.log();
+                    }
+                    return true;
+                }
+                if (sub === 'add') {
+                    const event = args[1];
+                    const command = args.slice(2).join(' ').trim();
+                    const validEvents = ['pre-turn', 'post-turn', 'pre-tool', 'post-tool', 'session-start', 'session-end'];
+                    if (!event || !validEvents.includes(event) || !command) {
+                        console.log(chalk.red(`\nUsage: /hooks add <${validEvents.join('|')}> <shell-command>\n`));
+                        return true;
+                    }
+                    const created = addHook(agent.workspaceRoot, { event, command });
+                    console.log(chalk.green(`\n✓ Hook added: ${created.id}\n`));
+                    return true;
+                }
+                if (sub === 'remove' && args[1]) {
+                    const ok = removeHook(agent.workspaceRoot, args[1]);
+                    console.log(ok ? chalk.green(`\n✓ Removed ${args[1]}\n`) : chalk.red(`\nNo hook with id ${args[1]}\n`));
+                    return true;
+                }
+                if ((sub === 'enable' || sub === 'disable') && args[1]) {
+                    const ok = setHookEnabled(agent.workspaceRoot, args[1], sub === 'enable');
+                    console.log(ok ? chalk.green(`\n✓ ${sub === 'enable' ? 'Enabled' : 'Disabled'} ${args[1]}\n`) : chalk.red(`\nNo hook with id ${args[1]}\n`));
+                    return true;
+                }
+                console.log(chalk.red('\nUsage: /hooks [list | add <event> <cmd> | remove <id> | enable <id> | disable <id>]\n'));
+                return true;
+            }
+        case '/yolo':
+            {
+                const prefs = readPreferences(agent.workspaceRoot);
+                const arg = (args[0] ?? '').toLowerCase();
+                if (!arg) {
+                    console.log(chalk.bold(`\nAuto-approve shell: ${prefs.autoApproveShell ? chalk.red('ON') : chalk.green('off')}`));
+                    console.log(chalk.gray('  When ON, run_command skips the per-call confirmation prompt and executes immediately.'));
+                    console.log(chalk.gray('  Pair with BRAINROUTER_SANDBOX=on if you still want a safety net.'));
+                    console.log(chalk.gray('  Toggle with: /yolo on  |  /yolo off\n'));
+                    return true;
+                }
+                const next = arg === 'on' || arg === 'true' || arg === '1';
+                writePreferences(agent.workspaceRoot, { autoApproveShell: next });
+                if (next) {
+                    console.log(chalk.red('\n⚠  /yolo ON — run_command will now execute without asking.'));
+                    console.log(chalk.gray('   You are in access mode "shell" so the agent CAN call shell commands.'));
+                    console.log(chalk.gray('   Lower the risk with /permissions write (no shell), or set BRAINROUTER_SANDBOX=on.\n'));
+                }
+                else {
+                    console.log(chalk.green('\n✓ /yolo off — run_command will prompt for confirmation again.\n'));
+                }
+                return true;
+            }
+        case '/sandbox':
+            {
+                const sub = (args[0] ?? '').toLowerCase();
+                const rest = args.slice(1).join(' ').trim();
+                const prefs = readPreferences(agent.workspaceRoot);
+                const showState = () => {
+                    const enabled = (process.env.BRAINROUTER_SANDBOX ?? '').toLowerCase() === 'on';
+                    console.log(chalk.bold('\nSandbox'));
+                    console.log(`  Engine:  ${enabled ? chalk.green('on') : chalk.gray('off')} ${chalk.gray('(BRAINROUTER_SANDBOX env)')}`);
+                    console.log(`  Platform: ${chalk.cyan(process.platform)} ${chalk.gray(process.platform === 'darwin' ? '(sandbox-exec)' : process.platform === 'linux' ? '(bwrap/firejail)' : '(unsupported — run_command runs unsandboxed)')}`);
+                    console.log(`  Workspace (always rw): ${chalk.blue(agent.workspaceRoot)}`);
+                    console.log(chalk.bold('  Read-only grants:'));
+                    if (prefs.sandboxReadPaths.length === 0)
+                        console.log(chalk.gray('    (none)'));
+                    else
+                        for (const p of prefs.sandboxReadPaths)
+                            console.log(`    ${chalk.cyan(p)}`);
+                    console.log(chalk.bold('  Write grants (beyond workspace):'));
+                    if (prefs.sandboxWritePaths.length === 0)
+                        console.log(chalk.gray('    (none)'));
+                    else
+                        for (const p of prefs.sandboxWritePaths)
+                            console.log(`    ${chalk.cyan(p)}`);
+                    console.log(chalk.gray('\n  Subcommands:'));
+                    console.log(chalk.gray('    /sandbox add-read <path>     grant read-only access'));
+                    console.log(chalk.gray('    /sandbox add-write <path>    grant read+write access'));
+                    console.log(chalk.gray('    /sandbox remove <path>       drop a grant (matches either list)'));
+                    console.log(chalk.gray('    /sandbox clear               drop all persisted grants'));
+                    console.log(chalk.gray('    /sandbox status              show this view\n'));
+                };
+                if (!sub || sub === 'status') {
+                    showState();
+                    break;
+                }
+                const resolveGrant = (p) => {
+                    if (!p)
+                        return null;
+                    const abs = path.resolve(agent.workspaceRoot, p);
+                    if (!fs.existsSync(abs)) {
+                        console.log(chalk.yellow(`\n⚠  Path does not exist: ${abs}`));
+                        console.log(chalk.gray('   Granting anyway — create it later or the sandbox will skip the bind.\n'));
+                    }
+                    return abs;
+                };
+                if (sub === 'add-read') {
+                    const abs = resolveGrant(rest);
+                    if (!abs) {
+                        console.log(chalk.red('\nUsage: /sandbox add-read <path>\n'));
+                        break;
+                    }
+                    const next = Array.from(new Set([...prefs.sandboxReadPaths, abs]));
+                    writePreferences(agent.workspaceRoot, { sandboxReadPaths: next });
+                    console.log(chalk.green(`\n✓ Added read grant: ${abs}\n`));
+                    return true;
+                }
+                if (sub === 'add-write') {
+                    const abs = resolveGrant(rest);
+                    if (!abs) {
+                        console.log(chalk.red('\nUsage: /sandbox add-write <path>\n'));
+                        break;
+                    }
+                    const next = Array.from(new Set([...prefs.sandboxWritePaths, abs]));
+                    writePreferences(agent.workspaceRoot, { sandboxWritePaths: next });
+                    console.log(chalk.green(`\n✓ Added write grant: ${abs}\n`));
+                    return true;
+                }
+                if (sub === 'remove') {
+                    const abs = resolveGrant(rest);
+                    if (!abs) {
+                        console.log(chalk.red('\nUsage: /sandbox remove <path>\n'));
+                        break;
+                    }
+                    writePreferences(agent.workspaceRoot, {
+                        sandboxReadPaths: prefs.sandboxReadPaths.filter((p) => p !== abs),
+                        sandboxWritePaths: prefs.sandboxWritePaths.filter((p) => p !== abs),
+                    });
+                    console.log(chalk.green(`\n✓ Removed grant: ${abs}\n`));
+                    return true;
+                }
+                if (sub === 'clear') {
+                    writePreferences(agent.workspaceRoot, { sandboxReadPaths: [], sandboxWritePaths: [] });
+                    console.log(chalk.green('\n✓ Cleared all persisted sandbox grants.\n'));
+                    return true;
+                }
+                console.log(chalk.red(`\nUnknown /sandbox subcommand "${sub}". Run /sandbox for help.\n`));
+                return true;
+            }
+        case '/logout':
+            {
+                // Remove the API key from the active server profile. The CLI keeps the
+                // profile so a future /login can re-attach credentials.
+                const profile = config.activeServer;
+                const server = config.servers[profile];
+                if (!server) {
+                    console.log(chalk.red(`\nNo active profile to log out of.\n`));
+                    return true;
+                }
+                const removed = [];
+                if (server.apiKey) {
+                    delete server.apiKey;
+                    removed.push('server.apiKey');
+                }
+                if (config.llm?.apiKey) {
+                    config.llm.apiKey = '';
+                    removed.push('llm.apiKey');
+                }
+                if (removed.length === 0) {
+                    console.log(chalk.gray(`\nNo credentials were set on profile "${profile}".\n`));
+                    return true;
+                }
+                const { saveConfig } = await import('../../config/config.js');
+                saveConfig(config);
+                console.log(chalk.green(`\n✓ Cleared ${removed.join(', ')} from profile "${profile}".`));
+                console.log(chalk.gray('  Re-attach with /login.\n'));
+                return true;
+            }
+        case '/hookify':
+            {
+                const sub = args[0];
+                if (!sub || sub === 'list') {
+                    const rules = listHookifyRules(agent.workspaceRoot);
+                    console.log(chalk.bold('\nHookify rules'));
+                    if (rules.length === 0) {
+                        console.log(chalk.yellow('  (none)'));
+                        console.log(chalk.gray('  Add with: /hookify create <name>|<event>|<pattern>|<action>|<message>'));
+                        console.log(chalk.gray('    event   = bash | file | prompt | stop | all'));
+                        console.log(chalk.gray('    action  = warn | block'));
+                        console.log(chalk.gray('  Rules live as markdown files in ~/.brainrouter/workspaces/<encoded>/hooks/'));
+                        console.log(chalk.gray('  (legacy <workspace>/.brainrouter/hooks/ files are auto-migrated on first read).\n'));
+                    }
+                    else {
+                        for (const r of rules) {
+                            const tag = r.enabled ? chalk.green('●') : chalk.gray('○');
+                            console.log(`  ${tag} ${chalk.cyan(r.id)} ${chalk.gray(r.event)} → ${chalk.yellow(r.action)}${r.pattern ? chalk.gray(` (pattern: ${r.pattern})`) : ''}`);
+                            console.log(chalk.gray(`    ${r.message.split('\n')[0].slice(0, 120)}`));
+                        }
+                        console.log();
+                    }
+                    return true;
+                }
+                if (sub === 'create') {
+                    const raw = args.slice(1).join(' ').trim();
+                    const parts = raw.split('|').map((p) => p.trim());
+                    if (parts.length < 5) {
+                        console.log(chalk.red('\nUsage: /hookify create <name>|<event>|<pattern>|<action>|<message>\n'));
+                        return true;
+                    }
+                    try {
+                        const created = createHookifyRule(agent.workspaceRoot, {
+                            name: parts[0],
+                            event: parts[1],
+                            pattern: parts[2],
+                            action: parts[3],
+                            message: parts.slice(4).join('|'),
+                        });
+                        console.log(chalk.green(`\n✓ Created hookify rule ${created.id} at ${path.relative(agent.workspaceRoot, created.sourcePath)}\n`));
+                    }
+                    catch (err) {
+                        console.log(chalk.red(`\nFailed: ${err.message}\n`));
+                    }
+                    return true;
+                }
+                if (sub === 'enable' || sub === 'disable') {
+                    const id = args[1];
+                    if (!id) {
+                        console.log(chalk.red(`\nUsage: /hookify ${sub} <id>\n`));
+                        break;
+                    }
+                    const ok = toggleHookifyRule(agent.workspaceRoot, id, sub === 'enable');
+                    console.log(ok ? chalk.green(`\n✓ ${sub === 'enable' ? 'Enabled' : 'Disabled'} ${id}\n`) : chalk.red(`\nNo rule ${id}\n`));
+                    return true;
+                }
+                if (sub === 'remove') {
+                    const id = args[1];
+                    if (!id) {
+                        console.log(chalk.red(`\nUsage: /hookify remove <id>\n`));
+                        break;
+                    }
+                    const ok = deleteHookifyRule(agent.workspaceRoot, id);
+                    console.log(ok ? chalk.green(`\n✓ Removed ${id}\n`) : chalk.red(`\nNo rule ${id}\n`));
+                    return true;
+                }
+                console.log(chalk.red('\nUsage: /hookify [list | create <spec> | enable <id> | disable <id> | remove <id>]\n'));
+                return true;
+            }
+    }
+    return false;
+}

package/dist/cli/commands/memory.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Memory-related slash commands. All cases here are leaf operations against
+ * the MCP memory tools (search, recall, briefing inspection, scenes,
+ * forget, handover, explain, trace, failed, verify, audit, export, import,
+ * persona, skill-hints, diagnostics, working canvas) plus the pipeline
+ * toggle / consolidation operation.
+ *
+ * They mostly delegate to printMcpCall / printMemoryCards and write nothing
+ * back to the workspace except /export (which writes the JSON envelope).
+ */
+import type { CommandContext } from './_context.js';
+export declare function tryHandleMemoryCommand(ctx: CommandContext): Promise<boolean>;