actoviq-agent-sdk 0.4.2 → 0.4.6

package/dist/src/tui/actoviqTui.js

@@ -5,20 +5,32 @@
  * output, permission dialogs, and mid-run steering. Dependency-free ANSI
  * rendering (no React/Ink).
  */
-import { execSync } from 'node:child_process';
+import { execSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import * as readline from 'node:readline';
-import { createActoviqCoreTools, createAgentSdk, loadDefaultActoviqSettings, loadJsonConfigFile, listWorkflows, loadWorkflow, listTeamDefinitions, loadTeamDefinition, createModelTeam, createTeamTool, listRouterProfiles, loadRouterProfile, resolveRoutedRun, WorktreeService, } from '../index.js';
+import { createActoviqCoreTools, createAgentSdk, detectBridgeProviders, loadDefaultActoviqSettings, loadJsonConfigFile, listWorkflows, loadWorkflow, listTeamDefinitions, loadTeamDefinition, createModelTeam, createTeamTool, listRouterProfiles, loadRouterProfile, resolveRoutedRun, WorktreeService, } from '../index.js';
 import { persistActoviqSettingsStore, resolveActoviqSettingsStore, } from '../config/actoviqSettingsStore.js';
+import { createPreToolUseHookClassifier, readPreToolUseHooks, readPostToolUseHooks, runPostToolUseHooks, readSessionStartHooks, runSessionStartHooks } from '../hooks/userHooks.js';
 import { isRecord } from '../runtime/helpers.js';
+import { getLoadedJsonConfig } from '../config/loadJsonConfigFile.js';
+import { findBridgeConfig, maskApiKey, readBridgeConfigs, addBridgeConfig, removeBridgeConfig, } from '../parity/bridgeConfigs.js';
+import { buildRouteModelApi } from '../router/modelRouter.js';
+import { addMcpServer, readMcpServerConfig, removeMcpServer } from '../mcp/mcpServerConfig.js';
+import { isReadOnlyBashCommand } from '../runtime/bashClassification.js';
+import { estimateCost } from '../team/pricing.js';
+import { applyOutputStyle, OUTPUT_STYLES } from '../prompts/outputStyles.js';
+import { planFilePath, readPlanFile } from '../tools/planMode/PlanModeTools.js';
+import { loadProjectContext } from '../memory/projectContext.js';
 import { pathToFileURL } from 'node:url';
+import { ACTOVIQ_INTERACTIVE_COMMANDS, SUBCOMMAND_DESCRIPTIONS, filterInteractiveCommands, } from '../ui/commandSurface.js';
 import { A, stringWidth, truncateToWidth, wrapToWidth } from './ansi.js';
 import { InputEditor } from './editor.js';
 import { discoverActoviqPlugins } from './pluginCatalog.js';
 import { TuiScreen } from './screen.js';
 import { filterTuiSelectionItems, moveTuiSelection, } from './selection.js';
-import { StreamFlusher, formatBanner, formatCompactNotice, formatErrorLine, formatInfoLine, formatQueuedPrompt, formatThinking, formatToolCall, formatToolResult, formatUserPrompt, } from './transcript.js';
+import { StreamFlusher, formatBanner, formatCompactNotice, formatDivider, formatEditCall, formatErrorLine, formatInfoLine, formatQueuedPrompt, formatThinking, formatToolCall, formatToolResult, formatUserPrompt, } from './transcript.js';
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const CTRL_C_EXIT_WINDOW_MS = 600;
 const DYNAMIC_FRAME_MS = 33;
@@ -35,35 +47,15 @@ const PERMISSION_MODES = new Set([
     'bypassPermissions',
     'auto',
 ]);
-export const TUI_SLASH_COMMANDS = {
-    help: 'Show available commands',
-    clear: 'Clear the screen',
-    compact: 'Compact the current session',
-    memory: 'Show memory/compact state',
-    model: 'Select a model or configure its provider',
-    effort: 'Select the reasoning effort',
-    permissions: 'Show or set the permission mode',
-    sessions: 'List stored sessions',
-    resume: 'Resume a stored session',
-    tools: 'List available tools',
-    skills: 'Browse available skills',
-    agents: 'Browse available subagents',
-    mcp: 'Inspect MCP servers and tools',
-    plugins: 'Browse discovered Clean plugins',
-    dream: 'Inspect or run memory consolidation',
-    workflows: 'Browse saved dynamic workflows',
-    worktree: 'Enter, exit, or list git worktrees',
-    team: 'List or run Model Team definitions',
-    exit: 'Quit',
-};
+export const TUI_SLASH_COMMANDS = ACTOVIQ_INTERACTIVE_COMMANDS;
+/** Mask an API key for display: show first 4 + last 4, hide the middle. */
+function maskKey(key) {
+    if (key.length <= 8)
+        return '****';
+    return `${key.slice(0, 4)}…${key.slice(-4)}`;
+}
 export function filterSlashCommands(input) {
-    if (!input.startsWith('/'))
-        return [];
-    const head = input.slice(1).split(/\s/, 1)[0] ?? '';
-    if (input.includes(' ') && head.length > 0)
-        return [];
-    const partial = head.toLowerCase();
-    return Object.keys(TUI_SLASH_COMMANDS).filter((name) => name.startsWith(partial));
+    return filterInteractiveCommands(input);
 }
 /**
  * Detect an active "@file" mention at the cursor for path completion. Returns
@@ -91,10 +83,32 @@ export function activeAtToken(text, cursor) {
  * expert-panel member reports so long output reads cleanly instead of dumping
  * raw lines. Optionally caps very long output with a "… (N more lines)" note.
  */
-function renderRichText(text, width, opts = {}) {
+// Apply inline markdown formatting to a single unwrapped line segment:
+// `code` → dim, **bold** → bold, *italic* → italic. Applied after wrapping
+// so ANSI codes never split mid-segment.
+function renderMarkdownInline(line) {
+    return line
+        .replace(/`([^`]+)`/g, `${A.dim}$1${A.reset}`)
+        .replace(/\*\*([^*]+)\*\*/g, `${A.bold}$1${A.reset}`)
+        .replace(/\*([^*]+)\*/g, `${A.italic}$1${A.reset}`);
+}
+export function renderRichText(text, width, opts = {}) {
     const cols = Math.max(20, width - 2);
     const out = [];
+    let inFence = false;
     for (const raw of text.replace(/\r/g, '').split('\n')) {
+        // Fenced code blocks: render a dim rule at the fence and the content
+        // dim/gray so code reads as a block instead of raw markdown text. Code
+        // lines are not word-wrapped (wrapping would corrupt code).
+        if (/^\s*```/.test(raw)) {
+            inFence = !inFence;
+            out.push(`${A.dim}${'─'.repeat(Math.min(cols, 40))}${A.reset}`);
+            continue;
+        }
+        if (inFence) {
+            out.push(`${A.gray}  ${raw}${A.reset}`);
+            continue;
+        }
         const heading = /^(#{1,6})\s+(.*)$/.exec(raw);
         if (heading) {
             out.push(`${A.bold}${A.cyan}${heading[2]}${A.reset}`);
@@ -104,8 +118,10 @@ function renderRichText(text, width, opts = {}) {
             out.push('');
             continue;
         }
+        // Wrap first, then apply inline formatting per segment — avoids ANSI
+        // splitting by never putting styling codes mid-segment.
         for (const line of wrapToWidth(raw, cols))
-            out.push(line);
+            out.push(renderMarkdownInline(line));
     }
     const maxLines = opts.maxLines ?? 0;
     if (maxLines > 0 && out.length > maxLines) {
@@ -124,6 +140,12 @@ function buildSystemPrompt(workDir) {
     catch {
         // not a git repo
     }
+    // Load the CLAUDE.md hierarchy (user + project, with @includes) so the agent
+    // picks up project-specific instructions — the canonical Claude Code behavior.
+    const project = loadProjectContext(workDir);
+    const projectSection = project.text
+        ? `\n\n# Project context (CLAUDE.md)\n\nThe following project instructions were loaded from CLAUDE.md files. Treat them as authoritative guidance for this workspace.\n\n${project.text}\n`
+        : '';
     return (`You are Hadamard Agent, an interactive CLI agent. Working directory: ${workDir}\n\n` +
         `<env>\nWorking directory: ${workDir}\nIs git repo: ${isGit ? 'Yes' : 'No'}\nPlatform: ${process.platform}\nDate: ${new Date().toISOString().slice(0, 10)}\n</env>\n\n` +
         `# Tone and style\n` +
@@ -141,7 +163,36 @@ function buildSystemPrompt(workDir) {
         `- NEVER commit changes unless the user explicitly asks you to\n\n` +
         `# Other\n` +
         `- NEVER create documentation files (*.md) unless explicitly requested.\n` +
-        `- When in doubt, use TodoWrite to track progress.`);
+        `- When in doubt, use TodoWrite to track progress.`) + projectSection;
+}
+// First-run onboarding: guides the user through creating ~/.actoviq/settings.json
+// when no credential is found. Uses plain readline (no TTY required beyond stdin).
+async function onboardCredentials(configPath) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+    console.log('\n  Welcome to Actoviq! Let\'s set up your first connection.\n');
+    const provider = await ask('  Provider (anthropic/openai) [anthropic]: ');
+    const apiKey = await ask('  API Key: ');
+    const baseURL = await ask('  Base URL [https://api.deepseek.com]: ');
+    const model = await ask('  Model [deepseek-chat]: ');
+    rl.close();
+    const resolvedProvider = provider.trim() || 'anthropic';
+    const resolvedBaseURL = baseURL.trim() || 'https://api.deepseek.com';
+    const resolvedModel = model.trim() || 'deepseek-chat';
+    const home = os.homedir();
+    const dir = path.join(home, '.actoviq');
+    const file = configPath ?? path.join(dir, 'settings.json');
+    fs.mkdirSync(dir, { recursive: true });
+    const env = {
+        ACTOVIQ_API_KEY: apiKey.trim(),
+        ACTOVIQ_BASE_URL: resolvedBaseURL,
+        ACTOVIQ_MODEL: resolvedModel,
+    };
+    if (resolvedProvider === 'openai')
+        env.ACTOVIQ_PROVIDER = 'openai';
+    const settings = { env };
+    fs.writeFileSync(file, JSON.stringify(settings, null, 2), 'utf-8');
+    console.log(`\n  Config saved to ${file}. Starting TUI...\n`);
 }
 export async function runActoviqTui(options = {}) {
     const workDir = path.resolve(options.workDir ?? process.cwd());
@@ -163,10 +214,56 @@ export async function runActoviqTui(options = {}) {
         workDir,
         tools,
         permissionMode,
+        // Load user-managed stdio MCP servers from ~/.actoviq/mcp.json (gap #10).
+        mcpServers: readMcpServerConfig().servers.map(s => (s.command
+            ? { kind: 'stdio', name: s.name, command: s.command, ...(s.args ? { args: s.args } : {}), ...(s.env ? { env: s.env } : {}), ...(s.cwd ? { cwd: s.cwd } : {}) }
+            : { kind: 'streamable_http', name: s.name, url: s.url, ...(s.headers ? { headers: s.headers } : {}) })),
         ...(options.model ? { model: options.model } : {}),
     });
-    let sdk = await createCleanSdk();
-    let toolMetadata = await sdk.listToolMetadata();
+    let sdk;
+    let toolMetadata;
+    while (true) {
+        try {
+            sdk = await createCleanSdk();
+            toolMetadata = await sdk.listToolMetadata();
+            break;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('No Actoviq credential')) {
+                // First-run onboarding: guide the user through creating ~/.actoviq/settings.json.
+                await onboardCredentials(options.configPath);
+                // After saving, retry SDK creation.
+                continue;
+            }
+            throw error;
+        }
+    }
+    // Build a dynamic capabilities section injected into the system prompt each
+    // turn (gap #16 vs claude-code) — subagents, MCP servers+tools, skills — so
+    // the model knows what it can delegate to/use beyond the core tool list.
+    function buildAgentContext() {
+        const parts = [];
+        const agents = sdk.listAgentDefinitions();
+        if (agents.length > 0) {
+            parts.push(`Available subagents: ${agents.map(a => a.name).join(', ')}`);
+        }
+        const byServer = new Map();
+        for (const tool of toolMetadata.filter(item => item.provider === 'mcp')) {
+            const server = tool.server ?? 'mcp';
+            if (!byServer.has(server))
+                byServer.set(server, []);
+            byServer.get(server).push(tool);
+        }
+        for (const [server, tools] of byServer) {
+            const names = tools.map(t => t.name).slice(0, 12).join(', ');
+            parts.push(`MCP server "${server}": ${names}${tools.length > 12 ? '…' : ''}`);
+        }
+        const skills = sdk.skills.listMetadata();
+        if (skills.length > 0) {
+            parts.push(`Skills: ${skills.map(s => s.name).slice(0, 12).join(', ')}${skills.length > 12 ? '…' : ''}`);
+        }
+        return parts.length > 0 ? `\n\n# Available capabilities\n\n${parts.join('\n')}\n` : '';
+    }
     let session = options.resumeSessionId
         ? await sdk.resumeSession(options.resumeSessionId, {
             model: options.model,
@@ -182,6 +279,8 @@ export async function runActoviqTui(options = {}) {
                 model: options.model,
                 permissionMode,
             });
+    // Run SessionStart hooks (fire-and-forget, from settings.json hooks.SessionStart[]).
+    runSessionStartHooks(() => readSessionStartHooks(getLoadedJsonConfig()?.raw), sdk.config.workDir);
     const screen = new TuiScreen(process.stdout);
     const editor = new InputEditor();
     const flusher = new StreamFlusher(() => screen.width);
@@ -194,6 +293,19 @@ export async function runActoviqTui(options = {}) {
     // /model router: when set, each user turn is classified and routed to a model.
     let activeRouter = null;
     let routedModelLabel = null;
+    // Bridge mode: when true, prompts run in-process through the selected config's
+    // provider/apiKey/baseURL/model (no child process). The active config's
+    // credentials are pre-built into a RoutedModel via buildRouteModelApi, then
+    // injected per-run into session.stream({model, modelApi}) — same session,
+    // context naturally survives switching bridge↔hadamard.
+    let bridgeMode = false;
+    let activeBridgeConfig = null;
+    // Pre-built {model, modelApi} for the active config. Built once at activation;
+    // stale after disable (cleared). Per-run injection reuses the /model router's
+    // proven mechanism (session.stream({model, modelApi})).
+    let activeBridgeModelApi = null;
+    // Display labels (model is set from the config on activation).
+    let bridgeModelLabel = null;
     let abortCtrl = null;
     let dialog = null;
     let selectionDialog = null;
@@ -208,10 +320,48 @@ export async function runActoviqTui(options = {}) {
     let runStartedAt = 0;
     let runToolCount = 0;
     let lastTokenEstimate;
+    // Running token + USD totals for /cost and /usage. Per-config breakdown
+    // shows spend by each bridge config so the user can compare backends.
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCostUsd = 0;
+    const configUsage = new Map();
+    function recordUsage(model, usage) {
+        const inT = usage?.input_tokens ?? 0;
+        const outT = usage?.output_tokens ?? 0;
+        totalInputTokens += inT;
+        totalOutputTokens += outT;
+        const cost = estimateCost(model, inT, outT);
+        totalCostUsd = cost === null ? null : (totalCostUsd === null ? cost : totalCostUsd + cost);
+        // Per-config tracking: attribute this turn to the active bridge config.
+        if (bridgeMode && activeBridgeConfig) {
+            const rec = configUsage.get(activeBridgeConfig.name) ?? { inputTokens: 0, outputTokens: 0, turns: 0 };
+            rec.inputTokens += inT;
+            rec.outputTokens += outT;
+            rec.turns += 1;
+            configUsage.set(activeBridgeConfig.name, rec);
+        }
+    }
+    function configCost(name, rec) {
+        const cfg = findBridgeConfig(name);
+        if (!cfg?.model)
+            return null;
+        const cost = estimateCost(cfg.model, rec.inputTokens, rec.outputTokens);
+        return cost !== null ? `$${cost.toFixed(4)}` : null;
+    }
     let statusNote = '';
+    // /output-style prompt prefix swap (gap #19). Applied to the base system
+    // prompt per turn; 'default' is a no-op.
+    let outputStyle = 'default';
     let ctrlCCount = 0;
     let ctrlCTimer = null;
     let streamedTextSeen = false;
+    // Track tool names by callId for PostToolUse hook context.
+    const toolCallNames = new Map();
+    // Live todo list (captured from TodoWrite tool calls). Rendered as a
+    // persistent panel in the dynamic region so the user can see what the agent
+    // is working on / what remains — Claude Code's main progress affordance.
+    let currentTodos = [];
     const queuedInputs = [];
     const currentPermissionMode = () => session.permissionContext.mode ?? permissionMode;
     const currentEffort = () => {
@@ -284,20 +434,21 @@ export async function runActoviqTui(options = {}) {
         });
         dialog = null;
         renderDynamic();
-        if (outcome === 'always') {
+        if (outcome === 'always' || outcome === 'always-user') {
             const state = session.permissionContext;
             const permissions = state.permissions.filter(rule => !(rule.toolName === context.publicName && rule.behavior === 'allow'));
+            const source = outcome === 'always-user' ? 'user' : 'project';
             permissions.push({
                 toolName: context.publicName,
                 behavior: 'allow',
-                source: 'tui-session',
+                source,
             });
             await session.setPermissionContext({
                 mode: state.mode ?? permissionMode,
                 permissions,
                 approver,
             });
-            return { behavior: 'allow', reason: 'Approved (always) in TUI.' };
+            return { behavior: 'allow', reason: `Approved (always — ${source} scope) in TUI.` };
         }
         return outcome === 'allow'
             ? { behavior: 'allow', reason: 'Approved in TUI.' }
@@ -305,12 +456,28 @@ export async function runActoviqTui(options = {}) {
     };
     const canUseTool = permissionMode === 'default'
         ? (context) => {
+            if (context.publicName === 'Bash') {
+                // Auto-allow read-only commands (ls, git status, cat, …) so the
+                // default mode isn't a prompt on every harmless call (gap #12 vs
+                // claude-code). Everything else still prompts. isReadOnlyBashCommand
+                // is conservative — anything ambiguous falls through to 'ask'.
+                const command = context.input?.command;
+                if (typeof command === 'string' && isReadOnlyBashCommand(command)) {
+                    return undefined;
+                }
+                return { behavior: 'ask', reason: 'Bash command may modify the workspace.' };
+            }
             if (MUTATING_TOOLS.has(context.publicName)) {
                 return { behavior: 'ask', reason: `${context.publicName} mutates the workspace.` };
             }
             return undefined;
         }
         : undefined;
+    // User-configurable PreToolUse hooks from settings.json hooks.PreToolUse[].
+    // Lazily reads the live settings so edits are picked up without a restart.
+    // The classifier returns undefined (no-op) when no hooks match — so the run
+    // path is unchanged for users who haven't configured any.
+    const preToolUseHookClassifier = createPreToolUseHookClassifier(() => readPreToolUseHooks(getLoadedJsonConfig()?.raw));
     function summarizeForDialog(input) {
         if (typeof input !== 'object' || input === null)
             return '';
@@ -434,17 +601,35 @@ export async function runActoviqTui(options = {}) {
         const query = token.toLowerCase();
         if (!query)
             return files.slice(0, 200);
-        const matches = files.filter((file) => file.toLowerCase().includes(query));
-        matches.sort((a, b) => {
-            const aBase = a.slice(a.lastIndexOf('/') + 1).toLowerCase();
-            const bBase = b.slice(b.lastIndexOf('/') + 1).toLowerCase();
-            const aScore = aBase.startsWith(query) ? 0 : aBase.includes(query) ? 1 : 2;
-            const bScore = bBase.startsWith(query) ? 0 : bBase.includes(query) ? 1 : 2;
-            if (aScore !== bScore)
-                return aScore - bScore;
-            return a.length - b.length;
-        });
-        return matches.slice(0, 200);
+        // Subsequence fuzzy match with path-aware scoring: prefer basename hits,
+        // then prefix hits, then path depth (shorter = nearer the root = more
+        // likely the file the user wants). Falls back to substring for short
+        // tokens so exact-include still ranks well.
+        const scored = [];
+        for (const file of files) {
+            const lower = file.toLowerCase();
+            const slash = lower.lastIndexOf('/') + 1;
+            const base = lower.slice(slash);
+            let score = -1;
+            if (base.startsWith(query))
+                score = 1000 - base.length;
+            else if (lower.includes(query))
+                score = 800 - slash;
+            else {
+                // Subsequence fuzzy match: walk the path consuming the query in order.
+                let qi = 0;
+                for (let i = 0; i < lower.length && qi < query.length; i++) {
+                    if (lower[i] === query[qi])
+                        qi++;
+                }
+                if (qi === query.length)
+                    score = 400 - slash - (lower.length - query.length) * 0.1;
+            }
+            if (score >= 0)
+                scored.push({ file, score });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, 200).map((s) => s.file);
     }
     function buildAtMenu() {
         const active = activeAtToken(editor.text, editor.cursor);
@@ -513,7 +698,7 @@ export async function runActoviqTui(options = {}) {
             const selected = index === menuSelected;
             const command = `/${name}`.padEnd(commandWidth);
             const label = selected ? `${A.inverse}${command}${A.reset}` : command;
-            const description = truncateToWidth(TUI_SLASH_COMMANDS[name] ?? '', descriptionWidth);
+            const description = truncateToWidth(TUI_SLASH_COMMANDS[name] ?? SUBCOMMAND_DESCRIPTIONS[name] ?? '', descriptionWidth);
             return `${label} ${A.dim}${description}${A.reset}`;
         });
         const hiddenAbove = windowStart;
@@ -532,7 +717,7 @@ export async function runActoviqTui(options = {}) {
         if (!dialog)
             return [];
         const inner = Math.max(screen.width - 4, 8);
-        const options = ['Yes', `Yes, always allow ${dialog.toolName}`, 'No (esc)'];
+        const options = ['Yes', `Always ${dialog.toolName} (project)`, `Always ${dialog.toolName} (user)`, 'No (esc)'];
         const lines = [];
         lines.push(boxTop(A.yellow));
         lines.push(boxRow(`${A.bold}Permission required · ${dialog.toolName}${A.reset}`, A.yellow));
@@ -542,7 +727,7 @@ export async function runActoviqTui(options = {}) {
             lines.push(boxRow(selected ? `${A.inverse} ${option} ${A.reset}` : `  ${option}`, A.yellow));
         });
         lines.push(boxBottom(A.yellow));
-        lines.push(`${A.dim}  y/enter approve · a always · n/esc deny · ↑↓ select${A.reset}`);
+        lines.push(`${A.dim}  y/enter approve · a always (project) · n/esc deny · ↑↓ select${A.reset}`);
         return lines;
     }
     function buildSelectionDialog() {
@@ -622,7 +807,10 @@ export async function runActoviqTui(options = {}) {
         const modelLabel = activeRouter
             ? `router:${activeRouter.name}${routedModelLabel ? ` → ${routedModelLabel}` : ''}`
             : session.model;
-        const left = `${modelLabel} · ${permissionLabel()} · effort:${currentEffort() ?? 'auto'} · team:${activeTeamName ?? 'none'} · `;
+        const bridgeTag = bridgeMode && activeBridgeConfig
+            ? ` · bridge:${activeBridgeConfig.name}${bridgeModelLabel ? ` · ${bridgeModelLabel}` : ''}`
+            : '';
+        const left = `${modelLabel} · ${permissionLabel()} · effort:${currentEffort() ?? 'auto'} · team:${activeTeamName ?? 'none'}${bridgeTag}${goalContextLine()} · `;
         return `${A.dim}  ${left}${A.reset}${ctxColor}ctx ${pct}% (${usedK})${A.reset}`;
     }
     function buildStatusLine() {
@@ -644,6 +832,39 @@ export async function runActoviqTui(options = {}) {
         }
         return [`${A.dim}  ? shortcuts · / commands · @ files · \\↵ newline · ↑↓ history · ctrl+c clear/exit${A.reset}`];
     }
+    function buildTodoPanel() {
+        if (currentTodos.length === 0)
+            return [];
+        const max = 8;
+        const visible = currentTodos.slice(0, max);
+        const done = currentTodos.filter(t => t.status === 'completed').length;
+        const lines = [
+            `${A.dim}  tasks (${done}/${currentTodos.length})${A.reset}`,
+        ];
+        for (const t of visible) {
+            let mark;
+            let body;
+            if (t.status === 'completed') {
+                mark = `${A.green}✓${A.reset}`;
+                body = `${A.dim}${truncateToWidth(t.content, screen.width - 6)}${A.reset}`;
+            }
+            else if (t.status === 'in_progress') {
+                mark = `${A.cyan}▶${A.reset}`;
+                // Show the present-continuous form while a task is actively executing.
+                const text = t.activeForm ?? t.content;
+                body = `${A.bold}${truncateToWidth(text, screen.width - 6)}${A.reset}`;
+            }
+            else {
+                mark = `${A.dim}○${A.reset}`;
+                body = `${truncateToWidth(t.content, screen.width - 6)}`;
+            }
+            lines.push(`  ${mark} ${body}`);
+        }
+        const more = currentTodos.length - max;
+        if (more > 0)
+            lines.push(`${A.dim}  … ${more} more${A.reset}`);
+        return lines;
+    }
     function renderDynamic() {
         const lines = [];
         lines.push(...buildStatusLine());
@@ -651,6 +872,11 @@ export async function runActoviqTui(options = {}) {
         if (running && tail) {
             lines.push(tail);
         }
+        // Live todo panel — shown whenever the agent has a plan, unless a modal
+        // (permission/selection/text-input) is open (those take the region).
+        if (currentTodos.length > 0 && !dialog && !selectionDialog && !textInputDialog) {
+            lines.push(...buildTodoPanel());
+        }
         if (dialog) {
             lines.push(...buildDialog());
         }
@@ -690,6 +916,38 @@ export async function runActoviqTui(options = {}) {
     function appendStatic(lines) {
         screen.appendStatic(lines);
     }
+    // Inline CLI spinner for long async operations (probe, reload).
+    // Writes directly to stdout with \r — independent of the redrawable region.
+    const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let inlineSpinnerTimer = null;
+    function showSpinner(message) {
+        let i = 0;
+        inlineSpinnerTimer = setInterval(() => {
+            process.stdout.write(`\r${A.dim}${SPINNER[i++ % SPINNER.length]} ${message}${A.reset}`);
+        }, 80);
+    }
+    function stopSpinner() {
+        if (inlineSpinnerTimer) {
+            clearInterval(inlineSpinnerTimer);
+            inlineSpinnerTimer = null;
+        }
+        process.stdout.write('\r\x1b[K');
+    }
+    /** Run an async operation with an inline spinner — no flicker for sub-100ms ops. */
+    async function withSpinner(message, fn) {
+        const start = Date.now();
+        showSpinner(message);
+        try {
+            const result = await fn();
+            const elapsed = Date.now() - start;
+            if (elapsed < 120)
+                await new Promise(r => setTimeout(r, 120 - elapsed)); // min display
+            return result;
+        }
+        finally {
+            stopSpinner();
+        }
+    }
     // ── Agent run ──────────────────────────────────────────────────────
     // /model router: pick a saved router profile (or turn routing off). When
     // active, each user turn is classified and routed to a model in startRun().
@@ -740,6 +998,50 @@ export async function runActoviqTui(options = {}) {
             appendStatic([...formatInfoLine(`router active: ${found.profile.name} — turns routed by ${found.profile.routerModel.model}`), '']);
         }
     }
+    // Expand @<image-path> tokens into Anthropic image content blocks so the
+    // user can attach screenshots/designs inline (gap #4, partial — clipboard
+    // capture is platform-specific, so this is the @path route only). Returns a
+    // string when there are no image refs (the common case) so the run path is
+    // unchanged; otherwise a ContentBlockParam[] with text + base64 image blocks.
+    function expandImageRefs(text) {
+        const refs = text.match(/@([\w./\\-]+\.(?:png|jpe?g|gif|webp|bmp))/gi);
+        if (!refs)
+            return text;
+        const blocks = [];
+        let cursor = 0;
+        const seen = new Set();
+        let imagesAdded = 0;
+        for (const ref of refs) {
+            const raw = ref.slice(1); // strip @
+            const resolved = path.resolve(workDir, raw);
+            if (seen.has(resolved))
+                continue;
+            let data;
+            try {
+                data = fs.readFileSync(resolved).toString('base64');
+            }
+            catch {
+                continue; // not readable — leave the @token in the text below
+            }
+            const at = text.indexOf(ref, cursor);
+            if (at > cursor)
+                blocks.push({ type: 'text', text: text.slice(cursor, at) });
+            const ext = path.extname(raw).slice(1).toLowerCase();
+            const mediaType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`;
+            blocks.push({
+                type: 'image',
+                source: { type: 'base64', media_type: mediaType, data },
+            });
+            cursor = at + ref.length;
+            seen.add(resolved);
+            imagesAdded++;
+        }
+        if (cursor < text.length)
+            blocks.push({ type: 'text', text: text.slice(cursor) });
+        // If no image actually loaded, fall back to the original string so the run
+        // path is unchanged (the @tokens stay literal for the model to ignore).
+        return imagesAdded > 0 ? blocks : text;
+    }
     async function startRun(text) {
         running = true;
         runStartedAt = Date.now();
@@ -754,10 +1056,11 @@ export async function runActoviqTui(options = {}) {
         }, 120);
         appendStatic(formatUserPrompt(text));
         renderDynamic();
-        // /model router: classify this turn and route it to the chosen model
-        // (possibly on a different provider). The turn then runs normally.
+        // /model router: classify this turn and route it to a model (possibly on a
+        // different provider). Only applies to the in-process SDK — bridge mode
+        // runs on the fixed provider+model, so routing is skipped there.
         let routed;
-        if (activeRouter) {
+        if (activeRouter && !bridgeMode) {
             try {
                 const decision = await resolveRoutedRun(activeRouter, text, abortCtrl.signal);
                 routed = { model: decision.model, modelApi: decision.modelApi };
@@ -769,24 +1072,66 @@ export async function runActoviqTui(options = {}) {
             }
         }
         try {
-            const stream = session.stream(text, {
-                systemPrompt,
-                signal: abortCtrl.signal,
-                permissionMode: currentPermissionMode(),
-                effort: currentEffort(),
-                approver,
-                ...(routed ? { model: routed.model, modelApi: routed.modelApi } : {}),
-                ...(activeTeamTool ? { tools: [...tools, activeTeamTool] } : {}),
-                ...(canUseTool ? { canUseTool } : {}),
-                drainQueuedInputs: () => {
-                    const drained = queuedInputs.splice(0);
-                    return drained;
-                },
-            });
-            for await (const event of stream) {
+            // Branch the event source. Bridge mode spawns the configured runtime CLI
+            // and adapts its events into the same AgentEvent stream the rest of this
+            // loop consumes — so a bridge run reuses the spinner, tool cards, Esc
+            // interrupt, steering queue, and history exactly like a normal run. The
+            // bridge stream has no mid-run drain, so steering typed during a bridge
+            // run queues and becomes the next turn (handled by the tail below).
+            let eventStream;
+            let resultPromise;
+            if (bridgeMode && activeBridgeModelApi) {
+                // Bridge mode: run in-process through the selected config's
+                // provider/apiKey/baseURL/model (no child process). Inject the
+                // pre-built {model, modelApi} into session.stream — the /model
+                // router's proven mechanism for cross-provider routing. Same
+                // session → context intact; switching bridge↔hadamard is seamless.
+                statusNote = `bridge:${activeBridgeConfig?.name ?? 'bridge'}`;
+                const stream = session.stream(expandImageRefs(text), {
+                    systemPrompt: applyOutputStyle(systemPrompt + buildAgentContext(), outputStyle),
+                    signal: abortCtrl.signal,
+                    permissionMode: currentPermissionMode(),
+                    effort: currentEffort(),
+                    approver,
+                    classifier: preToolUseHookClassifier,
+                    model: activeBridgeModelApi.model,
+                    modelApi: activeBridgeModelApi.modelApi,
+                    ...(activeTeamTool ? { tools: [...tools, activeTeamTool] } : {}),
+                    ...(canUseTool ? { canUseTool } : {}),
+                    drainQueuedInputs: () => {
+                        const drained = queuedInputs.splice(0);
+                        return drained;
+                    },
+                });
+                eventStream = stream;
+                resultPromise = stream.result;
+            }
+            else {
+                const stream = session.stream(expandImageRefs(text), {
+                    systemPrompt: applyOutputStyle(systemPrompt + buildAgentContext(), outputStyle),
+                    signal: abortCtrl.signal,
+                    permissionMode: currentPermissionMode(),
+                    effort: currentEffort(),
+                    approver,
+                    classifier: preToolUseHookClassifier,
+                    ...(routed ? { model: routed.model, modelApi: routed.modelApi } : {}),
+                    ...(activeTeamTool ? { tools: [...tools, activeTeamTool] } : {}),
+                    ...(canUseTool ? { canUseTool } : {}),
+                    drainQueuedInputs: () => {
+                        const drained = queuedInputs.splice(0);
+                        return drained;
+                    },
+                });
+                eventStream = stream;
+                resultPromise = stream.result;
+            }
+            for await (const event of eventStream) {
                 handleAgentEvent(event);
             }
-            const result = await stream.result;
+            const result = await resultPromise;
+            // Accumulate token + USD usage for /cost and /usage. The model is the
+            // routed model (if a router is active) or the session model. Bridge runs
+            recordUsage(routed?.model ?? activeBridgeModelApi?.model ?? session.model, result.usage);
             const rest = flusher.drain();
             if (rest.length > 0)
                 appendStatic(rest);
@@ -864,7 +1209,26 @@ export async function runActoviqTui(options = {}) {
                     appendStatic(pending);
                 runToolCount += 1;
                 statusNote = event.call.publicName;
-                appendStatic(formatToolCall(event.call.publicName, event.call.input, screen.width));
+                toolCallNames.set(event.call.id, event.call.publicName);
+                // Render Edit calls as a colored old→new diff instead of a one-liner.
+                appendStatic(event.call.publicName === 'Edit'
+                    ? formatEditCall(event.call.input, screen.width)
+                    : formatToolCall(event.call.publicName, event.call.input, screen.width));
+                // Capture the live todo list from TodoWrite calls so the persistent
+                // panel (renderDynamic) reflects the agent's current plan + progress.
+                if (event.call.publicName === 'TodoWrite') {
+                    const todos = event.call.input?.todos;
+                    if (Array.isArray(todos)) {
+                        currentTodos = todos
+                            .filter((t) => typeof t === 'object' && t !== null)
+                            .map(t => ({
+                            content: String(t.content ?? ''),
+                            status: String(t.status ?? 'pending'),
+                            activeForm: typeof t.activeForm === 'string' && t.activeForm ? t.activeForm : undefined,
+                        }));
+                        scheduleDynamicRender();
+                    }
+                }
                 renderDynamic();
                 return;
             }
@@ -883,6 +1247,11 @@ export async function runActoviqTui(options = {}) {
                     durationMs: event.result.durationMs,
                     outputText: event.result.outputText,
                 }, screen.width));
+                // Run matching PostToolUse hooks (fire-and-forget, never block).
+                const toolName = toolCallNames.get(event.result.id);
+                if (toolName) {
+                    runPostToolUseHooks(() => readPostToolUseHooks(getLoadedJsonConfig()?.raw), toolName, null, event.result.outputText ?? '', sdk.config.workDir);
+                }
                 renderDynamic();
                 return;
             case 'conversation.compacted':
@@ -908,17 +1277,31 @@ export async function runActoviqTui(options = {}) {
         const usage = {
             help: '/help',
             clear: '/clear',
+            init: '/init',
             compact: '/compact [summary instructions]',
             memory: '/memory',
+            context: '/context',
+            cost: '/cost',
+            usage: '/usage',
+            doctor: '/doctor',
+            batch: '/batch <file>',
+            goal: '/goal [objective|clear|pause|resume]',
+            review: '/review',
+            stats: '/stats',
+            export: '/export [filename]',
             model: '/model [model|min|medium|max|default|config|router]',
             effort: '/effort [low|medium|high|max|auto]',
+            'output-style': '/output-style [default|concise|explanatory|learning]',
             permissions: '/permissions [default|acceptEdits|plan|bypassPermissions|auto]',
+            plan: '/plan [off|open|view]',
+            rewind: '/rewind <N>',
             sessions: '/sessions',
             resume: '/resume [session-id]',
             tools: '/tools',
             skills: '/skills',
             agents: '/agents',
             mcp: '/mcp',
+            hooks: '/hooks',
             plugins: '/plugins',
             dream: '/dream [run|status]',
             workflows: '/workflows [run <name>|list]',
@@ -1072,7 +1455,7 @@ export async function runActoviqTui(options = {}) {
                 }
                 await persistActoviqSettingsStore(store.configPath, raw);
                 await loadJsonConfigFile(store.configPath);
-                await reloadCleanSdk();
+                await withSpinner('reloading SDK', reloadCleanSdk);
                 appendStatic([
                     ...formatInfoLine(`model settings saved: ${store.configPath}`),
                     '',
@@ -1142,6 +1525,498 @@ export async function runActoviqTui(options = {}) {
             }
         }
     }
+    async function configureBridgeSettings() {
+        const store = await resolveActoviqSettingsStore({ configPath: options.configPath });
+        const raw = structuredClone(store.raw);
+        const bridge = raw.bridge ?? {};
+        let dirty = false;
+        const detections = await detectBridgeProviders();
+        while (true) {
+            const defaultLabel = (typeof bridge.defaultProvider === 'string' ? bridge.defaultProvider : 'claude');
+            const providerItems = detections.map((d) => ({
+                id: `provider:${d.id}`,
+                label: `${d.id}${d.available ? '' : ' (not found)'}`,
+                description: d.version ? `v${d.version}${d.path ? ` · ${d.path}` : ''}` : 'not detected',
+            }));
+            const selected = await selectItem({
+                title: 'Bridge runtime settings',
+                subtitle: store.configPath,
+                searchable: false,
+                items: [
+                    { id: 'default', label: 'Default provider', description: defaultLabel },
+                    ...providerItems,
+                    { id: 'save', label: 'Save and apply', description: dirty ? 'Unsaved changes' : 'No changes' },
+                    { id: 'cancel', label: 'Cancel' },
+                ],
+            });
+            if (!selected || selected === 'cancel')
+                return;
+            if (selected === 'save') {
+                if (!dirty) {
+                    appendStatic([...formatInfoLine('bridge settings unchanged'), '']);
+                    return;
+                }
+                raw.bridge = bridge;
+                await persistActoviqSettingsStore(store.configPath, raw);
+                await loadJsonConfigFile(store.configPath);
+                appendStatic([...formatInfoLine(`bridge settings saved: ${store.configPath}`), '']);
+                return;
+            }
+            if (selected === 'default') {
+                const providerChoices = detections.map((d) => ({
+                    id: d.id,
+                    label: d.id,
+                    description: d.available ? (d.version ?? 'detected') : 'not found',
+                }));
+                const provider = await selectItem({
+                    title: 'Select default bridge provider',
+                    searchable: false,
+                    items: providerChoices,
+                });
+                if (provider) {
+                    bridge.defaultProvider = provider;
+                    dirty = true;
+                }
+                continue;
+            }
+            if (selected.startsWith('provider:')) {
+                const pid = selected.slice('provider:'.length);
+                const providers = bridge.providers ?? {};
+                const entry = providers[pid] ?? {};
+                const pathInput = await promptText({
+                    title: `Executable path for ${pid}`,
+                    label: 'Path',
+                    description: `Leave empty to auto-detect on PATH. Current: ${entry.path ?? 'auto'}`,
+                    initial: entry.path ?? '',
+                });
+                if (pathInput !== undefined) {
+                    if (pathInput.trim())
+                        entry.path = pathInput.trim();
+                    else
+                        delete entry.path;
+                    providers[pid] = entry;
+                    bridge.providers = providers;
+                    dirty = true;
+                }
+                continue;
+            }
+        }
+    }
+    async function runBridgePrompt(prompt) {
+        // /bridge run forces a bridge turn. If no config is active, open the board
+        // (or error if none saved) rather than auto-picking a detected runtime.
+        if (!bridgeMode || !activeBridgeModelApi) {
+            const configs = readBridgeConfigs().configs;
+            if (configs.length === 0) {
+                appendStatic([...formatErrorLine('No bridge configs saved. Use /bridge config to add one.'), '']);
+                return;
+            }
+            appendStatic([...formatInfoLine('No active bridge config — select one from the board.'), '']);
+            return;
+        }
+        await startRun(prompt);
+    }
+    async function disableBridge() {
+        // Switch back to the SDK's default model/provider. The conversation
+        // context stays intact (same session). Config stays saved for re-activation.
+        bridgeMode = false;
+        activeBridgeConfig = null;
+        activeBridgeModelApi = null;
+        appendStatic([
+            ...formatInfoLine('bridge mode off — back to default provider (session intact)'),
+            '',
+        ]);
+    }
+    function printBridgeHelp() {
+        appendStatic([
+            ...formatInfoLine('/bridge sub-commands:'),
+            `  ${A.dim}(bare)${A.reset}       — list saved configs; pick one to activate`,
+            `  ${A.dim}config${A.reset}      — add / edit / remove named connection configs`,
+            `  ${A.dim}run <prompt>${A.reset}  — run one turn through the active runtime`,
+            `  ${A.dim}switch <name>${A.reset} — activate a saved config by name (or a raw provider id)`,
+            `  ${A.dim}model [id]${A.reset} — set model for the current runtime`,
+            `  ${A.dim}setup${A.reset}      — detect + configure paths (legacy)`,
+            `  ${A.dim}off${A.reset}        — disable bridge mode`,
+            `  ${A.dim}help${A.reset}       — show this list`,
+            ...formatInfoLine('a saved config bundles name + provider + apiKey + baseURL + model;'),
+            ...formatInfoLine('activating it runs every prompt through that runtime with those'),
+            ...formatInfoLine('credentials injected (multi-turn via --resume). configs persist in'),
+            ...formatInfoLine('~/.actoviq/bridge-configs.json. provider multi-turn sessions are'),
+            ...formatInfoLine('retained across /bridge off; bridge turns also save to the hadamard session.'),
+            '',
+        ]);
+    }
+    async function openBridgeBoard() {
+        // The /bridge board lists SAVED connection configs (the user's presets).
+        // Selecting one activates that runtime with the config's credentials
+        // injected. No-config fallbacks (legacy provider switch, setup, detect)
+        // live under the actions so nothing is lost.
+        const configs = readBridgeConfigs().configs;
+        const state = bridgeMode
+            ? `${A.green}(active)${A.reset}`
+            : `${A.dim}(idle)${A.reset}`;
+        const activeCfg = activeBridgeConfig?.name ?? (bridgeMode ? 'active' : null);
+        const lines = [
+            `Bridge ${state}${activeCfg ? ` · ${A.bold}${activeCfg}${A.reset}` : ''}`,
+            ...formatDivider(screen.width),
+        ];
+        if (configs.length === 0) {
+            lines.push(`  ${A.dim}no saved configs — use "/bridge config" to add one${A.reset}`);
+        }
+        else {
+            for (const c of configs) {
+                const active = activeBridgeConfig?.name === c.name;
+                const mark = active ? `${A.green}●${A.reset}` : `${A.dim}○${A.reset}`;
+                lines.push(`  ${mark} ${A.bold}${c.name}${A.reset} ${A.dim}· ${c.provider}${A.reset}${c.model ? ` ${A.dim}· ${c.model}${A.reset}` : ''}`);
+                lines.push(`      ${A.dim}key: ${maskApiKey(c.apiKey)}${c.baseURL ? ` · ${c.baseURL}` : ''}${A.reset}`);
+            }
+        }
+        lines.push('');
+        appendStatic(lines);
+        const choice = await selectItem({
+            title: 'Bridge',
+            subtitle: activeCfg ? `active: ${activeCfg}` : 'no active config',
+            searchable: false,
+            items: [
+                // One item per saved config → selecting activates it.
+                ...configs.map(c => ({
+                    id: `c:${c.name}`,
+                    label: `${c.name}${activeBridgeConfig?.name === c.name ? ' *' : ''}`,
+                    description: `${c.provider} · ${maskApiKey(c.apiKey)}${c.model ? ` · ${c.model}` : ''}`,
+                })),
+                { id: 'config', label: '⚙ Manage configs…', description: 'add / edit / remove saved configs' },
+                { id: 'run', label: '▶ Run a prompt…', description: 'run one turn through the active runtime' },
+                { id: 'model', label: '◈ Model', description: 'set model for the active runtime' },
+                { id: 'setup', label: '✎ Edit paths…', description: 'per-provider executable + default (legacy)' },
+                { id: 'detect', label: '↻ Re-detect runtimes', description: 're-scan PATH for installed CLIs' },
+                ...(bridgeMode ? [{ id: 'off', label: '■ Disable bridge', description: 'back to in-process SDK' }] : []),
+                { id: 'help', label: '? Help', description: 'show /bridge sub-commands' },
+            ],
+        });
+        if (!choice)
+            return;
+        if (choice.startsWith('c:')) {
+            const name = choice.slice(2);
+            const cfg = configs.find(c => c.name === name);
+            if (cfg)
+                await activateBridgeConfig(cfg);
+            return;
+        }
+        if (choice === 'config') {
+            await manageBridgeConfigs();
+            return;
+        }
+        if (choice === 'run') {
+            const task = await promptText({ title: 'Bridge run', label: 'Prompt' });
+            if (task?.trim())
+                await runBridgePrompt(task.trim());
+            return;
+        }
+        if (choice === 'model') {
+            await selectBridgeModel();
+            return;
+        }
+        if (choice === 'setup') {
+            await configureBridgeSettings();
+            return;
+        }
+        if (choice === 'detect') {
+            const refreshed = await detectBridgeProviders();
+            appendStatic(['', ...refreshed.map((d) => `${d.available ? '✔' : '✘'} ${d.id} ${d.version ?? ''}`), '']);
+            return;
+        }
+        if (choice === 'off') {
+            await disableBridge();
+            return;
+        }
+        if (choice === 'help') {
+            printBridgeHelp();
+            return;
+        }
+    }
+    // Activate a named bridge config — the in-process path. Pre-builds a ModelApi
+    // via buildRouteModelApi so each turn can inject {model, modelApi} into
+    // session.stream (same session, context naturally survives switching).
+    async function activateBridgeConfig(config) {
+        try {
+            const routed = await buildRouteModelApi({
+                model: config.model || session.model,
+                provider: config.provider,
+                baseURL: config.baseURL,
+                apiKey: config.apiKey,
+                maxTokens: 32000,
+            });
+            activeBridgeModelApi = routed;
+            bridgeModelLabel = routed.model;
+            activeBridgeConfig = config;
+            bridgeMode = true;
+            appendStatic([
+                ...formatInfoLine(`bridge active — config: ${config.name} · provider: ${config.provider} · model: ${routed.model}`),
+                ...formatInfoLine(`apiKey: ${maskApiKey(config.apiKey)}${config.baseURL ? ` · baseURL: ${config.baseURL}` : ''}`),
+                ...formatInfoLine(`normal prompts now run through ${config.name}; /bridge off switches back to the default provider`),
+                '',
+            ]);
+            return true;
+        }
+        catch (error) {
+            appendStatic([...formatErrorLine(`bridge activation failed: ${error.message}`), '']);
+            return false;
+        }
+    }
+    // /bridge config — manage named connection configs (the management screen).
+    async function manageBridgeConfigs() {
+        while (true) {
+            const store = readBridgeConfigs();
+            const lines = [
+                `${A.bold}Bridge configs${A.reset} ${A.dim}(~/.actoviq/bridge-configs.json)${A.reset}`,
+            ];
+            if (store.configs.length === 0) {
+                lines.push(`  ${A.dim}no configs yet — add one to connect a runtime by name${A.reset}`);
+            }
+            else {
+                for (const c of store.configs) {
+                    const active = activeBridgeConfig?.name === c.name;
+                    const star = active ? ` ${A.green}*${A.reset}` : '';
+                    lines.push(`  ${A.bold}${c.name}${A.reset} ${A.dim}· ${c.provider}${A.reset}${star}`);
+                    lines.push(`    ${A.dim}key: ${maskApiKey(c.apiKey)}${c.baseURL ? ` · ${c.baseURL}` : ''}${c.model ? ` · ${c.model}` : ''}${A.reset}`);
+                }
+            }
+            lines.push('');
+            appendStatic(lines);
+            const choice = await selectItem({
+                title: 'Bridge configs',
+                searchable: false,
+                items: [
+                    { id: 'add', label: '+ Add config…', description: 'open the config editor with empty fields' },
+                    ...(store.configs.length > 0
+                        ? [
+                            { id: 'edit', label: '✎ Edit config…', description: 'modify any field of a saved config' },
+                            { id: 'remove', label: '− Remove config…', description: 'delete a saved config' },
+                        ]
+                        : []),
+                    { id: 'back', label: '↩ Back', description: 'return to the prompt' },
+                ],
+            });
+            if (!choice || choice === 'back')
+                return;
+            if (choice === 'add') {
+                const created = await editBridgeConfig();
+                if (created) {
+                    addBridgeConfig(created);
+                    appendStatic([...formatInfoLine(`saved config "${created.name}" — select it via /bridge to activate`), '']);
+                }
+                continue;
+            }
+            if (choice === 'edit') {
+                const name = await selectItem({
+                    title: 'Edit config',
+                    searchable: false,
+                    items: store.configs.map(c => ({ id: c.name, label: c.name, description: `${c.provider} · ${maskApiKey(c.apiKey)}` })),
+                });
+                if (!name)
+                    continue;
+                const existing = store.configs.find(c => c.name === name);
+                const updated = await editBridgeConfig(existing);
+                if (updated) {
+                    addBridgeConfig(updated); // dedupe-by-name replaces
+                    // If the edited config is active, refresh the live activeBridgeConfig.
+                    if (activeBridgeConfig?.name === existing.name || activeBridgeConfig?.name === updated.name) {
+                        activeBridgeConfig = updated;
+                        appendStatic([...formatInfoLine(`active config "${updated.name}" updated — applies next turn`), '']);
+                    }
+                    else {
+                        appendStatic([...formatInfoLine(`config "${updated.name}" saved`), '']);
+                    }
+                }
+                continue;
+            }
+            if (choice === 'remove') {
+                const name = await selectItem({
+                    title: 'Remove config',
+                    searchable: false,
+                    items: store.configs.map(c => ({ id: c.name, label: c.name, description: `${c.provider} · ${maskApiKey(c.apiKey)}` })),
+                });
+                if (!name)
+                    continue;
+                removeBridgeConfig(name);
+                if (activeBridgeConfig?.name === name) {
+                    appendStatic([...formatInfoLine(`removed active config "${name}" — bridge mode still on (provider: ${activeBridgeConfig?.provider ?? '?'})`), '']);
+                }
+                else {
+                    appendStatic([...formatInfoLine(`removed config "${name}"`), '']);
+                }
+                continue;
+            }
+        }
+    }
+    // Single-page config editor: shows ALL fields at once (with current values),
+    // and the user can edit any field in any order — e.g. set the key, then go
+    // back and change the name — before Save / Cancel. A field is selected via the
+    // menu, re-prompted, then the loop re-renders the whole form with the new
+    // value. Returns the config on Save, undefined on Cancel.
+    async function editBridgeConfig(existing) {
+        // Work on a local copy so Cancel discards all edits.
+        const draft = existing
+            ? { name: existing.name, provider: existing.provider, runtime: existing.runtime, ...(existing.apiKey ? { apiKey: existing.apiKey } : {}), ...(existing.baseURL ? { baseURL: existing.baseURL } : {}), ...(existing.model ? { model: existing.model } : {}) }
+            : { name: '', provider: 'anthropic', runtime: 'claude' };
+        // Lazy-detect: runtimes are probed only when the user opens the runtime
+        // picker, so the form renders instantly. Cached after first probe.
+        let detections = null;
+        while (true) {
+            // Render the live form.
+            const header = existing ? `Editing "${existing.name}"` : 'New bridge config';
+            const lines = [
+                `${A.bold}${header}${A.reset} — edit any field, then Save`,
+                ...formatDivider(screen.width),
+                `  ${A.bold}name${A.reset}     ${draft.name || `${A.dim}(unset)${A.reset}`}`,
+                `  ${A.bold}runtime${A.reset}   ${A.bold}${draft.provider === 'anthropic' ? 'claude / codewhale / reasonix' : 'pi / codex / crush'}${A.reset} ${A.dim}(${draft.provider})${A.reset}`,
+                `  ${A.bold}apiKey${A.reset}   ${maskApiKey(draft.apiKey)}`,
+                `  ${A.bold}baseURL${A.reset} ${draft.baseURL || `${A.dim}(inherit)${A.reset}`}`,
+                `  ${A.bold}model${A.reset}    ${draft.model || `${A.dim}(inherit)${A.reset}`}`,
+                '',
+            ];
+            appendStatic(lines);
+            const choice = await selectItem({
+                title: existing ? `Edit ${existing.name}` : 'New config',
+                subtitle: 'edit any field in any order · Save to commit',
+                searchable: false,
+                items: [
+                    { id: 'name', label: `name: ${draft.name || '(unset)'}`, description: 'a label you pick, e.g. deepseek-claude' },
+                    { id: 'provider', label: `runtime: ${draft.provider === 'anthropic' ? 'claude / codewhale / reasonix' : 'pi / codex / crush'}`, description: `${draft.provider} · pick from detected runtimes` },
+                    { id: 'apiKey', label: `apiKey: ${maskApiKey(draft.apiKey)}`, description: 'injected as the credential each turn (hidden input)' },
+                    { id: 'baseURL', label: `baseURL: ${draft.baseURL || '(inherit)'}`, description: 'the backend endpoint (e.g. https://api.deepseek.com)' },
+                    { id: 'model', label: `model: ${draft.model || '(inherit)'}`, description: 'optional model id' },
+                    { id: 'save', label: '💾 Save config', description: draft.name ? `commit "${draft.name}"` : 'a name is required to save' },
+                    { id: 'cancel', label: '✕ Cancel', description: 'discard changes' },
+                ],
+            });
+            if (!choice || choice === 'cancel')
+                return undefined;
+            if (choice === 'save') {
+                const name = draft.name.trim();
+                if (!name) {
+                    appendStatic([...formatErrorLine('cannot save — name is required (edit the name field first)'), '']);
+                    continue;
+                }
+                const config = { name, provider: draft.provider, runtime: draft.runtime };
+                if (draft.apiKey)
+                    config.apiKey = draft.apiKey;
+                if (draft.baseURL)
+                    config.baseURL = draft.baseURL;
+                if (draft.model)
+                    config.model = draft.model;
+                if (draft.apiKey)
+                    config.apiKey = draft.apiKey;
+                if (draft.baseURL)
+                    config.baseURL = draft.baseURL;
+                if (draft.model)
+                    config.model = draft.model;
+                return config;
+            }
+            if (choice === 'name') {
+                const v = (await promptText({ title: 'Config name', label: 'name', initial: draft.name, description: 'a label you pick, e.g. deepseek-claude' }))?.trim();
+                if (v !== undefined)
+                    draft.name = v;
+                continue;
+            }
+            if (choice === 'provider') {
+                // Show detected runtimes as the primary options; each maps to an
+                // in-process provider. Detection is lazy — probed only when the user
+                // opens this picker, so the form renders instantly.
+                if (!detections) {
+                    detections = await withSpinner('scanning for runtimes', detectBridgeProviders);
+                }
+                const RUNTIME_MAP = {
+                    claude: { provider: 'anthropic', label: 'claude' },
+                    codewhale: { provider: 'anthropic', label: 'codewhale' },
+                    reasonix: { provider: 'anthropic', label: 'reasonix' },
+                    pi: { provider: 'openai', label: 'pi' },
+                    codex: { provider: 'openai', label: 'codex' },
+                    crush: { provider: 'openai', label: 'crush' },
+                };
+                const curProvider = draft.provider;
+                const curRuntime = Object.entries(RUNTIME_MAP).find(([, v]) => v.provider === curProvider)?.[0];
+                const items = detections.map(d => ({
+                    id: d.id,
+                    label: `${d.id}${d.id === curRuntime ? ' ✓' : ''}`,
+                    description: `${RUNTIME_MAP[d.id]?.provider ?? '?'}${d.available ? (d.version ? ` · v${d.version}` : ' · detected') : ' · not found'}${d.id === 'reasonix' ? ' · DeepSeek' : d.id === 'crush' ? ' · multi-backend' : ''}`,
+                }));
+                const v = await selectItem({
+                    title: 'Runtime',
+                    subtitle: curRuntime ? `current: ${curRuntime} (${curProvider})` : `current provider: ${curProvider}`,
+                    searchable: false,
+                    items,
+                });
+                if (v) {
+                    const mapped = RUNTIME_MAP[v] ?? { provider: 'anthropic' };
+                    draft.provider = mapped.provider;
+                }
+                continue;
+            }
+            if (choice === 'apiKey') {
+                const initial = draft.apiKey;
+                const v = await promptText({
+                    title: 'API key',
+                    label: 'api key',
+                    secret: true,
+                    initial,
+                    description: 'hidden input · clear to inherit from settings',
+                });
+                if (v !== undefined)
+                    draft.apiKey = v.trim() || undefined;
+                continue;
+            }
+            if (choice === 'baseURL') {
+                const v = (await promptText({ title: 'Base URL', label: 'base url', initial: draft.baseURL, description: 'the backend endpoint; leave empty to inherit' }))?.trim();
+                if (v !== undefined)
+                    draft.baseURL = v || undefined;
+                continue;
+            }
+            if (choice === 'model') {
+                const v = (await promptText({
+                    title: 'Model',
+                    label: 'model',
+                    initial: draft.model,
+                    description: 'a model id (optional, e.g. deepseek-chat, claude-sonnet-4-6)',
+                }))?.trim();
+                if (v !== undefined)
+                    draft.model = v || undefined;
+                continue;
+            }
+        }
+    }
+    async function switchBridgeProvider(target) {
+        if (!target) {
+            appendStatic([...formatInfoLine('usage: /bridge switch <config-name>  (or open /bridge to pick)'), '']);
+            return;
+        }
+        const cfg = findBridgeConfig(target);
+        if (cfg) {
+            await activateBridgeConfig(cfg);
+            return;
+        }
+        appendStatic([...formatErrorLine(`unknown config: ${target} — use /bridge config to add one, or open /bridge to pick`), '']);
+    }
+    async function selectBridgeModel(modelId = '') {
+        const cfgName = activeBridgeConfig?.name ?? 'active';
+        if (modelId) {
+            // Direct set: /bridge model claude-sonnet-4-6
+            bridgeModelLabel = modelId;
+            appendStatic([...formatInfoLine(`bridge model → ${modelId}`), '']);
+            return;
+        }
+        // Picker: prompt for a model ID.
+        const v = (await promptText({
+            title: `Bridge model for ${cfgName}`,
+            label: 'Model ID',
+            initial: bridgeModelLabel ?? '',
+            description: 'enter the model id to use with the bridge config',
+        }));
+        if (v !== undefined) {
+            bridgeModelLabel = v.trim() || null;
+            appendStatic([...formatInfoLine(`bridge model → ${bridgeModelLabel || 'session default'}`), '']);
+        }
+    }
     async function chooseEffort() {
         const selected = await selectItem({
             title: 'Select reasoning effort',
@@ -1168,6 +2043,58 @@ export async function runActoviqTui(options = {}) {
         });
         appendStatic([...formatInfoLine(`effort set to: ${currentEffort() ?? 'auto'}`), '']);
     }
+    // ── /goal: session-scoped goal with status tracking ─────────────────
+    const GOAL_METADATA_KEY = '__actoviqGoal';
+    function getGoal() {
+        const raw = session.metadata[GOAL_METADATA_KEY];
+        if (typeof raw === 'string') {
+            try {
+                return JSON.parse(raw);
+            }
+            catch { /* ignore */ }
+        }
+        if (typeof raw === 'object' && raw !== null)
+            return raw;
+        return null;
+    }
+    async function setGoal(objective) {
+        const goal = { objective, status: 'active', setAt: new Date().toISOString() };
+        await session.mergeMetadata({ [GOAL_METADATA_KEY]: goal });
+    }
+    async function clearGoal() {
+        const md = { ...session.metadata };
+        delete md[GOAL_METADATA_KEY];
+        await session.mergeMetadata(md);
+    }
+    function goalContextLine() {
+        const g = getGoal();
+        if (!g)
+            return '';
+        const statusMarks = { active: `${A.green}▶${A.reset}`, paused: `${A.yellow}‖${A.reset}`, complete: `${A.dim}✓${A.reset}` };
+        return ` · goal:${statusMarks[g.status] ?? ''}${A.dim}${truncateToWidth(g.objective, 30)}${A.reset}`;
+    }
+    async function chooseOutputStyle(arg) {
+        const valid = OUTPUT_STYLES.map(s => s.id);
+        if (arg) {
+            if (!valid.includes(arg)) {
+                appendStatic([...formatErrorLine(`unknown output style: ${arg}. Valid: ${valid.join(', ')}`), '']);
+                return;
+            }
+            outputStyle = arg;
+            appendStatic([...formatInfoLine(`output style → ${outputStyle}`), '']);
+            return;
+        }
+        const selected = await selectItem({
+            title: 'Select output style',
+            subtitle: `Current: ${outputStyle}`,
+            searchable: false,
+            items: OUTPUT_STYLES.map(s => ({ id: s.id, label: s.label, description: s.description })),
+        });
+        if (selected) {
+            outputStyle = selected;
+            appendStatic([...formatInfoLine(`output style → ${outputStyle}`), '']);
+        }
+    }
     async function showSkills() {
         const skills = sdk.skills.listMetadata();
         if (skills.length === 0) {
@@ -1226,23 +2153,100 @@ export async function runActoviqTui(options = {}) {
             tools.push(tool);
             byServer.set(server, tools);
         }
-        if (byServer.size === 0) {
-            appendStatic([...formatInfoLine('no MCP servers are active'), '']);
-            return;
+        const persisted = readMcpServerConfig();
+        const lines = [];
+        if (byServer.size > 0) {
+            lines.push(`${A.bold}Active MCP servers${A.reset} ${A.dim}(${byServer.size})${A.reset}`);
+            for (const [server, tools] of byServer) {
+                lines.push(`  ${A.green}●${A.reset} ${A.bold}${server}${A.reset} ${A.dim}— ${tools.length} tool${tools.length === 1 ? '' : 's'}${A.reset}`);
+            }
         }
-        const selected = await selectItem({
+        else {
+            lines.push(`${A.dim}no MCP servers are active${A.reset}`);
+        }
+        if (persisted.servers.length > 0) {
+            lines.push(`${A.bold}Configured servers${A.reset} ${A.dim}(~/.actoviq/mcp.json)${A.reset}`);
+            for (const s of persisted.servers) {
+                lines.push(`  ${A.dim}·${A.reset} ${s.name} ${A.dim}→ ${s.command}${s.args?.length ? ' ' + s.args.join(' ') : ''}${A.reset}`);
+            }
+        }
+        lines.push('');
+        appendStatic(lines);
+        const choice = await selectItem({
             title: 'MCP servers',
-            items: [...byServer.entries()].map(([server, tools]) => ({
-                id: server,
-                label: server,
-                description: `${tools.length} tool${tools.length === 1 ? '' : 's'}`,
-                detail: tools.map(tool => tool.name).join(', '),
-            })),
+            searchable: false,
+            items: [
+                { id: 'add', label: '+ Add stdio server…', description: 'persist a stdio MCP server to ~/.actoviq/mcp.json' },
+                ...(persisted.servers.length > 0
+                    ? [{ id: 'remove', label: '− Remove server…', description: 'delete a configured server and reload' }]
+                    : []),
+                { id: 'reload', label: '↻ Reload SDK', description: 'recreate the client to pick up config changes' },
+                ...(byServer.size > 0
+                    ? [...byServer.entries()].map(([server, tools]) => ({
+                        id: `view:${server}`,
+                        label: server,
+                        description: `${tools.length} tool${tools.length === 1 ? '' : 's'}: ${tools.map(t => t.name).slice(0, 6).join(', ')}${tools.length > 6 ? '…' : ''}`,
+                    }))
+                    : []),
+            ],
         });
-        if (selected) {
+        if (!choice)
+            return;
+        if (choice === 'add') {
+            const name = (await promptText({ title: 'MCP server name', label: 'name' }))?.trim();
+            if (!name)
+                return;
+            const kind = await selectItem({
+                title: 'Server type',
+                items: [
+                    { id: 'stdio', label: 'stdio', description: 'local process (e.g. npx, python, a binary)' },
+                    { id: 'http', label: 'http', description: 'remote streamable HTTP MCP server (url)' },
+                ],
+            });
+            if (!kind)
+                return;
+            if (kind === 'stdio') {
+                const command = (await promptText({ title: `Command for ${name}`, label: 'command', description: 'e.g. npx or a binary path' }))?.trim();
+                if (!command)
+                    return;
+                const argsRaw = await promptText({ title: `Args for ${name}`, label: 'args', description: 'space-separated (optional)' });
+                addMcpServer({ name, command, ...(argsRaw?.trim() ? { args: argsRaw.trim().split(/\s+/) } : {}) });
+            }
+            else {
+                const url = (await promptText({ title: `URL for ${name}`, label: 'url', description: 'e.g. https://mcp.example.com' }))?.trim();
+                if (!url)
+                    return;
+                const headersRaw = await promptText({ title: `Headers for ${name}`, label: 'headers', description: 'key:value, comma-separated (optional)' });
+                const headers = headersRaw?.trim() ? Object.fromEntries(headersRaw.split(',').map(p => p.split(':').map(s => s.trim())).filter(a => a.length === 2)) : undefined;
+                addMcpServer({ name, url, ...(headers ? { headers } : {}) });
+            }
+            appendStatic([...formatInfoLine(`added MCP server "${name}" — reloading SDK`), '']);
+            await withSpinner('reloading SDK', reloadCleanSdk);
+            return;
+        }
+        if (choice === 'remove') {
+            const name = await selectItem({
+                title: 'Remove MCP server',
+                searchable: false,
+                items: persisted.servers.map(s => ({ id: s.name, label: s.name, description: `${s.command}` })),
+            });
+            if (!name)
+                return;
+            removeMcpServer(name);
+            appendStatic([...formatInfoLine(`removed MCP server "${name}" — reloading SDK`), '']);
+            await withSpinner('reloading SDK', reloadCleanSdk);
+            return;
+        }
+        if (choice === 'reload') {
+            await withSpinner('reloading SDK', reloadCleanSdk);
+            appendStatic([...formatInfoLine('SDK reloaded — MCP config re-read'), '']);
+            return;
+        }
+        if (choice.startsWith('view:')) {
+            const server = choice.slice('view:'.length);
             appendStatic([
-                `${A.cyan}${selected}${A.reset}`,
-                `${A.dim}${(byServer.get(selected) ?? []).map(tool => tool.name).join(', ')}${A.reset}`,
+                `${A.cyan}${server}${A.reset}`,
+                `${A.dim}${(byServer.get(server) ?? []).map(tool => tool.name).join(', ')}${A.reset}`,
                 '',
             ]);
         }
@@ -1342,6 +2346,13 @@ export async function runActoviqTui(options = {}) {
                     process.stdout.write('\x1b[2J\x1b[H');
                     renderDynamic();
                     return;
+                case 'init': {
+                    // Bootstrap a CLAUDE.md by having the agent explore the repo and
+                    // write concise guidance — complements the CLAUDE.md loader (the
+                    // generated file is then injected into every system prompt).
+                    await startRun('Create or update a CLAUDE.md at the repo root with concise guidance for AI coding assistants: the build/test/lint/run commands, a short architecture overview, key conventions, and non-obvious gotchas. Explore with Glob, Grep, and Read first (package.json, README, existing CLAUDE.md, key source dirs). If a CLAUDE.md already exists, improve it without discarding user-authored sections. Keep it focused — no filler.');
+                    return;
+                }
                 case 'exit':
                 case 'quit':
                     await shutdown(0);
@@ -1369,6 +2380,9 @@ export async function runActoviqTui(options = {}) {
                     else
                         await setEffort(args.toLowerCase());
                     return;
+                case 'output-style':
+                    await chooseOutputStyle(args.toLowerCase());
+                    return;
                 case 'permissions': {
                     // Three presets, selectable or named directly:
                     //   read-only  → deny mutating tools (read / search / web only)
@@ -1411,6 +2425,70 @@ export async function runActoviqTui(options = {}) {
                     ]);
                     return;
                 }
+                case 'plan': {
+                    // Plan mode (gap #6). The model can enter/exit via EnterPlanMode /
+                    // ExitPlanMode tools; /plan toggles the permission mode and lets the
+                    // user view/open the plan file the agent wrote.
+                    const arg = args.trim().toLowerCase();
+                    if (arg === 'off') {
+                        await session.setPermissionContext({ mode: permissionMode === 'bypassPermissions' ? 'bypassPermissions' : 'default', permissions: [], approver });
+                        appendStatic([...formatInfoLine('plan mode off — back to default permissions'), '']);
+                        return;
+                    }
+                    if (arg === 'open') {
+                        const file = planFilePath(sdk.config.workDir);
+                        try {
+                            const editorBin = process.env.EDITOR || process.env.VISUAL || 'notepad';
+                            spawnSync(editorBin, [file], { stdio: 'ignore', shell: false });
+                        }
+                        catch {
+                            appendStatic([...formatErrorLine(`could not open plan file: ${file}`), '']);
+                        }
+                        return;
+                    }
+                    // Default: enter plan mode (if not already) and show the current plan.
+                    const current = session.permissionContext.mode;
+                    if (current !== 'plan') {
+                        await session.setPermissionContext({ mode: 'plan', permissions: [], approver });
+                        appendStatic([...formatInfoLine('plan mode on — mutating tools blocked; research, then ExitPlanMode'), '']);
+                    }
+                    const plan = readPlanFile(sdk.config.workDir);
+                    if (plan) {
+                        appendStatic([
+                            `${A.bold}Current plan${A.reset} ${A.dim}(${planFilePath(sdk.config.workDir)})${A.reset}`,
+                            '',
+                            ...renderRichText(plan, screen.width),
+                            '',
+                        ]);
+                    }
+                    else {
+                        appendStatic([...formatInfoLine('no plan yet — ask the agent to plan a task (it will call ExitPlanMode)'), '']);
+                    }
+                    return;
+                }
+                case 'rewind': {
+                    const n = parseInt(args, 10);
+                    if (!n || n < 1) {
+                        appendStatic([...formatErrorLine('usage: /rewind <N> — drops the last N messages (best-effort, no file restore)'), '']);
+                        return;
+                    }
+                    const msgs = session.messages;
+                    if (n >= msgs.length) {
+                        appendStatic([...formatErrorLine('cannot rewind beyond session start'), '']);
+                        return;
+                    }
+                    const kept = msgs.slice(0, msgs.length - n);
+                    // Create a fresh session with only the kept messages.
+                    const nextSession = await sdk.createSession({ title: session.title, model: session.model });
+                    if (kept.length > 0)
+                        await nextSession.appendMessages(kept);
+                    // Switch the active session.
+                    const prevSession = session;
+                    session = nextSession;
+                    await prevSession.delete().catch(() => undefined);
+                    appendStatic([...formatInfoLine(`rewound ${n} message${n === 1 ? '' : 's'} (session ${session.id}), files unchanged`), '']);
+                    return;
+                }
                 case 'sessions': {
                     const sessions = await sdk.sessions.list();
                     appendStatic([
@@ -1444,6 +2522,229 @@ export async function runActoviqTui(options = {}) {
                     }
                     return;
                 }
+                case 'context': {
+                    // Break down what is consuming the context window (gap #9 vs
+                    // claude-code's /context) — usage, messages, system prompt, tools,
+                    // the loaded CLAUDE.md sources, and the active config.
+                    const window = sdk.config.compact?.contextWindowTokens ?? 200_000;
+                    const used = lastTokenEstimate ?? 0;
+                    const pct = window > 0 ? Math.min(100, Math.round((used / window) * 100)) : 0;
+                    const usedK = used >= 1000 ? `${(used / 1000).toFixed(1)}k` : `${used}`;
+                    const windowK = window >= 1000 ? `${(window / 1000).toFixed(0)}k` : `${window}`;
+                    const ctxColor = pct >= 90 ? A.red : pct >= 70 ? A.yellow : A.dim;
+                    const messages = session.messages.length;
+                    const sysChars = systemPrompt.length;
+                    const mcpCount = toolMetadata.filter(t => t.provider === 'mcp').length;
+                    const project = loadProjectContext(sdk.config.workDir);
+                    const team = activeTeamName ?? 'none';
+                    const router = activeRouter ? activeRouter.name : 'off';
+                    const bridge = bridgeMode && activeBridgeConfig ? activeBridgeConfig.name : 'off';
+                    appendStatic([
+                        `${A.bold}Context window${A.reset}`,
+                        `  ${ctxColor}${pct}% used (${usedK} / ${windowK} tokens)${A.reset}`,
+                        `  ${A.dim}messages${A.reset}        ${messages}`,
+                        `  ${A.dim}system prompt${A.reset}   ~${sysChars} chars`,
+                        `  ${A.dim}tools${A.reset}           ${toolMetadata.length}${mcpCount > 0 ? ` (${mcpCount} MCP)` : ''}`,
+                        `  ${A.dim}CLAUDE.md${A.reset}       ${project.sources.length ? project.sources.join(', ') : '(none loaded)'}`,
+                        `  ${A.dim}active${A.reset}         model=${session.model} · effort=${currentEffort() ?? 'auto'} · team=${team} · router=${router} · bridge=${bridge}`,
+                        '',
+                    ]);
+                    return;
+                }
+                case 'cost':
+                case 'usage': {
+                    // Running token + spend totals for the session (gap #20).
+                    const fmtTok = (n) => n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`;
+                    const costStr = totalCostUsd === null
+                        ? `${A.dim}(unknown — model lacks pricing; set ~/.actoviq/pricing.json)${A.reset}`
+                        : `$${totalCostUsd.toFixed(4)}`;
+                    const lines = [
+                        `${A.bold}Session usage${A.reset}`,
+                        `  ${A.dim}tokens${A.reset}   ${fmtTok(totalInputTokens)} in · ${fmtTok(totalOutputTokens)} out`,
+                        `  ${A.dim}cost${A.reset}     ${costStr}`,
+                        `  ${A.dim}model${A.reset}    ${session.model}`,
+                    ];
+                    // Per-config breakdown panel.
+                    if (configUsage.size > 0) {
+                        lines.push('');
+                        lines.push(`${A.bold}By config${A.reset}`);
+                        for (const [name, rec] of configUsage) {
+                            const active = activeBridgeConfig?.name === name;
+                            const star = active ? ` ${A.green}*${A.reset}` : '';
+                            const cfgCost = configCost(name, rec);
+                            lines.push(`  ${A.bold}${name}${star}${A.reset}  ${A.dim}${rec.turns} turn${rec.turns === 1 ? '' : 's'}${A.reset}  ${fmtTok(rec.inputTokens)} in · ${fmtTok(rec.outputTokens)} out${cfgCost ? `  ${cfgCost}` : ''}`);
+                        }
+                    }
+                    lines.push('');
+                    appendStatic(lines);
+                    return;
+                }
+                case 'doctor': {
+                    // Configuration diagnostics (gap #21, partial). Checks the things a
+                    // user would actually need to fix to get a run working.
+                    const cfg = sdk.config;
+                    const ok = (b) => b ? `${A.green}✓${A.reset}` : `${A.red}✗${A.reset}`;
+                    const lines = [`${A.bold}Actoviq diagnostics${A.reset}`];
+                    // Model + provider
+                    lines.push(`  ${ok(Boolean(cfg.model))} model ${A.dim}${cfg.model || '(unset)'}${A.reset}`);
+                    lines.push(`  ${ok(Boolean(cfg.provider))} provider ${A.dim}${cfg.provider || '(unset)'}${A.reset}`);
+                    // API key (env or settings)
+                    const apiKey = cfg.apiKey ?? process.env.ACTOVIQ_API_KEY ?? process.env.ANTHROPIC_API_KEY ?? process.env.OPENAI_API_KEY;
+                    lines.push(`  ${ok(Boolean(apiKey))} api key ${A.dim}${apiKey ? 'set (' + maskKey(apiKey) + ')' : '(not set — set ACTOVIQ_API_KEY or configure via /model config)'}${A.reset}`);
+                    if (cfg.baseURL)
+                        lines.push(`  ${A.dim}base url${A.reset} ${cfg.baseURL}`);
+                    // Workspace + git
+                    let isGit = false;
+                    try {
+                        execSync('git rev-parse --is-inside-work-tree', { cwd: cfg.workDir, stdio: 'ignore' });
+                        isGit = true;
+                    }
+                    catch { /* not git */ }
+                    lines.push(`  ${ok(true)} workdir ${A.dim}${cfg.workDir}${A.reset}`);
+                    lines.push(`  ${ok(isGit)} git repo ${A.dim}${isGit ? 'yes' : 'no'}${A.reset}`);
+                    // Session + permissions
+                    lines.push(`  ${ok(true)} session ${A.dim}${session.id}${A.reset} · ${session.messages.length} messages`);
+                    lines.push(`  ${ok(true)} permission mode ${A.dim}${currentPermissionMode()}${A.reset}`);
+                    lines.push(`  ${ok(toolMetadata.length > 0)} tools ${A.dim}${toolMetadata.length}${A.reset}`);
+                    // Context memory
+                    const project = loadProjectContext(cfg.workDir);
+                    lines.push(`  ${ok(project.sources.length > 0)} CLAUDE.md ${A.dim}${project.sources.length ? project.sources.join(', ') : '(none)'}${A.reset}`);
+                    // Bridge runtimes
+                    const detections = await withSpinner('detecting runtimes', detectBridgeProviders);
+                    const avail = detections.filter(d => d.available);
+                    lines.push(`  ${ok(avail.length > 0)} bridge runtimes ${A.dim}${avail.length ? avail.map(d => d.id).join(', ') : '(none on PATH)'}${A.reset}`);
+                    if (bridgeMode && activeBridgeConfig) {
+                        lines.push(`  ${A.dim}active bridge${A.reset} ${activeBridgeConfig.name}${bridgeModelLabel ? ` · ${bridgeModelLabel}` : ''}`);
+                    }
+                    lines.push('');
+                    appendStatic(lines);
+                    return;
+                }
+                case 'batch': {
+                    const file = args.trim();
+                    if (!file) {
+                        appendStatic([...formatErrorLine('usage: /batch <file> — runs each line as a separate turn'), '']);
+                        return;
+                    }
+                    let prompts;
+                    try {
+                        const content = fs.readFileSync(path.resolve(workDir, file), 'utf-8');
+                        prompts = content.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+                    }
+                    catch (error) {
+                        appendStatic([...formatErrorLine(`cannot read batch file: ${error.message}`), '']);
+                        return;
+                    }
+                    if (!prompts.length) {
+                        appendStatic([...formatInfoLine('batch file is empty'), '']);
+                        return;
+                    }
+                    appendStatic([...formatInfoLine(`batch: ${prompts.length} prompt${prompts.length === 1 ? '' : 's'} from ${file}`), '']);
+                    for (let i = 0; i < prompts.length; i++) {
+                        appendStatic([`${A.dim}[${i + 1}/${prompts.length}]${A.reset} ${A.bold}>${A.reset} ${truncateToWidth(prompts[i], 60)}`, '']);
+                        await startRun(prompts[i]);
+                    }
+                    appendStatic([...formatInfoLine(`batch complete — ${prompts.length} prompt${prompts.length === 1 ? '' : 's'} done`), '']);
+                    return;
+                }
+                case 'goal': {
+                    const arg = args.trim();
+                    if (!arg) {
+                        const g = getGoal();
+                        if (!g) {
+                            appendStatic([...formatInfoLine('no goal set — use /goal <objective> to set one'), '']);
+                        }
+                        else {
+                            const marks = { active: `${A.green}▶ active${A.reset}`, paused: `${A.yellow}‖ paused${A.reset}`, complete: `${A.dim}✓ complete${A.reset}` };
+                            appendStatic([`${A.bold}Goal${A.reset}  ${marks[g.status]}  ${A.dim}${g.setAt.slice(0, 10)}${A.reset}`, `  ${g.objective}`, '']);
+                        }
+                        return;
+                    }
+                    if (arg === 'clear') {
+                        await clearGoal();
+                        appendStatic([...formatInfoLine('goal cleared'), '']);
+                        return;
+                    }
+                    if (arg === 'pause') {
+                        const g = getGoal();
+                        if (g && g.status === 'active') {
+                            await session.mergeMetadata({ [GOAL_METADATA_KEY]: { ...g, status: 'paused' } });
+                            appendStatic([...formatInfoLine('goal paused'), '']);
+                        }
+                        else {
+                            appendStatic([...formatInfoLine('no active goal to pause'), '']);
+                        }
+                        return;
+                    }
+                    if (arg === 'resume') {
+                        const g = getGoal();
+                        if (g && g.status === 'paused') {
+                            await session.mergeMetadata({ [GOAL_METADATA_KEY]: { ...g, status: 'active' } });
+                            appendStatic([...formatInfoLine('goal resumed'), '']);
+                        }
+                        else {
+                            appendStatic([...formatInfoLine('no paused goal to resume'), '']);
+                        }
+                        return;
+                    }
+                    if (arg === 'complete' || arg === 'done') {
+                        const g = getGoal();
+                        if (g) {
+                            await session.mergeMetadata({ [GOAL_METADATA_KEY]: { ...g, status: 'complete' } });
+                            appendStatic([...formatInfoLine('goal marked complete'), '']);
+                        }
+                        return;
+                    }
+                    await setGoal(arg);
+                    appendStatic([...formatInfoLine(`goal set — ${arg}`), '']);
+                    return;
+                }
+                case 'review': {
+                    // Run a code-review prompt on the current git diff (gap #5 subset).
+                    let diff = '';
+                    try {
+                        diff = execSync('git diff', { cwd: workDir, encoding: 'utf8', maxBuffer: 1024 * 1024, timeout: 15_000 }).trim();
+                    }
+                    catch { /* no diff available */ }
+                    if (!diff) {
+                        appendStatic([...formatInfoLine('no uncommitted changes to review — working tree is clean'), '']);
+                        return;
+                    }
+                    await startRun('Review this code change for correctness bugs, security issues, and simplification opportunities. ' +
+                        'File-by-file, note any real problems with file_path:line_number. Skip trivial style nits.\n\n```diff\n' +
+                        diff.slice(0, 80_000) + '\n```');
+                    return;
+                }
+                case 'stats': {
+                    const now = Date.now();
+                    const uptime = Math.max(0, Math.round((now - (runStartedAt || now)) / 1000));
+                    const fmtTok = (n) => n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`;
+                    appendStatic([
+                        `${A.bold}Session stats${A.reset}`,
+                        `  ${A.dim}messages${A.reset}     ${session.messages.length}`,
+                        `  ${A.dim}tokens${A.reset}       ${fmtTok(totalInputTokens)} in · ${fmtTok(totalOutputTokens)} out`,
+                        `  ${A.dim}tools${A.reset}        ${toolMetadata.length}${toolMetadata.filter(t => t.provider === 'mcp').length ? ` (${toolMetadata.filter(t => t.provider === 'mcp').length} MCP)` : ''}`,
+                        `  ${A.dim}model${A.reset}       ${session.model}${bridgeMode && activeBridgeConfig ? ` · bridge:${activeBridgeConfig.name}` : ''}`,
+                        `  ${A.dim}output style${A.reset} ${outputStyle}`,
+                        `  ${A.dim}plan mode${A.reset}   ${session.permissionContext.mode === 'plan' ? 'on' : 'off'}`,
+                        '',
+                    ]);
+                    return;
+                }
+                case 'export': {
+                    const file = args.trim() || `session-${new Date().toISOString().replace(/[:.]/g, '-')}.md`;
+                    const md = session.messages
+                        .map((m) => `## ${m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : m.role}\n\n${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
+                        .join('\n\n---\n\n');
+                    try {
+                        fs.writeFileSync(path.resolve(workDir, file), md, 'utf-8');
+                        appendStatic([...formatInfoLine(`conversation exported to ${file}`), '']);
+                    }
+                    catch (error) {
+                        appendStatic([...formatErrorLine(`export failed: ${error.message}`), '']);
+                    }
+                    return;
+                }
                 case 'compact': {
                     try {
                         const summaryInstructions = args || undefined;
@@ -1486,6 +2787,43 @@ export async function runActoviqTui(options = {}) {
                 case 'mcp':
                     await showMcp();
                     return;
+                case 'hooks': {
+                    // List configured hooks from settings.json (gap #2). Hooks are read
+                    // live from the hooks.PreToolUse[], hooks.PostToolUse[], and
+                    // hooks.SessionStart[] blocks.
+                    const preHooks = readPreToolUseHooks(getLoadedJsonConfig()?.raw);
+                    const postHooks = readPostToolUseHooks(getLoadedJsonConfig()?.raw);
+                    const startHooks = readSessionStartHooks(getLoadedJsonConfig()?.raw);
+                    const total = preHooks.length + postHooks.length + startHooks.length;
+                    if (total === 0) {
+                        appendStatic([
+                            ...formatInfoLine('no hooks configured'),
+                            ...formatInfoLine('add to ~/.actoviq/settings.json: "{ hooks: { PreToolUse: [...], PostToolUse: [...], SessionStart: [...] } }"'),
+                            `  ${A.dim}PreToolUse:   { "matcher": "Bash", "command": "echo checking $ACTOVIQ_HOOK_TOOL" }${A.reset}`,
+                            `  ${A.dim}PostToolUse:  { "matcher": "*", "command": "notify-tool-complete" }  (fire-and-forget)${A.reset}`,
+                            `  ${A.dim}SessionStart: { "command": "echo session started" }  (fire-and-forget)${A.reset}`,
+                            '',
+                        ]);
+                    }
+                    else {
+                        const lines = [`${A.bold}Hooks${A.reset} ${A.dim}(${total})${A.reset}`];
+                        if (preHooks.length > 0) {
+                            lines.push(`${A.bold}  PreToolUse${A.reset} ${A.dim}(${preHooks.length}) — blocks tool on non-zero exit or "BLOCK" stdout${A.reset}`);
+                            preHooks.forEach((h, i) => lines.push(`    ${A.dim}${i + 1}.${A.reset} ${A.bold}${h.matcher}${A.reset} ${A.dim}→${A.reset} ${truncateToWidth(h.command, 50)}`));
+                        }
+                        if (postHooks.length > 0) {
+                            lines.push(`${A.bold}  PostToolUse${A.reset} ${A.dim}(${postHooks.length}) — fire-and-forget after tool completes${A.reset}`);
+                            postHooks.forEach((h, i) => lines.push(`    ${A.dim}${i + 1}.${A.reset} ${A.bold}${h.matcher}${A.reset} ${A.dim}→${A.reset} ${truncateToWidth(h.command, 50)}`));
+                        }
+                        if (startHooks.length > 0) {
+                            lines.push(`${A.bold}  SessionStart${A.reset} ${A.dim}(${startHooks.length}) — fire-and-forget on session init${A.reset}`);
+                            startHooks.forEach((h, i) => lines.push(`    ${A.dim}${i + 1}.${A.reset} ${A.dim}→${A.reset} ${truncateToWidth(h.command, 50)}`));
+                        }
+                        lines.push('');
+                        appendStatic(lines);
+                    }
+                    return;
+                }
                 case 'plugins':
                     await showPlugins();
                     return;
@@ -1625,6 +2963,49 @@ export async function runActoviqTui(options = {}) {
                     appendStatic([...formatInfoLine('usage: /worktree [enter <name>|exit|list]'), '']);
                     return;
                 }
+                case 'bridge': {
+                    if (args === 'run' || args.startsWith('run ')) {
+                        const bp = args.startsWith('run ') ? args.slice(4).trim() : '';
+                        if (!bp) {
+                            appendStatic([...formatErrorLine('usage: /bridge run <prompt>'), '']);
+                            return;
+                        }
+                        await runBridgePrompt(bp);
+                        return;
+                    }
+                    if (args === 'switch' || args.startsWith('switch ')) {
+                        const target = args.startsWith('switch ') ? args.slice(7).trim() : '';
+                        await switchBridgeProvider(target);
+                        return;
+                    }
+                    if (args === 'setup') {
+                        await configureBridgeSettings();
+                        return;
+                    }
+                    if (args === 'config') {
+                        await manageBridgeConfigs();
+                        return;
+                    }
+                    if (args === 'off') {
+                        await disableBridge();
+                        return;
+                    }
+                    if (args === 'model' || args.startsWith('model ')) {
+                        const modelId = args.startsWith('model ') ? args.slice(6).trim() : '';
+                        await selectBridgeModel(modelId);
+                        return;
+                    }
+                    if (args === 'help') {
+                        printBridgeHelp();
+                        return;
+                    }
+                    if (!args) {
+                        await openBridgeBoard();
+                        return;
+                    }
+                    await configureBridgeSettings();
+                    return;
+                }
                 // ── v0.5.0: Model Team ───────────────────────────────────
                 case 'team': {
                     if (args.startsWith('ask ')) {
@@ -1772,13 +3153,13 @@ export async function runActoviqTui(options = {}) {
             return;
         const name = key.name ?? '';
         if (name === 'up') {
-            dialog.selected = (dialog.selected + 2) % 3;
+            dialog.selected = (dialog.selected + 3) % 4;
         }
         else if (name === 'down' || name === 'tab') {
-            dialog.selected = (dialog.selected + 1) % 3;
+            dialog.selected = (dialog.selected + 1) % 4;
         }
         else if (name === 'return' || name === 'enter') {
-            dialog.resolve(dialog.selected === 0 ? 'allow' : dialog.selected === 1 ? 'always' : 'deny');
+            dialog.resolve(dialog.selected === 0 ? 'allow' : dialog.selected === 1 ? 'always' : dialog.selected === 2 ? 'always-user' : 'deny');
             return;
         }
         else if (name === 'y') {
@@ -2121,6 +3502,7 @@ export async function runActoviqTui(options = {}) {
         catch {
             // best-effort close
         }
+        // Close any live bridge runtime clients (sessions were per-provider).
         process.exit(code);
     }
     screen.start();
@@ -2146,6 +3528,7 @@ export async function runActoviqTui(options = {}) {
         }
     });
     process.on('SIGTERM', () => void shutdown(0));
+    process.on('SIGINT', () => void shutdown(0));
     process.stdout.on('resize', () => renderDynamic());
     // Keep the process alive until shutdown() exits it.
     await new Promise(() => { });