@calliopelabs/cli 2.5.0 → 3.1.0

package/dist/ui/commands.js

@@ -1,101 +1,97 @@
 /**
  * UI Module - Command Handler
  *
- * Handles all slash commands (/help, /mode, /provider, etc.)
- * Extracted from TerminalChat using a CommandContext state bag.
+ * Handles the slash commands exposed by the TUI. The surface is intentionally
+ * small: see COMMAND_NAMES for the canonical list. Legacy/verbose commands have
+ * been folded into subcommands of the survivors (e.g. /models -> /model list,
+ * /add-dir -> /scope add, /set -> /config set, /breakloop -> /loop stop).
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as config from '../config.js';
 import { selectProvider, getAvailableProviders } from '../providers/index.js';
-import { getSystemPrompt, DEFAULT_MODELS, MODE_CONFIG } from '../types.js';
-import { getVersion, getLatestVersion } from '../version-check.js';
-import { getAvailableModels } from '../model-detection.js';
+import { MODE_CONFIG } from '../types.js';
+import { getSystemPromptForProvider } from '../local-model.js';
+import { getAvailableModels, getModelContextLimit } from '../model-detection.js';
 import * as storage from '../storage.js';
 import * as mcp from '../mcp.js';
 import * as skills from '../skills.js';
-import * as modelRouter from '../model-router.js';
 import * as summarization from '../summarization.js';
 import { addToScope, removeFromScope, getScopeSummary, getScopeDetails, resetScope } from '../scope.js';
-import { getAgentStatusReport, swarmManager, councilManager, COUNCIL_TEMPLATES, getInstallReport, installItem, installAllMissing, listAgentDefs, listTeamDefs, getAgent, getTeam, scaffoldAgentsDir, saveAgentDef, getAvailableExecutors } from '../agents/index.js';
-import { smartRoute, getDefaultSmartRoutingConfig, detectTaskType } from '../smart-router.js';
-import { getCurrentSkin, getCurrentPalette, applySkin, applyPalette, listSkins, listPalettes } from '../hud/api.js';
-import { getCurrentCompanion, applyCompanion, listCompanions, getMoodText } from '../companions.js';
-import { scuttlebotClient } from '../scuttlebot/index.js';
-import { createJob, runJob, cancelJob, getJob, formatJob, formatJobsList, clearFinishedJobs } from '../background-jobs.js';
-import { listRecordings, loadRecording, formatRecording, deleteRecording } from '../terminal-recording.js';
-import { startApiServer, stopApiServer, isApiServerRunning } from '../api-server.js';
-import { getTerminalImageInfo, getImageModeLabel, renderSkinBanner, renderTransition } from '../terminal-image.js';
-import { applyThemePack, listThemePacks, getCurrentPack, getCompanionMode, setCompanionMode, getThemePack } from '../hud/theme-packs/api.js';
-import { getModelContextLimit } from '../model-detection.js';
+import { fleetConfigured, fleetActive, fleetStatus, fleetEnable, fleetDisable, fleetPostMessage } from '../fleet.js';
+import { getTerminalImageInfo, getImageModeLabel } from '../terminal-image.js';
 import { resetContextWarnings } from './context.js';
 import * as memory from '../memory.js';
+import { getBudgetCaps, hasBudgetCaps, loadProjectSpend } from '../budget.js';
 import { resolveIterationLimit, formatIterationLimit, isFiniteIterationLimit, } from '../iteration-limit.js';
+// ============================================================================
+// Command registry
+// ============================================================================
+/**
+ * Canonical list of every slash-command label handled by the switch in
+ * handleCommand(). Tests assert this stays in lockstep with the switch and a
+ * superset of the completion roots. `/quit` is the sole alias (of `/exit`);
+ * `/fleet` is flag-gated in completions but always handled here.
+ */
+export const COMMAND_NAMES = [
+    '/help',
+    '/status',
+    '/clear',
+    '/exit',
+    '/quit',
+    '/model',
+    '/provider',
+    '/mode',
+    '/undo',
+    '/export',
+    '/resume',
+    '/compact',
+    '/scope',
+    '/memory',
+    '/mcp',
+    '/skills',
+    '/config',
+    '/setup',
+    '/trust',
+    '/cost',
+    '/loop',
+    '/restore',
+    '/debug',
+    '/fleet',
+];
 // Builds the full system prompt including memory context (project + global).
-// dir should be the project directory for the active/resumed session.
-function buildFullSystemPrompt(persona, dir) {
-    const base = getSystemPrompt(persona);
+// dir should be the project directory for the active/resumed session; provider
+// selects the compact (local) vs full (cloud) base prompt (feature 5).
+function buildFullSystemPrompt(dir, provider) {
+    const base = getSystemPromptForProvider(provider);
     const mem = memory.buildMemoryContext(dir);
     return mem.trim() ? base + '\n\n--- Project Context ---\n' + mem : base;
 }
 function getActiveProjectDir(ctx) {
     return ctx.sessionRef.current?.projectPath ?? process.cwd();
 }
-function formatLedgerDuration(durationMs) {
-    if (durationMs < 1000)
-        return `${durationMs}ms`;
-    if (durationMs < 60_000)
-        return `${(durationMs / 1000).toFixed(1)}s`;
-    return `${(durationMs / 60_000).toFixed(1)}m`;
-}
 function formatSessionLogLimit(limit) {
     return limit > 0 ? String(limit) : 'unlimited';
 }
-function formatLedgerRun(run) {
-    const iterationCount = Math.max(0, (run.entryCountAtEnd ?? run.entryCountAtStart) - run.entryCountAtStart);
-    const parts = [`${run.kind}`, `[${run.status}]`];
-    if (iterationCount > 0) {
-        parts.push(`${iterationCount} iteration${iterationCount === 1 ? '' : 's'}`);
-    }
-    if (run.maxIterations != null && Number.isFinite(run.maxIterations)) {
-        parts.push(`max ${run.maxIterations}`);
-    }
-    else if (run.maxIterations === null) {
-        parts.push('unlimited');
+/**
+ * Apply a `budget.*` config key. `off`/`none`/empty clears the cap. Throws on an
+ * invalid number so the caller's try/catch surfaces the message.
+ */
+function applyBudgetKey(field, value) {
+    const budget = { ...(config.get('budget') ?? {}) };
+    if (value === 'off' || value === 'none' || value === '') {
+        delete budget[field];
+        config.set('budget', budget);
+        return `✓ ${field} cleared`;
     }
-    const prompt = run.prompt.length > 90 ? `${run.prompt.slice(0, 90)}...` : run.prompt;
-    let line = `${parts.join(' ')} — ${prompt}`;
-    if (run.errorSummary) {
-        line += ` (${run.errorSummary})`;
+    const num = Number(value);
+    if (isNaN(num) || num < 0) {
+        throw new Error(`${field} must be a non-negative number (or 'off' to clear)`);
     }
-    return line;
-}
-function watchAsyncLedgerRun(ledger, kind, prompt, getStatus) {
-    if (!ledger)
-        return;
-    const runId = ledger.startRun(kind, prompt);
-    void (async () => {
-        for (;;) {
-            const current = getStatus();
-            if (!current) {
-                ledger.finishRun(runId, 'failed', { errorSummary: 'Run state no longer available' });
-                return;
-            }
-            if (current.status === 'completed') {
-                ledger.finishRun(runId, 'completed');
-                return;
-            }
-            if (current.status === 'failed') {
-                ledger.finishRun(runId, 'failed', { errorSummary: current.error });
-                return;
-            }
-            if (current.status === 'cancelled') {
-                ledger.finishRun(runId, 'cancelled', { errorSummary: current.error || 'Cancelled' });
-                return;
-            }
-            await new Promise(resolve => setTimeout(resolve, 500));
-        }
-    })();
+    budget[field] = field === 'maxTokensPerRun' ? Math.floor(num) : num;
+    config.set('budget', budget);
+    const unit = field === 'maxTokensPerRun' ? ' tokens' : ' USD';
+    return `✓ ${field} set to ${budget[field]}${unit}`;
 }
 // ============================================================================
 // handleCommand
@@ -104,97 +100,54 @@ export async function handleCommand(cmd, ctx) {
     const parts = cmd.split(/\s+/);
     const command = parts[0].toLowerCase();
     switch (command) {
-        case '/help':
-        case '/h':
-            ctx.addMessage('system', `--- Model & Routing ---
-  /provider [name]           - Switch AI provider (/p)
-  /model [name]              - Switch model (/m)
-  /models                    - List available models
-  /mode [plan|hybrid|work]   - Switch modes (Shift+Tab to cycle)
-  /persona [name]            - Switch personality
-  /route [on|off]            - Auto model routing (/autoroute)
-  /smart [on|off|cost|test]  - Cross-provider smart routing
-  /breaker [status|adjust]   - Circuit breaker control (/cb)
-
---- Conversation ---
-  /edit                      - Edit and resend last message
-  /undo / /redo              - Undo/redo (up to 10 steps)
-  /copy                      - Copy last response to clipboard
-  /export [file.md]          - Export conversation to markdown
-  /branch [new|switch]       - Conversation branches
-  /clear                     - Clear conversation (/c)
+        case '/help': {
+            let help = `Session
+  /help                       Show this help
+  /status                     Provider, model, tokens, terminal, fleet
+  /clear                      Clear the conversation
+  /exit                       Exit Calliope (alias /quit)
 
---- Session & State ---
-  /session [list|info|fork|save] - Session management (/sessions)
-  /log [summary|tail|failures|reset] - Iteration/run log
-  /resume [sessionId]        - Resume session (restores full context)
-  /checkpoint [list|clear]   - File checkpoints (/cp)
-  /restore <path> [index]    - Restore file from checkpoint
-  /bookmark [name|list|goto] - Bookmarks (/bm)
-  /queue [show|clear|flush]  - Message queue (/q)
+Model & Mode
+  /model [name|list]          Switch model, or list/pick available models
+  /provider [name|list]       Switch provider, or list providers
+  /mode [plan|hybrid|work]    Switch mode (Shift+Tab to cycle)
 
---- Context & Scope ---
-  /scope [details|reset]     - File access scope (/dirs)
-  /add-dir / /remove-dir     - Manage scope directories
-  /context [load|summary]    - Context management
-  /summarize                 - Compact context to save tokens
-  /trust [add|remove|list]   - Project trust registry
-  /find <pattern>            - Fuzzy file search
-  /search <query>            - Search conversation
+Conversation
+  /undo                       Undo the last change (up to 10 steps)
+  /export [file.md]           Export conversation to markdown
+  /resume [sessionId]         Resume a saved session (restores full context)
+  /compact [status]           Compress conversation context; status shows a summary
 
---- Tasks & Planning ---
-  /todo [add|done|list]      - Manage TODOs
-  /plans [list|view]         - View plan history
-  /template [save|use|del]   - Prompt templates (/t)
-  /plan / /work              - Quick mode switch
-  /approve [notes]           - Approve pending plan & execute
+Workspace
+  /scope [add|remove <dir>]   File-access scope (also details|reset)
+  /memory [init|add|show]     Project memory (CALLIOPE.md)
+  /trust [add|remove|list]    Project trust registry
+  /restore [<path> [index]]   List checkpoints, or restore a file
 
---- Appearance ---
-  /skin [name]               - Switch HUD skin (${(await import('../hud/api.js')).listSkins().length}+ available)
-  /palette [name]            - Switch color palette
-  /companion [name]          - Switch companion personality
-  /pack [name]               - Apply theme pack (skin+palette+companion)
-  /theme [name]              - Color themes
-  /layout [name]             - UI layout (classic/split/etc)
-  /density [normal|compact]  - Display density
-  /collapse [tools|all|off]  - Tool output visibility
-  /intensity [1-5]           - Immersion level
-  /emoji [on|off]            - Toggle emoji
-  /banner                    - Show skin banner art
+Extend
+  /mcp [add|remove|tools]     MCP servers
+  /skills [add|remove]        Agent skills
 
---- Tools & Integration ---
-  /mcp [add|remove|tools]    - MCP servers
-  /skills [add|remove]       - Agent skills
-  /memory [init|add|show]    - Project memory (CALLIOPE.md)
-  /project [init|show|run]   - Project config (.calliope)
-  /hooks [list|add]          - Pre/post tool hooks
-  /profile [name|save|del]   - Switch/save/delete profiles
+System
+  /config [set <key> <value>] Show or change settings (maxIterations, sessionLogLimit, diffStyle, theme)
+  /setup                      Reconfigure Calliope
+  /cost                       Cost tracking summary
+  /loop ["prompt"|stop]       Iterative agent loop
+  /debug [on|off]             Debug state/logging`;
+            if (fleetConfigured()) {
+                help += `
 
---- Multi-Agent ---
-  /agents                    - Sub-agent status (--agents mode)
-  /swarm [start|coord|status] - Agent swarms & coordination
-  /loop [prompt]             - Iterative agent loop (default: unlimited)
-  /cancel-loop               - Stop running loop (/stop, /breakloop)
-
---- System ---
-  /status                    - Show status (/s)
-  /config                    - Show config
-  /set <key> <value>         - Set config variable
-  /cost                      - Cost tracking summary
-  /confirm [on|off]          - Toggle risky op confirmation
-  /debug [on|off]            - Debug state/logging
-  /unstick                   - Emergency reset
-  /upgrade                   - Check for updates
-  /keys or /?                - Keyboard shortcuts
-  /exit                      - Exit (/quit)
+Fleet
+  /fleet [message|disable]    Multi-agent fleet coordination`;
+            }
+            help += `
 
-File references: @filename, ./path, /absolute/path
-Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.agtermEnabled ? '\nAgents: ON' : ''}`);
+File references: @filename, ./path, /absolute/path`;
+            ctx.addMessage('system', help);
             break;
+        }
         case '/provider':
-        case '/providers':
-        case '/p':
-            if (parts[1]) {
+            if (parts[1] && parts[1] !== 'list') {
                 const requested = parts[1].toLowerCase();
                 const available = getAvailableProviders();
                 if (!available.includes(requested)) {
@@ -202,7 +155,14 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
                     break;
                 }
                 ctx.setProvider(requested);
-                ctx.addMessage('system', `Provider: ${selectProvider(requested)}`);
+                // Explicit switches persist as the new defaults; a stale model from
+                // the previous provider must not leak into this one (#233).
+                config.set('defaultProvider', requested);
+                config.unset('defaultModel');
+                ctx.addMessage('system', `Provider: ${selectProvider(requested)} (saved as default)`);
+            }
+            else if (parts[1] === 'list') {
+                ctx.addMessage('system', `Provider: ${ctx.actualProvider} | Available: ${getAvailableProviders().join(', ')}`);
             }
             else if (ctx.openProviderPicker) {
                 ctx.openProviderPicker();
@@ -212,8 +172,7 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
             }
             break;
         case '/model':
-        case '/m':
-            if (parts[1]) {
+            if (parts[1] && parts[1] !== 'list') {
                 const newModel = parts[1];
                 const oldModel = ctx.model || ctx.actualModel;
                 // Check context compatibility before switching (#26)
@@ -222,17 +181,19 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
                 const currentTokens = ctx.estimateContextTokens();
                 const newPct = Math.round((currentTokens / newLimit) * 100);
                 ctx.setModel(newModel);
+                config.set('defaultModel', newModel);
                 ctx.setContextTokens(currentTokens);
                 let switchWarning = '';
                 if (newPct > 80) {
-                    switchWarning = `\n⚠️  Context at ${newPct}% of new model limit (${Math.round(currentTokens / 1000)}K/${Math.round(newLimit / 1000)}K). Consider /summarize compact.`;
+                    switchWarning = `\n⚠️  Context at ${newPct}% of new model limit (${Math.round(currentTokens / 1000)}K/${Math.round(newLimit / 1000)}K). Consider /compact.`;
                 }
                 else if (newLimit < oldLimit) {
                     switchWarning = `\n📉 Context window: ${Math.round(oldLimit / 1000)}K → ${Math.round(newLimit / 1000)}K (${newPct}% used)`;
                 }
-                ctx.addMessage('system', `Model: ${oldModel} → ${newModel}${switchWarning}`);
+                ctx.addMessage('system', `Model: ${oldModel} → ${newModel} (saved as default)${switchWarning}`);
             }
             else {
+                // No arg or `list`: open the model picker (absorbs the old /models listing)
                 ctx.addMessage('system', `Fetching models for ${ctx.actualProvider}...`);
                 try {
                     const models = await getAvailableModels(ctx.actualProvider, { throwOnError: true });
@@ -249,22 +210,6 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
                 }
             }
             break;
-        case '/models':
-            ctx.addMessage('system', `Fetching models for ${ctx.actualProvider}...`);
-            try {
-                const models = await getAvailableModels(ctx.actualProvider, { throwOnError: true });
-                if (models.length > 0) {
-                    ctx.setAvailableModels(models);
-                    ctx.setModalMode('model');
-                }
-                else {
-                    ctx.addMessage('error', `No models found for ${ctx.actualProvider} — API key may be invalid`);
-                }
-            }
-            catch (e) {
-                ctx.addMessage('error', `Failed to fetch models for ${ctx.actualProvider}: ${e instanceof Error ? e.message : String(e)}. Check your API key.`);
-            }
-            break;
         case '/mode':
             if (parts[1] && ['plan', 'hybrid', 'work'].includes(parts[1])) {
                 const m = parts[1];
@@ -276,64 +221,13 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
                 ctx.addMessage('system', `Mode: ${currentConfig.icon} ${currentConfig.label}\nOptions: plan (\u{1F4CB}), hybrid (\u{1F504}), work (\u{1F527})\nUse Shift+Tab to cycle`);
             }
             break;
-        case '/persona':
-            if (parts[1] && ['calliope', 'muse', 'minimal'].includes(parts[1])) {
-                const p = parts[1];
-                ctx.setPersona(p);
-                ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(p, getActiveProjectDir(ctx)) }];
-                ctx.addMessage('system', `Persona: ${p}`);
-            }
-            else {
-                ctx.addMessage('system', `Persona: ${ctx.persona} | Options: calliope, muse, minimal`);
-            }
-            break;
         case '/clear':
-        case '/c':
             ctx.setMessages([]);
-            ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
+            ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(getActiveProjectDir(ctx), ctx.actualProvider) }];
             ctx.ledger?.reset();
             ctx.setStats({ inputTokens: 0, outputTokens: 0, cost: 0, messageCount: 0 });
             resetContextWarnings(); // Reset context warning state
             break;
-        case '/copy': {
-            // Copy last assistant response to clipboard
-            const lastAssistant = [...ctx.messages].reverse().find(m => m.type === 'assistant');
-            if (lastAssistant) {
-                try {
-                    const { execSync } = await import('child_process');
-                    // Try different clipboard commands based on platform
-                    const content = lastAssistant.content;
-                    if (process.platform === 'darwin') {
-                        execSync('pbcopy', { input: content });
-                    }
-                    else if (process.platform === 'win32') {
-                        execSync('clip', { input: content });
-                    }
-                    else {
-                        // Linux - try xclip, xsel, or wl-copy
-                        try {
-                            execSync('xclip -selection clipboard', { input: content });
-                        }
-                        catch {
-                            try {
-                                execSync('xsel --clipboard --input', { input: content });
-                            }
-                            catch {
-                                execSync('wl-copy', { input: content });
-                            }
-                        }
-                    }
-                    ctx.addMessage('system', '\u2713 Copied to clipboard');
-                }
-                catch (e) {
-                    ctx.addMessage('error', `Clipboard not available: ${e instanceof Error ? e.message : String(e)}`);
-                }
-            }
-            else {
-                ctx.addMessage('system', 'No assistant message to copy');
-            }
-            break;
-        }
         case '/export': {
             // Export conversation to markdown
             const filename = parts[1] || `calliope-export-${Date.now()}.md`;
@@ -362,20 +256,7 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
             }
             const filepath = path.resolve(process.cwd(), filename);
             fsModule.writeFileSync(filepath, markdown);
-            ctx.addMessage('system', `\u2713 Exported to ${filename}`);
-            break;
-        }
-        case '/edit': {
-            // Edit last user message
-            const lastUserIdx = [...ctx.messages].reverse().findIndex(m => m.type === 'user');
-            if (lastUserIdx >= 0) {
-                const lastUser = ctx.messages[ctx.messages.length - 1 - lastUserIdx];
-                ctx.setInput(lastUser.content);
-                ctx.addMessage('system', 'Edit the message above and press Enter to resend');
-            }
-            else {
-                ctx.addMessage('system', 'No user message to edit');
-            }
+            ctx.addMessage('system', `✓ Exported to ${filename}`);
             break;
         }
         case '/undo': {
@@ -394,735 +275,251 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
             ctx.setMessages(prevState.messages);
             ctx.llmMessages.current = prevState.llmMessages;
             ctx.setContextTokens(ctx.estimateContextTokens());
-            ctx.addMessage('system', `\u2713 Undone (${ctx.undoStack.current.length} more available)`);
-            break;
-        }
-        case '/redo': {
-            if (ctx.redoStack.current.length === 0) {
-                ctx.addMessage('system', 'Nothing to redo.');
-                break;
-            }
-            // Save current state to undo stack
-            ctx.undoStack.current.push({
-                messages: [...ctx.messages],
-                llmMessages: [...ctx.llmMessages.current],
-                timestamp: new Date(),
-            });
-            // Restore redo state
-            const redoState = ctx.redoStack.current.pop();
-            ctx.setMessages(redoState.messages);
-            ctx.llmMessages.current = redoState.llmMessages;
-            ctx.setContextTokens(ctx.estimateContextTokens());
-            ctx.addMessage('system', `\u2713 Redone (${ctx.redoStack.current.length} more available)`);
+            ctx.addMessage('system', `✓ Undone (${ctx.undoStack.current.length} more available)`);
             break;
         }
-        case '/status':
-        case '/s': {
+        case '/status': {
             const imgInfo = getTerminalImageInfo();
             let statusMsg = `${ctx.actualProvider}:${ctx.actualModel} | ${ctx.stats.messageCount} msgs | ${ctx.stats.inputTokens + ctx.stats.outputTokens} tokens | terminal: ${getImageModeLabel(imgInfo.mode)}${imgInfo.truecolor ? ' (truecolor)' : ''} ${imgInfo.width}cols`;
-            // Add scuttlebot status if enabled
-            if (scuttlebotClient.isEnabled()) {
-                const sbStatus = scuttlebotClient.getStatus();
-                statusMsg += `\nScuttlebot: enabled (${sbStatus.nick}) | irc:${sbStatus.config?.ircAddr} | #${sbStatus.config?.channel}`;
+            // Add fleet status if active
+            const fleetSt = fleetStatus();
+            if (fleetSt) {
+                statusMsg += `\nFleet: active (${fleetSt.nick}) | irc:${fleetSt.config?.ircAddr} | #${fleetSt.config?.channel}`;
+            }
+            // Show budget state when any cap is configured.
+            const caps = getBudgetCaps();
+            if (hasBudgetCaps(caps)) {
+                const parts = [];
+                if (typeof caps.maxCostPerRun === 'number')
+                    parts.push(`run<=$${caps.maxCostPerRun}`);
+                if (typeof caps.maxTokensPerRun === 'number')
+                    parts.push(`run<=${caps.maxTokensPerRun}tok`);
+                if (typeof caps.maxCostPerProject === 'number') {
+                    const spent = loadProjectSpend(getActiveProjectDir(ctx)).spentUsd;
+                    parts.push(`project $${spent.toFixed(4)}/$${caps.maxCostPerProject}`);
+                }
+                statusMsg += `\nBudget: ${parts.join(' | ')}`;
             }
             ctx.addMessage('system', statusMsg);
             break;
         }
-        case '/scuttlebot': {
+        case '/fleet': {
             const subCmd = parts[1];
-            const sbStatus = scuttlebotClient.getStatus();
-            // /scuttlebot enable - enable mid-session
             if (subCmd === 'enable') {
-                if (sbStatus.enabled) {
-                    ctx.addMessage('system', 'Scuttlebot is already enabled.');
+                if (fleetActive()) {
+                    ctx.addMessage('system', 'Fleet mode is already active.');
                     break;
                 }
-                // Initialize scuttlebot — config is loaded from ~/.config/scuttlebot-relay.env,
-                // process.env, and .scuttlebot.yaml inside initialize()
                 const sessionId = ctx.sessionRef.current?.id || 'default';
                 const cwd = getActiveProjectDir(ctx);
-                scuttlebotClient.initialize(sessionId, cwd).then(async (enabled) => {
+                fleetEnable(sessionId, cwd).then((enabled) => {
                     if (enabled) {
-                        const status = scuttlebotClient.getStatus();
-                        let msg = '✓ Scuttlebot enabled!\n';
-                        msg += `  Nick:      ${status.nick}\n`;
-                        msg += `  IRC:       ${status.config?.ircAddr}\n`;
-                        msg += `  Channel:   #${status.config?.channel}`;
-                        if (status.config?.channels && status.config.channels.length > 1) {
-                            msg += `\n  Channels:  ${status.config.channels.map((c) => '#' + c).join(', ')}`;
-                        }
+                        const status = fleetStatus();
+                        let msg = '✓ Fleet mode enabled\n';
+                        msg += `  Nick:      ${status?.nick}\n`;
+                        msg += `  IRC:       ${status?.config?.ircAddr}\n`;
+                        msg += `  Channel:   #${status?.config?.channel}`;
                         ctx.addMessage('system', msg);
-                        // Post online status and start routing IRC instructions
-                        await scuttlebotClient.postOnline();
-                        ctx.startScuttlebotPolling();
+                        ctx.startFleetPolling();
                     }
                     else {
-                        ctx.addMessage('system', 'Failed to enable scuttlebot');
+                        ctx.addMessage('system', 'Failed to enable fleet mode — check relay config (~/.config/scuttlebot-relay.env, .scuttlebot.yaml).');
                     }
                 }).catch((err) => {
-                    ctx.addMessage('system', `Failed to enable scuttlebot: ${err instanceof Error ? err.message : String(err)}`);
+                    ctx.addMessage('system', `Failed to enable fleet mode: ${err instanceof Error ? err.message : String(err)}`);
                 });
                 break;
             }
-            // /scuttlebot disable - disable mid-session
             if (subCmd === 'disable') {
-                if (!sbStatus.enabled) {
-                    ctx.addMessage('system', 'Scuttlebot is not enabled.');
+                if (!fleetConfigured() && !fleetActive()) {
+                    ctx.addMessage('system', 'Fleet mode is not enabled.');
                     break;
                 }
-                scuttlebotClient.postOffline().then(() => {
-                    return scuttlebotClient.disconnect();
-                }).then(() => {
-                    ctx.addMessage('system', 'Scuttlebot disabled');
+                fleetDisable().then(() => {
+                    ctx.addMessage('system', 'Fleet mode disabled.');
                 }).catch((err) => {
-                    ctx.addMessage('system', `Error disabling scuttlebot: ${err instanceof Error ? err.message : String(err)}`);
+                    ctx.addMessage('system', `Error disabling fleet mode: ${err instanceof Error ? err.message : String(err)}`);
                 });
                 break;
             }
-            // Show status
-            if (!sbStatus.enabled) {
-                ctx.addMessage('system', 'Scuttlebot not enabled.\n\nRun: /scuttlebot enable\n\nConfig is loaded automatically from ~/.config/scuttlebot-relay.env\nChannel is read from .scuttlebot.yaml');
+            if (!fleetActive()) {
+                ctx.addMessage('system', 'Fleet mode is off.\n\nRun: /fleet enable\n\nRelay config is read from ~/.config/scuttlebot-relay.env and .scuttlebot.yaml.\nDocs: docs/fleet.md');
                 break;
             }
-            let statusText = 'Scuttlebot Status\n────────────────────────────────────────\n';
-            statusText += `Enabled:     yes\n`;
-            statusText += `Nick:        ${sbStatus.nick}\n`;
-            statusText += `IRC:         ${sbStatus.config?.ircAddr}\n`;
-            statusText += `Channel:     #${sbStatus.config?.channel}\n`;
-            statusText += `Connected:   ${sbStatus.connected ? 'yes' : 'no'}`;
-            if (sbStatus.config?.channels && sbStatus.config.channels.length > 1) {
-                statusText += `\nChannels:    ${sbStatus.config.channels.map((c) => '#' + c).join(', ')}`;
-            }
-            statusText += '\n\nCommands:\n  /scuttlebot <message>  Post a message\n  /scuttlebot disable    Disable integration';
-            ctx.addMessage('system', statusText);
-            // Allow manual message posting
-            if (subCmd && subCmd !== 'enable' && subCmd !== 'disable') {
+            if (subCmd) {
                 const message = parts.slice(1).join(' ');
-                scuttlebotClient.postMessage(message).then(() => {
-                    ctx.addMessage('system', 'Message posted to scuttlebot.');
-                }).catch((err) => {
-                    ctx.addMessage('system', `Failed to post message: ${err instanceof Error ? err.message : String(err)}`);
-                });
+                fleetPostMessage(message);
+                ctx.addMessage('system', 'Message posted to the fleet channel.');
+                break;
             }
+            const status = fleetStatus();
+            let statusText = 'Fleet Status\n────────────────────\n';
+            statusText += `Nick:        ${status?.nick}\n`;
+            statusText += `IRC:         ${status?.config?.ircAddr}\n`;
+            statusText += `Channel:     #${status?.config?.channel}\n`;
+            statusText += `Connected:   ${status?.connected ? 'yes' : 'no'}`;
+            statusText += '\n\nCommands:\n  /fleet <message>  Post to the fleet channel\n  /fleet disable    Disable fleet mode';
+            ctx.addMessage('system', statusText);
             break;
         }
-        case '/config':
-            ctx.addMessage('system', `Config: ${config.getConfigPath()}\nProviders: ${config.getConfiguredProviders().join(', ') || 'none'}\nmaxIterations: ${config.get('maxIterations')}\nsessionLogLimit: ${formatSessionLogLimit(config.get('sessionLogLimit'))} (set > 0 to cap)`);
-            break;
-        case '/agents': {
-            if (!ctx.agtermEnabled) {
-                ctx.addMessage('system', 'Agents mode not enabled. Start with --agents flag to unlock multi-agent features.');
-                break;
-            }
-            const sub = parts[1];
-            if (!sub) {
-                ctx.addMessage('system', getAgentStatusReport());
-            }
-            else if (sub === 'defs' || sub === 'list') {
-                const defs = listAgentDefs(process.cwd());
-                if (defs.length === 0) {
-                    ctx.addMessage('system', 'No agent definitions loaded. Run /agents init to create examples.');
-                }
-                else {
-                    const lines = defs.map(d => {
-                        const src = d._source || 'unknown';
-                        return `  ${d.name} — ${d.engine}/${d.provider || 'auto'}/${d.model || 'default'} [${src}]${d.description ? `\n    ${d.description}` : ''}`;
-                    });
-                    ctx.addMessage('system', `Agent Definitions (${defs.length}):\n${lines.join('\n')}`);
-                }
-            }
-            else if (sub === 'teams') {
-                const teams = listTeamDefs(process.cwd());
-                if (teams.length === 0) {
-                    ctx.addMessage('system', 'No team definitions loaded. Run /agents init to create examples.');
-                }
-                else {
-                    const lines = teams.map(t => {
-                        const src = t._source || 'unknown';
-                        return `  ${t.name} — ${t.mode}, ${t.members.length} members [${src}]${t.description ? `\n    ${t.description}` : ''}`;
-                    });
-                    ctx.addMessage('system', `Team Definitions (${teams.length}):\n${lines.join('\n')}`);
-                }
-            }
-            else if (sub === 'init') {
-                const result = scaffoldAgentsDir(process.cwd());
-                if (result.created.length > 0) {
-                    ctx.addMessage('system', `Created .calliope/agents/ with examples:\n${result.created.map(f => `  ${f}`).join('\n')}`);
-                }
-                else {
-                    ctx.addMessage('system', '.calliope/agents/ already exists.');
-                }
-            }
-            else if (sub === 'show') {
-                const name = parts[2];
-                if (!name) {
-                    ctx.addMessage('system', 'Usage: /agents show <name>');
+        case '/config': {
+            if (parts[1] === 'set') {
+                // /config set <key> <value> (absorbs the old /set)
+                const key = parts[2];
+                const value = parts.slice(3).join(' ');
+                if (!key || !value) {
+                    ctx.addMessage('system', `Usage: /config set <key> <value>
+Available keys:
+  maxIterations <number>                  - Max agent iterations (current: ${config.get('maxIterations')})
+  sessionLogLimit <number>                - Cap retained session log items (current: ${formatSessionLogLimit(config.get('sessionLogLimit'))}, 0 = unlimited)
+  collapseTools <bool>                    - Auto-collapse tool output
+  toolDisplayLimit <number>               - Tools shown expanded (0 = all)
+  diffStyle <inline|unified|side-by-side> - Diff display style
+  sandboxMode <auto|native|docker|off>    - Code execution sandbox
+  routing.enabled <bool>                  - Smart model routing
+  routing.costSensitivity <0-1>           - Cost vs quality (0 = best, 1 = cheapest)
+  theme <dark|light|no-color>             - Color theme
+  budget.maxCostPerRun <usd|off>          - Halt a run at this spend (0/off = no cap)
+  budget.maxTokensPerRun <n|off>          - Halt a run at this token count
+  budget.maxCostPerProject <usd|off>      - Halt when project spend reaches this
+  audit.enabled <bool>                    - Audit run log (on by default)
+  policy.command <path|off>               - Pre-tool policy hook script`);
+                    break;
                 }
-                else {
-                    const agentDef = getAgent(name, process.cwd());
-                    const teamDef = getTeam(name, process.cwd());
-                    if (agentDef) {
-                        const lines = [
-                            `Agent: ${agentDef.name}`,
-                            agentDef.description ? `Description: ${agentDef.description}` : '',
-                            `Engine: ${agentDef.engine}`,
-                            `Provider: ${agentDef.provider || 'auto'}`,
-                            `Model: ${agentDef.model || 'default'}`,
-                            agentDef.role ? `Role: ${agentDef.role}` : '',
-                            agentDef.weight !== undefined ? `Weight: ${agentDef.weight}` : '',
-                            agentDef.instructions ? `Instructions:\n  ${agentDef.instructions.split('\n').join('\n  ')}` : '',
-                            `Source: ${agentDef._source || 'unknown'}`,
-                            agentDef._filePath ? `File: ${agentDef._filePath}` : '',
-                        ].filter(Boolean);
-                        ctx.addMessage('system', lines.join('\n'));
+                try {
+                    if (key === 'maxIterations') {
+                        const num = parseInt(value, 10);
+                        if (isNaN(num) || num < 0 || num > 1000000) {
+                            ctx.addMessage('error', 'maxIterations must be 0-1000000 (0 = unlimited)');
+                            break;
+                        }
+                        config.set('maxIterations', num);
+                        ctx.addMessage('system', `✓ maxIterations set to ${formatIterationLimit(resolveIterationLimit(num))}`);
                     }
-                    else if (teamDef) {
-                        const lines = [
-                            `Team: ${teamDef.name}`,
-                            teamDef.description ? `Description: ${teamDef.description}` : '',
-                            `Mode: ${teamDef.mode}`,
-                            `Members (${teamDef.members.length}):`,
-                            ...teamDef.members.map(m => `  ${m.name} — ${m.engine}/${m.provider || 'auto'}/${m.model || 'default'} [${m.role || 'no role'}] w=${m.weight}`),
-                        ].filter(Boolean);
-                        ctx.addMessage('system', lines.join('\n'));
+                    else if (key === 'sessionLogLimit') {
+                        const num = parseInt(value, 10);
+                        if (isNaN(num) || num < 0 || num > 100000) {
+                            ctx.addMessage('error', 'sessionLogLimit must be 0-100000 (0 = unlimited)');
+                            break;
+                        }
+                        config.set('sessionLogLimit', num);
+                        ctx.ledger?.setRetentionLimit(num);
+                        ctx.addMessage('system', `✓ sessionLogLimit set to ${num === 0 ? 'unlimited (set > 0 to cap)' : num}`);
                     }
-                    else {
-                        ctx.addMessage('system', `No agent or team found with name '${name}'.`);
+                    else if (key === 'collapseTools') {
+                        const bool = value === 'true';
+                        config.set('collapseTools', bool);
+                        ctx.addMessage('system', `✓ collapseTools set to ${bool}`);
                     }
-                }
-            }
-            else {
-                ctx.addMessage('system', `Unknown subcommand: ${sub}\nUsage: /agents [defs|teams|init|show <name>]`);
-            }
-            break;
-        }
-        case '/install-agents': {
-            // /install-agents [name] — install missing agent CLIs and SDK backends
-            const target = parts[1];
-            if (target) {
-                ctx.addMessage('system', `Installing ${target}...`);
-                const result = installItem(target);
-                ctx.addMessage('system', result.success
-                    ? `✓ ${target} installed successfully.`
-                    : `✗ ${result.output}`);
-            }
-            else if (parts.includes('--all')) {
-                ctx.addMessage('system', 'Installing all missing agents and SDK backends...');
-                const result = await installAllMissing();
-                const lines = [];
-                if (result.installed.length > 0) {
-                    lines.push(`✓ Installed: ${result.installed.join(', ')}`);
-                }
-                if (result.failed.length > 0) {
-                    lines.push(`✗ Failed:\n  ${result.failed.join('\n  ')}`);
-                }
-                if (result.installed.length === 0 && result.failed.length === 0) {
-                    lines.push('Everything is already installed!');
-                }
-                ctx.addMessage('system', lines.join('\n'));
-            }
-            else {
-                const report = await getInstallReport();
-                ctx.addMessage('system', `${report}\n\nUsage:\n  /install-agents <name>   Install a specific agent or SDK\n  /install-agents --all    Install everything missing`);
-            }
-            break;
-        }
-        case '/build-agent': {
-            // Interactive agent definition builder
-            // Parse inline args: /build-agent [name] [--engine X] [--provider X] [--model X]
-            const agentName = parts[1] && !parts[1].startsWith('--') ? parts[1] : undefined;
-            const engineArg = parts.includes('--engine') ? parts[parts.indexOf('--engine') + 1] : undefined;
-            const providerArg = parts.includes('--provider') ? parts[parts.indexOf('--provider') + 1] : undefined;
-            const modelArg = parts.includes('--model') ? parts[parts.indexOf('--model') + 1] : undefined;
-            const roleArg = parts.includes('--role') ? parts[parts.indexOf('--role') + 1] : undefined;
-            if (!agentName) {
-                // Interactive wizard — show guided step-by-step builder
-                const executors = await getAvailableExecutors();
-                const providers = config.getConfiguredProviders();
-                // Engine descriptions
-                const engineDescriptions = {
-                    'cli': 'Built-in CLI agent loop (works with all providers, most flexible)',
-                    'claude-sdk': 'Anthropic Claude SDK (native tool use, streaming, best for Anthropic models)',
-                    'openai-sdk': 'OpenAI SDK (function calling, JSON mode, best for OpenAI models)',
-                    'google-adk': 'Google ADK (grounding, search, best for Gemini models)',
-                };
-                // Provider-to-engine recommendations
-                const providerEngineMap = {
-                    anthropic: 'claude-sdk',
-                    openai: 'openai-sdk',
-                    google: 'google-adk',
-                    together: 'cli',
-                    openrouter: 'cli',
-                    groq: 'cli',
-                    fireworks: 'cli',
-                    mistral: 'cli',
-                    ollama: 'cli',
-                    bedrock: 'cli',
-                };
-                // Common roles
-                const roles = [
-                    { name: 'coder', desc: 'Writes and refactors code' },
-                    { name: 'reviewer', desc: 'Reviews code for bugs, style, and security' },
-                    { name: 'architect', desc: 'Designs system architecture and APIs' },
-                    { name: 'researcher', desc: 'Gathers information and summarizes findings' },
-                    { name: 'qa-engineer', desc: 'Writes tests and validates correctness' },
-                    { name: 'devops', desc: 'Infrastructure, CI/CD, and deployment' },
-                    { name: 'writer', desc: 'Documentation, READMEs, and technical writing' },
-                    { name: 'analyst', desc: 'Data analysis and insights' },
-                ];
-                const lines = [];
-                lines.push('=== Build Agent Wizard ===');
-                lines.push('');
-                // Step 1: Engine
-                lines.push('STEP 1: Choose an engine');
-                lines.push('The engine determines how the agent executes (SDK backend or CLI loop).');
-                lines.push('');
-                for (const eng of ['cli', 'claude-sdk', 'openai-sdk', 'google-adk']) {
-                    const available = executors.includes(eng);
-                    const marker = available ? '[installed]' : '[not installed]';
-                    lines.push(`  ${eng}  ${marker}`);
-                    lines.push(`    ${engineDescriptions[eng] || ''}`);
-                }
-                lines.push('');
-                if (executors.length === 1) {
-                    lines.push('  Recommendation: Only "cli" is available. Install SDK packages for more options.');
-                    lines.push('  Run /install-agents to see what can be installed.');
-                }
-                else {
-                    lines.push(`  Available on this system: ${executors.join(', ')}`);
-                }
-                lines.push('');
-                // Step 2: Provider
-                lines.push('STEP 2: Choose a provider');
-                lines.push('The provider determines which API your agent calls.');
-                lines.push('');
-                if (providers.length === 0) {
-                    lines.push('  No providers configured! Run calliope --setup to add API keys.');
-                }
-                else {
-                    for (const p of providers) {
-                        const recEngine = providerEngineMap[p] || 'cli';
-                        const model = DEFAULT_MODELS[p] || 'auto';
-                        lines.push(`  ${p}  (best with --engine ${recEngine}, default model: ${model})`);
+                    else if (key === 'toolDisplayLimit') {
+                        const num = parseInt(value, 10);
+                        if (isNaN(num) || num < 0 || num > 100) {
+                            ctx.addMessage('error', 'toolDisplayLimit must be 0-100 (0 = all expanded)');
+                            break;
+                        }
+                        config.set('toolDisplayLimit', num);
+                        ctx.addMessage('system', `✓ toolDisplayLimit set to ${num}`);
                     }
-                }
-                lines.push('');
-                // Step 3: Model
-                lines.push('STEP 3: Choose a model');
-                lines.push('Each provider has a default model. Override with --model if needed.');
-                lines.push('');
-                if (providers.length > 0) {
-                    for (const p of providers) {
-                        lines.push(`  ${p}: ${DEFAULT_MODELS[p] || 'auto'}`);
+                    else if (key === 'diffStyle') {
+                        if (value !== 'inline' && value !== 'unified' && value !== 'side-by-side') {
+                            ctx.addMessage('error', 'diffStyle must be inline, unified, or side-by-side');
+                            break;
+                        }
+                        config.set('diffStyle', value);
+                        ctx.addMessage('system', `✓ diffStyle set to ${value}`);
                     }
-                    lines.push('');
-                    lines.push('  Tip: Run /models to see all available models for your providers.');
-                }
-                lines.push('');
-                // Step 4: Role
-                lines.push('STEP 4: Set a role');
-                lines.push('The role labels what this agent specializes in. Common roles:');
-                lines.push('');
-                for (const r of roles) {
-                    lines.push(`  ${r.name.padEnd(14)} ${r.desc}`);
-                }
-                lines.push('');
-                lines.push('  You can also use any custom role name.');
-                lines.push('');
-                // Step 5: Instructions
-                lines.push('STEP 5: Write instructions (after creation)');
-                lines.push('After creating the agent, edit its YAML file to add detailed instructions.');
-                lines.push('');
-                lines.push('  Template:');
-                lines.push('    instructions: |');
-                lines.push('      You are a specialized {role} agent.');
-                lines.push('      Your focus areas: ...');
-                lines.push('      When reviewing code: ...');
-                lines.push('      Output format: ...');
-                lines.push('');
-                // Final command
-                lines.push('--- Ready to build? ---');
-                lines.push('');
-                if (providers.includes('anthropic') && executors.includes('claude-sdk')) {
-                    lines.push('  /build-agent my-agent --engine claude-sdk --provider anthropic --role coder');
-                }
-                else if (providers.includes('openai') && executors.includes('openai-sdk')) {
-                    lines.push('  /build-agent my-agent --engine openai-sdk --provider openai --role coder');
-                }
-                else if (providers.length > 0) {
-                    const firstProvider = providers[0];
-                    lines.push(`  /build-agent my-agent --engine cli --provider ${firstProvider} --role coder`);
-                }
-                else {
-                    lines.push('  /build-agent my-agent --engine cli --provider anthropic --role coder');
-                }
-                lines.push('');
-                lines.push('Add --model <model> to override the default model for the chosen provider.');
-                ctx.addMessage('system', lines.join('\n'));
-            }
-            else if (!engineArg && !providerArg && !modelArg && !roleArg) {
-                // Name provided but no flags — show a concise personalized wizard
-                const executors = await getAvailableExecutors();
-                const providers = config.getConfiguredProviders();
-                const providerEngineMap = {
-                    anthropic: 'claude-sdk', openai: 'openai-sdk', google: 'google-adk',
-                    together: 'cli', openrouter: 'cli', groq: 'cli', fireworks: 'cli',
-                    mistral: 'cli', ollama: 'cli', bedrock: 'cli',
-                };
-                const lines = [];
-                lines.push(`=== Building agent: ${agentName} ===`);
-                lines.push('');
-                lines.push('Choose your configuration:');
-                lines.push('');
-                // Show ready-to-run commands for each configured provider
-                let optionNum = 0;
-                for (const p of providers) {
-                    const recEngine = providerEngineMap[p] || 'cli';
-                    const engineAvailable = executors.includes(recEngine);
-                    const engine = engineAvailable ? recEngine : 'cli';
-                    const model = DEFAULT_MODELS[p] || 'auto';
-                    optionNum++;
-                    lines.push(`  Option ${optionNum}: ${p}`);
-                    lines.push(`    /build-agent ${agentName} --engine ${engine} --provider ${p} --model ${model} --role coder`);
-                    lines.push('');
-                }
-                if (optionNum === 0) {
-                    lines.push('  No providers configured. Run calliope --setup to add API keys.');
-                    lines.push(`  Or build with defaults: /build-agent ${agentName} --engine cli --provider anthropic --role coder`);
-                }
-                lines.push('Common roles: coder, reviewer, architect, researcher, qa-engineer, devops, writer');
-                lines.push('');
-                lines.push('Pick an option above and change --role to match your needs.');
-                lines.push(`After creation, customize instructions in .calliope/agents/${agentName}.yaml`);
-                ctx.addMessage('system', lines.join('\n'));
-            }
-            else {
-                // Build and save agent definition (flags provided)
-                const newDef = {
-                    name: agentName,
-                    engine: engineArg || 'cli',
-                    provider: providerArg,
-                    model: modelArg,
-                    role: roleArg,
-                    weight: 1.0,
-                    instructions: `You are a specialized agent (${roleArg || agentName}). Complete assigned tasks thoroughly.`,
-                    limits: { timeout: 600000 },
-                };
-                const filePath = saveAgentDef(process.cwd(), newDef);
-                ctx.addMessage('system', `Agent '${agentName}' created: ${filePath}\n\nEdit the file to customize instructions and settings.\nUse with: spawn_agent agentDef="${agentName}"`);
-            }
-            break;
-        }
-        case '/build-team': {
-            // Interactive team builder
-            const teamNameArg = parts[1] && !parts[1].startsWith('--') ? parts[1] : undefined;
-            const modeArg = parts.includes('--mode') ? parts[parts.indexOf('--mode') + 1] : undefined;
-            if (!teamNameArg) {
-                // Interactive wizard — guided team builder
-                const teams = listTeamDefs(process.cwd());
-                const agents = listAgentDefs(process.cwd());
-                const lines = [];
-                lines.push('=== Build Team Wizard ===');
-                lines.push('');
-                // Step 1: Available agents
-                lines.push('STEP 1: Review your available agents');
-                lines.push('Teams are composed of agent definitions. Here is what you have:');
-                lines.push('');
-                if (agents.length === 0) {
-                    lines.push('  No agents defined yet!');
-                    lines.push('  Create agents first: /build-agent (run without args for the wizard)');
-                    lines.push('');
-                }
-                else {
-                    for (const a of agents) {
-                        const src = a._source === 'builtin' ? ' (built-in)' : '';
-                        lines.push(`  ${a.name.padEnd(20)} engine: ${a.engine.padEnd(12)} provider: ${(a.provider || 'auto').padEnd(12)} role: ${a.role || 'any'}${src}`);
+                    else if (key === 'sandboxMode') {
+                        if (value !== 'auto' && value !== 'native' && value !== 'docker' && value !== 'off') {
+                            ctx.addMessage('error', 'sandboxMode must be auto, native, docker, or off');
+                            break;
+                        }
+                        config.set('sandboxMode', value);
+                        ctx.addMessage('system', `✓ sandboxMode set to ${value}`);
                     }
-                    lines.push('');
-                    lines.push(`  Total: ${agents.length} agents available`);
-                    if (agents.length < 2) {
-                        lines.push('  You need at least 2 agents for a team. Create more with /build-agent.');
+                    else if (key === 'routing.enabled') {
+                        const bool = value === 'true';
+                        const routing = config.get('routing') ?? { enabled: false, costSensitivity: 0.3 };
+                        config.set('routing', { ...routing, enabled: bool });
+                        ctx.addMessage('system', `✓ routing.enabled set to ${bool}`);
                     }
-                    lines.push('');
-                }
-                // Step 2: Choose mode
-                lines.push('STEP 2: Choose a coordination mode');
-                lines.push('The mode determines how agents work together:');
-                lines.push('');
-                lines.push('  competitive');
-                lines.push('    All agents tackle the same task independently.');
-                lines.push('    The best response wins (scored by quality/relevance).');
-                lines.push('    Best for: code review, creative alternatives, getting multiple perspectives.');
-                lines.push('');
-                lines.push('  collaborative');
-                lines.push('    Agents work in a pipeline, each building on the previous output.');
-                lines.push('    First agent plans, next implements, last reviews.');
-                lines.push('    Best for: refactoring, multi-step tasks, plan-implement-review workflows.');
-                lines.push('');
-                lines.push('  consensus');
-                lines.push('    All agents must agree before a result is accepted.');
-                lines.push('    Disagreements trigger additional rounds of discussion.');
-                lines.push('    Best for: security audits, critical decisions, high-stakes analysis.');
-                lines.push('');
-                lines.push('  overseer');
-                lines.push('    A lead agent decomposes the task and delegates to workers.');
-                lines.push('    The overseer reviews and merges all results.');
-                lines.push('    Best for: complex projects, research, large feature implementation.');
-                lines.push('');
-                // Step 3: Strategy recommendations
-                lines.push('STEP 3: Pick a strategy based on your task');
-                lines.push('');
-                lines.push('  Task Type            Mode            Recommended Agents');
-                lines.push('  ─────────────────────────────────────────────────────────');
-                lines.push('  Code review          competitive     code-reviewer, qa-engineer');
-                lines.push('  Refactoring          collaborative   architect, coder, reviewer');
-                lines.push('  Security audit       consensus       security-analyst, code-reviewer, qa-engineer');
-                lines.push('  Research             overseer        researcher, analyst, writer');
-                lines.push('  Feature development  overseer        architect, coder, qa-engineer, reviewer');
-                lines.push('  Documentation        collaborative   researcher, writer');
-                lines.push('');
-                // Existing teams
-                if (teams.length > 0) {
-                    lines.push('Existing teams:');
-                    for (const t of teams) {
-                        lines.push(`  ${t.name.padEnd(20)} mode: ${t.mode.padEnd(14)} members: ${t.members.length}`);
+                    else if (key === 'routing.costSensitivity') {
+                        const num = Number(value);
+                        if (isNaN(num) || num < 0 || num > 1) {
+                            ctx.addMessage('error', 'routing.costSensitivity must be between 0 and 1');
+                            break;
+                        }
+                        const routing = config.get('routing') ?? { enabled: false, costSensitivity: 0.3 };
+                        config.set('routing', { ...routing, costSensitivity: num });
+                        ctx.addMessage('system', `✓ routing.costSensitivity set to ${num}`);
                     }
-                    lines.push('');
-                }
-                // Final command
-                lines.push('--- Ready to build? ---');
-                lines.push('');
-                if (agents.length >= 2) {
-                    const sampleAgents = agents.slice(0, 3).map(a => a.name).join(', ');
-                    lines.push(`  /build-team my-team --mode collaborative`);
-                    lines.push('');
-                    lines.push(`  This will auto-compose a team from your available agents (${sampleAgents}${agents.length > 3 ? ', ...' : ''}).`);
-                    lines.push('  After creation, edit the YAML to fine-tune members and settings.');
-                }
-                else {
-                    lines.push('  First, create at least 2 agents:');
-                    lines.push('    /build-agent planner --engine cli --provider anthropic --role architect');
-                    lines.push('    /build-agent coder --engine cli --provider anthropic --role coder');
-                    lines.push('');
-                    lines.push('  Then build a team:');
-                    lines.push('    /build-team my-team --mode collaborative');
-                }
-                lines.push('');
-                lines.push('After creation, use the team with:');
-                lines.push('  /swarm --team <name> <prompt>');
-                lines.push('  spawn_agent team="<name>" prompt="..."');
-                ctx.addMessage('system', lines.join('\n'));
-            }
-            else {
-                // Create a team with available agents
-                const availableAgents = listAgentDefs(process.cwd());
-                const mode = (modeArg || 'collaborative');
-                // Auto-compose a reasonable team from available agent definitions
-                const memberAgents = availableAgents
-                    .filter(a => a._source !== 'builtin' || ['code-reviewer', 'architect', 'qa-engineer', 'researcher'].includes(a.name))
-                    .slice(0, 4);
-                if (memberAgents.length < 2) {
-                    ctx.addMessage('system', `Need at least 2 agent definitions to build a team.\nCreate agents first with /build-agent <name>, then compose them with /build-team.`);
-                }
-                else {
-                    const { saveTeamDef } = await import('../agents/index.js');
-                    const teamDef = {
-                        name: teamNameArg,
-                        description: `${teamNameArg} team`,
-                        mode,
-                        members: memberAgents.map(a => ({ agent: a.name, role: a.role, weight: a.weight })),
-                        swarm: { strategy: 'parallel', aggregation: 'structured', maxWorkers: 3 },
-                        council: { maxRounds: 2, consensusThreshold: 0.67 },
-                    };
-                    const filePath = saveTeamDef(process.cwd(), teamDef);
-                    ctx.addMessage('system', `Team '${teamNameArg}' created: ${filePath}
-
-Members:
-${memberAgents.map(a => `  ${a.name} [${a.role || 'any'}]`).join('\n')}
-
-Mode: ${mode}
-
-Use with:
-  /swarm --team ${teamNameArg} <prompt>
-  /swarm coord --team ${teamNameArg} <prompt>
-  spawn_agent team="${teamNameArg}" prompt="..."
-
-Edit the YAML to customize members, strategy, and coordination settings.`);
-                }
-            }
-            break;
-        }
-        case '/set': {
-            // /set <key> <value>
-            const key = parts[1];
-            const value = parts.slice(2).join(' ');
-            if (!key || !value) {
-                ctx.addMessage('system', `Usage: /set <key> <value>
-Available keys:
-  maxIterations <number>  - Max agent iterations (current: ${config.get('maxIterations')})
-  sessionLogLimit <number> - Cap retained session log items (current: ${formatSessionLogLimit(config.get('sessionLogLimit'))}, 0 = unlimited)
-  persona <name>          - calliope, muse, minimal
-  fancyOutput <bool>      - true/false`);
-                break;
-            }
-            try {
-                if (key === 'maxIterations') {
-                    const num = parseInt(value, 10);
-                    if (isNaN(num) || num < 0 || num > 1000000) {
-                        ctx.addMessage('error', 'maxIterations must be 0-1000000 (0 = unlimited)');
-                        break;
+                    else if (key === 'theme') {
+                        const themes = await import('../themes.js');
+                        if (themes.setCurrentTheme(value)) {
+                            themes.clearThemeCache();
+                            ctx.addMessage('system', `✓ theme set to ${value}`);
+                        }
+                        else {
+                            ctx.addMessage('error', `Theme not found: ${value}. Options: dark, light, no-color`);
+                        }
                     }
-                    config.set('maxIterations', num);
-                    ctx.addMessage('system', `\u2713 maxIterations set to ${formatIterationLimit(resolveIterationLimit(num))}`);
-                }
-                else if (key === 'sessionLogLimit') {
-                    const num = parseInt(value, 10);
-                    if (isNaN(num) || num < 0 || num > 100000) {
-                        ctx.addMessage('error', 'sessionLogLimit must be 0-100000 (0 = unlimited)');
-                        break;
+                    else if (key === 'budget.maxCostPerRun') {
+                        ctx.addMessage('system', applyBudgetKey('maxCostPerRun', value));
                     }
-                    config.set('sessionLogLimit', num);
-                    ctx.ledger?.setRetentionLimit(num);
-                    ctx.addMessage('system', `\u2713 sessionLogLimit set to ${num === 0 ? 'unlimited (set > 0 to cap)' : num}`);
-                }
-                else if (key === 'persona') {
-                    if (!['calliope', 'muse', 'minimal'].includes(value)) {
-                        ctx.addMessage('error', 'persona must be: calliope, muse, or minimal');
-                        break;
+                    else if (key === 'budget.maxTokensPerRun') {
+                        ctx.addMessage('system', applyBudgetKey('maxTokensPerRun', value));
+                    }
+                    else if (key === 'budget.maxCostPerProject') {
+                        ctx.addMessage('system', applyBudgetKey('maxCostPerProject', value));
+                    }
+                    else if (key === 'audit.enabled') {
+                        const bool = value === 'true';
+                        config.set('audit', { ...(config.get('audit') ?? {}), enabled: bool });
+                        ctx.addMessage('system', `✓ audit.enabled set to ${bool}`);
+                    }
+                    else if (key === 'policy.command') {
+                        const policy = { ...(config.get('policy') ?? {}) };
+                        if (value === 'off' || value === 'none') {
+                            delete policy.command;
+                            config.set('policy', policy);
+                            ctx.addMessage('system', '✓ policy.command cleared');
+                        }
+                        else {
+                            config.set('policy', { ...policy, command: value });
+                            ctx.addMessage('system', '✓ policy.command set');
+                        }
+                    }
+                    else {
+                        ctx.addMessage('error', `Unknown config key: ${key}`);
                     }
-                    config.set('persona', value);
-                    ctx.setPersona(value);
-                    ctx.addMessage('system', `\u2713 persona set to ${value}`);
-                }
-                else if (key === 'fancyOutput') {
-                    const bool = value === 'true';
-                    config.set('fancyOutput', bool);
-                    ctx.addMessage('system', `\u2713 fancyOutput set to ${bool}`);
                 }
-                else {
-                    ctx.addMessage('error', `Unknown config key: ${key}`);
+                catch (err) {
+                    ctx.addMessage('error', `Failed to set ${key}: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
-            catch (err) {
-                ctx.addMessage('error', `Failed to set ${key}: ${err instanceof Error ? err.message : String(err)}`);
+            else {
+                ctx.addMessage('system', `Config: ${config.getConfigPath()}\nProviders: ${config.getConfiguredProviders().join(', ') || 'none'}\nmaxIterations: ${config.get('maxIterations')}\nsessionLogLimit: ${formatSessionLogLimit(config.get('sessionLogLimit'))} (set > 0 to cap)\n\nChange a setting with /config set <key> <value>`);
             }
             break;
         }
         case '/setup':
             ctx.addMessage('system', 'Run `calliope --setup` to reconfigure.');
             break;
-        case '/layout': {
-            // /layout [classic|response-top|response-bottom|split|zen|focus|dashboard|minimal]
-            const layoutArg = parts[1];
-            if (!layoutArg) {
-                ctx.addMessage('system', `Current layout: ${ctx.layout}
-
-Available layouts:
-  classic         - Everything in chronological order
-  response-top    - Calliope response at top, tools below
-  response-bottom - Tools at top, response at bottom (default)
-  split           - Side by side: tools left, response right
-  zen             - Response only, tools hidden — distraction-free
-  focus           - Latest response pinned top, compact tool log
-  dashboard       - Three-panel: stats, response, tools
-  minimal         - No decorations, raw text output
-
-Usage: /layout <name>`);
-                break;
-            }
-            const validLayouts = ['classic', 'response-top', 'response-bottom', 'split', 'zen', 'focus', 'dashboard', 'minimal'];
-            if (!validLayouts.includes(layoutArg)) {
-                ctx.addMessage('error', `Invalid layout. Choose: ${validLayouts.join(', ')}`);
-                break;
-            }
-            config.set('layout', layoutArg);
-            ctx.setLayout(layoutArg);
-            ctx.addMessage('system', `\u2713 Layout set to: ${layoutArg}`);
-            break;
-        }
-        case '/density': {
-            // /density [normal|compact]
-            const densityArg = parts[1];
-            if (!densityArg) {
-                ctx.addMessage('system', `Current density: ${ctx.density}
-
-Available densities:
-  normal  - Standard spacing
-  compact - Reduced whitespace for more info
-
-Usage: /density <normal|compact>`);
-                break;
-            }
-            const validDensities = ['normal', 'compact'];
-            if (!validDensities.includes(densityArg)) {
-                ctx.addMessage('error', `Invalid density. Choose: normal, compact`);
-                break;
-            }
-            config.set('density', densityArg);
-            ctx.setDensity(densityArg);
-            ctx.addMessage('system', `\u2713 Density set to: ${densityArg}`);
-            break;
-        }
-        case '/collapse': {
-            // /collapse [tools|thinking|all|off] [limit N]
-            const subCmd = parts[1];
-            if (!subCmd) {
-                ctx.addMessage('system', `Collapse settings:
-  collapseTools: ${ctx.collapseSettings.collapseTools}
-  collapseThinking: ${ctx.collapseSettings.collapseThinking}
-  toolDisplayLimit: ${ctx.collapseSettings.toolDisplayLimit} (0 = all expanded)
-
-Usage:
-  /collapse tools      - Toggle tool output collapsing
-  /collapse thinking   - Toggle thinking block collapsing
-  /collapse all        - Collapse both tools and thinking
-  /collapse off        - Expand everything
-  /collapse limit <N>  - Show last N tools expanded (0 = all)`);
-                break;
-            }
-            if (subCmd === 'tools') {
-                const newVal = !ctx.collapseSettings.collapseTools;
-                config.set('collapseTools', newVal);
-                ctx.setCollapseSettings(prev => ({ ...prev, collapseTools: newVal }));
-                ctx.addMessage('system', `\u2713 collapseTools set to ${newVal}`);
-            }
-            else if (subCmd === 'thinking') {
-                const newVal = !ctx.collapseSettings.collapseThinking;
-                config.set('collapseThinking', newVal);
-                ctx.setCollapseSettings(prev => ({ ...prev, collapseThinking: newVal }));
-                ctx.addMessage('system', `\u2713 collapseThinking set to ${newVal}`);
-            }
-            else if (subCmd === 'all') {
-                config.set('collapseTools', true);
-                config.set('collapseThinking', true);
-                ctx.setCollapseSettings(prev => ({ ...prev, collapseTools: true, collapseThinking: true }));
-                ctx.addMessage('system', '\u2713 Collapsing tools and thinking');
-            }
-            else if (subCmd === 'off') {
-                config.set('collapseTools', false);
-                config.set('collapseThinking', false);
-                ctx.setCollapseSettings(prev => ({ ...prev, collapseTools: false, collapseThinking: false }));
-                ctx.addMessage('system', '\u2713 Expanding all output');
-            }
-            else if (subCmd === 'limit') {
-                const limit = parseInt(parts[2], 10);
-                if (isNaN(limit) || limit < 0 || limit > 100) {
-                    ctx.addMessage('error', 'Limit must be 0-100');
-                    break;
+        case '/loop': {
+            // /loop stop absorbs the old /cancel-loop, /breakloop, /stop
+            if (parts[1] === 'stop') {
+                if (ctx.loopActive) {
+                    ctx.loopCancelledRef.current = true;
+                    ctx.setLoopActive(false);
+                    ctx.addMessage('system', '\u{1F6D1} Loop cancelled');
                 }
-                config.set('toolDisplayLimit', limit);
-                ctx.setCollapseSettings(prev => ({ ...prev, toolDisplayLimit: limit }));
-                ctx.addMessage('system', `\u2713 toolDisplayLimit set to ${limit}`);
-            }
-            else {
-                ctx.addMessage('error', 'Unknown collapse option. Use: tools, thinking, all, off, or limit <N>');
+                else {
+                    ctx.addMessage('system', 'No active loop to cancel');
+                }
+                break;
             }
-            break;
-        }
-        case '/loop': {
             // Parse /loop "<prompt>" [--max-iterations N] [--completion-promise "text"]
             if (ctx.loopActive) {
-                ctx.addMessage('system', 'Loop already running. Use /breakloop to stop it first.');
+                ctx.addMessage('system', 'Loop already running. Use /loop stop to stop it first.');
                 break;
             }
             const loopArgs = parts.slice(1).join(' ');
@@ -1138,7 +535,8 @@ Usage:
                 prompt = quotedMatch[1];
             if (!prompt) {
                 ctx.addMessage('system', `Usage: /loop "<prompt>" [--max-iterations N] [--completion-promise "text"]
-Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE"`);
+Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE"
+Stop a running loop with /loop stop`);
                 break;
             }
             const defaultMaxIterations = resolveIterationLimit(config.get('maxIterations'));
@@ -1156,86 +554,11 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
   Prompt: "${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}"
   Max iterations: ${formatIterationLimit(loopMaxIterations)}
   ${completionMatch ? `Completion promise: "${completionMatch[1]}"` : isFiniteIterationLimit(loopMaxIterations) ? 'No completion promise (runs until max iterations)' : 'No completion promise (runs until stopped)'}
-  Use /breakloop to stop`);
+  Use /loop stop to stop`);
             // Start the loop execution (non-blocking)
             ctx.runLoop(prompt, loopMaxIterations, completionMatch?.[1]);
             break;
         }
-        case '/cancel-loop':
-        case '/breakloop':
-        case '/stop':
-            if (ctx.loopActive) {
-                ctx.loopCancelledRef.current = true;
-                ctx.setLoopActive(false);
-                ctx.addMessage('system', '\u{1F6D1} Loop cancelled');
-            }
-            else {
-                ctx.addMessage('system', 'No active loop to cancel');
-            }
-            break;
-        case '/confirm':
-            if (parts[1] === 'on') {
-                ctx.setConfirmMode(true);
-                ctx.addMessage('system', '\u2713 Confirmation mode ON - will ask before risky operations');
-            }
-            else if (parts[1] === 'off') {
-                ctx.setConfirmMode(false);
-                ctx.addMessage('system', '\u26A0\uFE0F Confirmation mode OFF - risky operations will auto-execute');
-            }
-            else {
-                ctx.addMessage('system', `Confirm mode: ${ctx.confirmMode ? 'ON' : 'OFF'}\nUsage: /confirm [on|off]`);
-            }
-            break;
-        case '/profile': {
-            const subCmd = parts[1];
-            if (subCmd === 'list' || !subCmd) {
-                const profiles = config.listProfiles();
-                const active = config.getActiveProfile();
-                const list = profiles.map(p => {
-                    const marker = p.name === active ? '\u2192 ' : '  ';
-                    const tag = p.builtin ? '(built-in)' : '(custom)';
-                    return `${marker}${p.name}: ${p.profile.provider}/${p.profile.model || 'default'} ${tag}`;
-                }).join('\n');
-                ctx.addMessage('system', `Profiles:\n${list}\n\nUsage: /profile <name> | /profile save <name>`);
-            }
-            else if (subCmd === 'save' && parts[2]) {
-                const name = parts[2];
-                config.saveProfile(name, {
-                    provider: ctx.provider,
-                    model: ctx.model,
-                    persona: ctx.persona,
-                    confirmMode: ctx.confirmMode,
-                });
-                ctx.addMessage('system', `\u2713 Saved profile: ${name}`);
-            }
-            else if (subCmd === 'delete' && parts[2]) {
-                const name = parts[2];
-                if (config.deleteProfile(name)) {
-                    ctx.addMessage('system', `\u2713 Deleted profile: ${name}`);
-                }
-                else {
-                    ctx.addMessage('error', `Cannot delete profile: ${name} (built-in or not found)`);
-                }
-            }
-            else {
-                // Load profile
-                const profile = config.getProfile(subCmd);
-                if (profile) {
-                    ctx.setProvider(profile.provider);
-                    if (profile.model)
-                        ctx.setModel(profile.model);
-                    ctx.setPersona(profile.persona);
-                    if (profile.confirmMode !== undefined)
-                        ctx.setConfirmMode(profile.confirmMode);
-                    config.setActiveProfile(subCmd);
-                    ctx.addMessage('system', `\u2713 Loaded profile: ${subCmd} (${profile.provider}/${profile.model || 'default'})`);
-                }
-                else {
-                    ctx.addMessage('error', `Profile not found: ${subCmd}\nBuilt-in: fast, smart, cheap, local`);
-                }
-            }
-            break;
-        }
         case '/mcp': {
             const subCmd = parts[1];
             if (subCmd === 'list' || !subCmd) {
@@ -1245,7 +568,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                 }
                 else {
                     const list = servers.map(s => {
-                        const status = s.status === 'connected' ? '\u{1F7E2}' : s.status === 'error' ? '\u{1F534}' : '\u26AA';
+                        const status = s.status === 'connected' ? '\u{1F7E2}' : s.status === 'error' ? '\u{1F534}' : '⚪';
                         return `${status} ${s.name} (${s.tools.length} tools)\n   ${s.url}`;
                     }).join('\n\n');
                     ctx.addMessage('system', `MCP Servers:\n\n${list}`);
@@ -1256,7 +579,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                 ctx.addMessage('system', `Registering MCP server: ${url}...`);
                 try {
                     const server = await mcp.registerServer(url);
-                    ctx.addMessage('system', `\u2713 Registered: ${server.name} (${server.tools.length} tools)`);
+                    ctx.addMessage('system', `✓ Registered: ${server.name} (${server.tools.length} tools)`);
                 }
                 catch (e) {
                     ctx.addMessage('error', `Failed to register: ${e instanceof Error ? e.message : String(e)}`);
@@ -1264,7 +587,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             }
             else if ((subCmd === 'remove' || subCmd === 'rm') && parts[2]) {
                 if (mcp.unregisterServer(parts[2])) {
-                    ctx.addMessage('system', '\u2713 Server removed');
+                    ctx.addMessage('system', '✓ Server removed');
                 }
                 else {
                     ctx.addMessage('error', 'Server not found');
@@ -1286,7 +609,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                     ctx.addMessage('system', 'No MCP tools available. Add servers with /mcp add <url>');
                 }
                 else {
-                    const list = tools.map(t => `\u2022 ${t.name}\n  ${t.description}`).join('\n\n');
+                    const list = tools.map(t => `• ${t.name}\n  ${t.description}`).join('\n\n');
                     ctx.addMessage('system', `MCP Tools:\n\n${list}`);
                 }
             }
@@ -1298,14 +621,20 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
         case '/skills': {
             const subCmd = parts[1];
             if (subCmd === 'list' || !subCmd) {
-                const allSkills = skills.getSkills();
-                if (allSkills.length === 0) {
+                // Show every installed skill with its trust state (#137) — including
+                // CHANGED entries that getSkills() withholds from the model.
+                const listed = skills.listSkills();
+                if (listed.length === 0) {
                     ctx.addMessage('system', 'No skills installed.\n\nUsage:\n  /skills add <name>     - Install from agentskills.io\n  /skills add <github-url> - Install from GitHub\n  /skills add <path>     - Install from local directory');
                 }
                 else {
-                    const list = allSkills.map(s => {
+                    const list = listed.map(s => {
                         const src = s.source === 'github' ? '(GitHub)' : s.source === 'registry' ? '(agentskills.io)' : '(local)';
-                        return `\u2022 ${s.metadata.name} ${src}\n  ${s.metadata.description.substring(0, 80)}...`;
+                        const trust = s.trust === 'pinned' ? (s.fingerprint ?? 'pinned') :
+                            s.trust === 'changed' ? 'CHANGED — reinstall to re-trust' :
+                                'UNVERIFIED';
+                        const desc = s.description ? `${s.description.substring(0, 80)}...` : '';
+                        return `• ${s.name} ${src} [${trust}]\n  ${desc}`;
                     }).join('\n\n');
                     ctx.addMessage('system', `Installed Skills:\n\n${list}`);
                 }
@@ -1313,6 +642,10 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             else if (subCmd === 'add' && parts[2]) {
                 const source = parts[2];
                 ctx.addMessage('system', `Installing skill: ${source}...`);
+                // Snapshot pinned fingerprints so a re-install can show old→new rather
+                // than re-pinning silently (#137). The remote name is only known after
+                // the fetch, so we key the lookup by the returned skill's name.
+                const priorFingerprints = new Map(skills.listSkills().map(s => [s.name, s.fingerprint]));
                 try {
                     let skill;
                     if (source.startsWith('http')) {
@@ -1325,7 +658,14 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                         skill = await skills.installFromRegistry(source);
                     }
                     if (skill) {
-                        ctx.addMessage('system', `\u2713 Installed: ${skill.metadata.name}`);
+                        const prev = priorFingerprints.get(skill.metadata.name);
+                        const now = skill.fingerprint ?? '(unverified)';
+                        if (prev && prev !== skill.fingerprint) {
+                            ctx.addMessage('system', `✓ Re-pinned ${skill.metadata.name}: ${prev} → ${now} (content updated)`);
+                        }
+                        else {
+                            ctx.addMessage('system', `✓ Installed ${skill.metadata.name} — pinned ${now} (trust-on-first-use)`);
+                        }
                     }
                     else {
                         ctx.addMessage('error', 'Failed to install skill');
@@ -1337,7 +677,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             }
             else if ((subCmd === 'remove' || subCmd === 'rm') && parts[2]) {
                 if (skills.uninstallSkill(parts[2])) {
-                    ctx.addMessage('system', '\u2713 Skill removed');
+                    ctx.addMessage('system', '✓ Skill removed');
                 }
                 else {
                     ctx.addMessage('error', 'Skill not found');
@@ -1354,10 +694,19 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                         info += `License: ${skill.metadata.license}\n`;
                     if (skill.sourceUrl)
                         info += `Source: ${skill.sourceUrl}\n`;
+                    info += skill.fingerprint ? `Fingerprint: ${skill.fingerprint} (${skill.trust})\n` : 'Fingerprint: none (UNVERIFIED)\n';
                     ctx.addMessage('system', info);
                 }
                 else {
-                    ctx.addMessage('error', 'Skill not found');
+                    // getSkill withholds a tampered skill; surface WHY, not a bare
+                    // "not found", so the trust state stays visible (#137).
+                    const changed = skills.listSkills().find(s => s.name === parts[2] && s.trust === 'changed');
+                    if (changed) {
+                        ctx.addMessage('error', `Skill "${parts[2]}" CHANGED since install (pinned ${changed.fingerprint}) — content no longer matches. Reinstall to re-trust.`);
+                    }
+                    else {
+                        ctx.addMessage('error', 'Skill not found');
+                    }
                 }
             }
             else {
@@ -1434,894 +783,55 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             }
             break;
         }
-        case '/find': {
-            const fuzzy = await import('../fuzzy-search.js');
-            const query = parts.slice(1).join(' ');
-            if (!query) {
-                ctx.addMessage('system', 'Usage: /find <pattern>\nFuzzy search for files');
-            }
-            else {
-                const results = fuzzy.searchWithHighlight(process.cwd(), query, { maxResults: 20 });
-                if (results.length === 0) {
-                    ctx.addMessage('system', 'No files found');
-                }
-                else {
-                    const list = results.map((r, i) => `${i + 1}. ${r.highlighted}`).join('\n');
-                    ctx.addMessage('system', `Found ${results.length} files:\n\n${list}`);
-                }
-            }
-            break;
-        }
-        case '/branch': {
-            const branching = await import('../branching.js');
+        case '/scope': {
             const subCmd = parts[1];
-            const sessionId = ctx.sessionRef.current?.id || storage.createSessionId();
-            if (subCmd === 'list' || !subCmd) {
-                const tree = branching.getBranchTree(sessionId);
-                ctx.addMessage('system', `Branches:\n${tree}`);
-            }
-            else if (subCmd === 'new' && parts[2]) {
-                const branch = branching.createBranch(sessionId, parts[2], ctx.llmMessages.current, parts.slice(3).join(' '));
-                ctx.addMessage('system', `Created branch: ${branch.name}`);
-            }
-            else if (subCmd === 'switch' && parts[2]) {
-                const msgs = branching.switchBranch(sessionId, parts[2], ctx.llmMessages.current);
-                if (msgs) {
-                    ctx.llmMessages.current = msgs;
-                    ctx.addMessage('system', `Switched to branch: ${parts[2]}`);
+            if (subCmd === 'add') {
+                // Absorbs the old /add-dir
+                const dirPath = parts.slice(2).join(' ').replace(/^["']|["']$/g, '');
+                if (!dirPath) {
+                    ctx.addMessage('system', 'Usage: /scope add <path>\n\nAdd a directory to the allowed scope.\nThe agent can only access files within scope.');
                 }
                 else {
-                    ctx.addMessage('error', 'Branch not found');
+                    const result = addToScope(dirPath);
+                    if (result.success) {
+                        ctx.addMessage('system', `✓ ${result.message}`);
+                    }
+                    else {
+                        ctx.addMessage('error', result.message);
+                    }
                 }
             }
-            else if (subCmd === 'delete' && parts[2]) {
-                if (branching.deleteBranch(sessionId, parts[2])) {
-                    ctx.addMessage('system', 'Branch deleted');
+            else if (subCmd === 'remove') {
+                // Absorbs the old /remove-dir
+                const dirPath = parts.slice(2).join(' ').replace(/^["']|["']$/g, '');
+                if (!dirPath) {
+                    ctx.addMessage('system', 'Usage: /scope remove <path>\n\nRemove a directory from the allowed scope.');
                 }
                 else {
-                    ctx.addMessage('error', 'Cannot delete branch');
+                    const result = removeFromScope(dirPath);
+                    if (result.success) {
+                        ctx.addMessage('system', `✓ ${result.message}`);
+                    }
+                    else {
+                        ctx.addMessage('error', result.message);
+                    }
                 }
             }
-            else {
-                ctx.addMessage('system', 'Usage: /branch [list|new <name>|switch <name>|delete <name>]');
-            }
-            break;
-        }
-        case '/theme': {
-            const subCmd = parts[1];
-            if (!subCmd) {
-                // Open interactive theme picker
-                ctx.setModalMode('theme-picker');
-            }
-            else if (subCmd === 'list') {
-                const themes = await import('../themes.js');
-                const list = themes.listThemes();
-                const current = themes.getCurrentThemeName();
-                const formatted = list.map((t) => {
-                    const marker = t.name === current ? ' *' : '';
-                    const custom = t.custom ? ' (custom)' : '';
-                    return `  ${t.name}${marker}${custom} - ${t.description || 'No description'}`;
-                }).join('\n');
-                ctx.addMessage('system', `Available themes:\n${formatted}`);
-            }
-            else {
-                const themes = await import('../themes.js');
-                if (themes.setCurrentTheme(subCmd)) {
-                    themes.clearThemeCache();
-                    ctx.addMessage('system', `Theme set to: ${subCmd}`);
-                }
-                else {
-                    ctx.addMessage('error', `Theme not found: ${subCmd}`);
-                }
-            }
-            break;
-        }
-        case '/skin': {
-            const subCmd = parts[1];
-            if (subCmd === 'list' || !subCmd) {
-                const skins = listSkins();
-                const current = getCurrentSkin();
-                const formatted = skins.map((s) => {
-                    const marker = s.name === current.name ? ' *' : '';
-                    const custom = s.custom ? ' (custom)' : '';
-                    return `  ${s.name}${marker}${custom} - ${s.description}`;
-                }).join('\n');
-                ctx.addMessage('system', `Active: ${current.name}\nAvailable skins:\n${formatted}`);
-            }
-            else {
-                applySkin(subCmd);
-                const newSkin = getCurrentSkin();
-                if (newSkin.name === subCmd) {
-                    config.set('activeSkin', subCmd);
-                    ctx.addMessage('system', `Skin set to: ${subCmd} \u2014 ${newSkin.description}`);
-                }
-                else {
-                    ctx.addMessage('error', `Skin not found: ${subCmd}. Available: ${listSkins().map((s) => s.name).join(', ')}`);
-                }
-            }
-            break;
-        }
-        case '/palette': {
-            const subCmd = parts[1];
-            if (subCmd === 'list' || !subCmd) {
-                const palettes = listPalettes();
-                const current = getCurrentPalette();
-                const formatted = palettes.map((p) => {
-                    const marker = p.name === current.name ? ' *' : '';
-                    const custom = p.custom ? ' (custom)' : '';
-                    return `  ${p.name}${marker}${custom} - ${p.description}`;
-                }).join('\n');
-                ctx.addMessage('system', `Active: ${current.name}\nAvailable palettes:\n${formatted}`);
-            }
-            else {
-                applyPalette(subCmd);
-                const newPal = getCurrentPalette();
-                if (newPal.name === subCmd) {
-                    config.set('activePalette', subCmd);
-                    ctx.addMessage('system', `Palette set to: ${subCmd} \u2014 ${newPal.description}`);
-                }
-                else {
-                    ctx.addMessage('error', `Palette not found: ${subCmd}. Available: ${listPalettes().map((p) => p.name).join(', ')}`);
-                }
-            }
-            break;
-        }
-        case '/companion': {
-            const subCmd = parts[1];
-            if (subCmd === 'list' || !subCmd) {
-                const companions = listCompanions();
-                const current = getCurrentCompanion();
-                const formatted = companions.map((comp) => {
-                    const marker = comp.name === current.name ? ' *' : '';
-                    return `  ${comp.name}${marker} - ${comp.description}`;
-                }).join('\n');
-                ctx.addMessage('system', `Active: ${current.name}\nAvailable companions:\n${formatted}`);
-            }
-            else {
-                applyCompanion(subCmd);
-                const newComp = getCurrentCompanion();
-                if (newComp.name === subCmd) {
-                    config.set('activeCompanion', subCmd);
-                    ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
-                    ctx.addMessage('system', `Companion set to: ${subCmd} \u2014 "${newComp.greeting}"`);
-                }
-                else {
-                    ctx.addMessage('error', `Companion not found: ${subCmd}. Available: ${listCompanions().map((c) => c.name).join(', ')}`);
-                }
-            }
-            break;
-        }
-        case '/banner': {
-            const bannerSkin = getCurrentSkin();
-            const bannerPalette = getCurrentPalette();
-            const bannerColor = bannerPalette.colors.primary;
-            const imgInfo = getTerminalImageInfo();
-            const rendered = renderSkinBanner(bannerSkin.banner.art, bannerColor, bannerSkin.banner.tagline ?? undefined, imgInfo.mode);
-            ctx.addMessage('system', `${rendered}\n\nSkin: ${bannerSkin.name} | Terminal: ${getImageModeLabel(imgInfo.mode)}${imgInfo.truecolor ? ' (truecolor)' : ''}`);
-            break;
-        }
-        case '/hud': {
-            const hudSkin = getCurrentSkin();
-            const hudPalette = getCurrentPalette();
-            const hudCompanion = getCurrentCompanion();
-            const hudPack = getCurrentPack();
-            const hudIntensity = getCompanionMode();
-            ctx.addMessage('system', `HUD Configuration\n` +
-                (hudPack ? `  Pack:      ${hudPack.name} — ${hudPack.description}\n` : '') +
-                `  Skin:      ${hudSkin.name} — ${hudSkin.description}\n` +
-                `  Palette:   ${hudPalette.name} — ${hudPalette.description}\n` +
-                `  Companion: ${hudCompanion.name} — ${hudCompanion.description}\n` +
-                `  Intensity: ${hudIntensity}\n` +
-                `  Emojis:    ${config.get('useEmojis') !== false ? 'ON' : 'OFF'}\n` +
-                `  Mood:      ${getMoodText()}\n\n` +
-                `  /pack <name>  /intensity <pro|immersive>  /emoji [on|off]\n` +
-                `  /skin <name>  /palette <name>  /companion <name>`);
-            break;
-        }
-        case '/pack': {
-            const subCmd = parts[1];
-            if (!subCmd) {
-                ctx.setModalMode('pack-picker');
-                break;
-            }
-            if (subCmd === 'list') {
-                const category = parts[2];
-                const packs = listThemePacks(category || undefined);
-                const currentP = getCurrentPack();
-                // Group by category
-                const grouped = new Map();
-                for (const p of packs) {
-                    const group = grouped.get(p.category) || [];
-                    group.push(p);
-                    grouped.set(p.category, group);
-                }
-                let output = 'Theme Packs:\n';
-                for (const [cat, catPacks] of grouped) {
-                    output += `\n  [${cat}]\n`;
-                    for (const p of catPacks) {
-                        const marker = currentP && p.name === currentP.name ? ' *' : '';
-                        output += `    ${p.name}${marker} — ${p.description}\n`;
-                    }
-                }
-                output += '\nUse: /pack <name>';
-                ctx.addMessage('system', output);
-            }
-            else {
-                // Run theme transition animation before applying
-                const targetPack = getThemePack(subCmd);
-                if (targetPack?.skin.splash?.transition) {
-                    await renderTransition(targetPack.skin.splash.transition);
-                }
-                const success = applyThemePack(subCmd, getCompanionMode());
-                if (success) {
-                    const pack = getCurrentPack();
-                    config.set('activeThemePack', subCmd);
-                    config.set('activeSkin', pack.skin.name);
-                    config.set('activePalette', pack.palette.name);
-                    const companion = getCompanionMode() === 'professional'
-                        ? pack.companions.professional
-                        : pack.companions.immersive;
-                    config.set('activeCompanion', companion.name);
-                    // Reset LLM system prompt to use the companion's persona
-                    ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
-                    ctx.addMessage('system', `Theme pack: ${subCmd}\n` +
-                        `  Skin: ${pack.skin.name}, Palette: ${pack.palette.name}, Companion: ${companion.name}\n` +
-                        `  "${companion.greeting}"`);
-                }
-                else {
-                    ctx.addMessage('error', `Theme pack not found: ${subCmd}. Use /pack list to see available packs.`);
-                }
-            }
-            break;
-        }
-        case '/intensity': {
-            const intensity = parts[1];
-            if (intensity === 'professional' || intensity === 'pro') {
-                const success = setCompanionMode('professional');
-                if (success) {
-                    const pack = getCurrentPack();
-                    config.set('companionIntensity', 'professional');
-                    config.set('activeCompanion', pack.companions.professional.name);
-                    ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
-                    ctx.addMessage('system', `Switched to professional mode — ${pack.companions.professional.description}`);
-                }
-                else {
-                    ctx.addMessage('error', 'No theme pack active. Use /pack <name> first.');
-                }
-            }
-            else if (intensity === 'immersive' || intensity === 'imm') {
-                const success = setCompanionMode('immersive');
-                if (success) {
-                    const pack = getCurrentPack();
-                    config.set('companionIntensity', 'immersive');
-                    config.set('activeCompanion', pack.companions.immersive.name);
-                    ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
-                    ctx.addMessage('system', `Switched to immersive mode — ${pack.companions.immersive.description}`);
-                }
-                else {
-                    ctx.addMessage('error', 'No theme pack active. Use /pack <name> first.');
-                }
-            }
-            else {
-                const currentIntensity = getCompanionMode();
-                ctx.addMessage('system', `Intensity: ${currentIntensity}\nOptions: /intensity professional (pro), /intensity immersive (imm)`);
-            }
-            break;
-        }
-        case '/emoji': {
-            const emojiArg = parts[1];
-            const current = config.get('useEmojis') !== false;
-            if (emojiArg === 'on') {
-                config.set('useEmojis', true);
-                ctx.addMessage('system', '\u2713 Emojis enabled');
-            }
-            else if (emojiArg === 'off') {
-                config.set('useEmojis', false);
-                ctx.addMessage('system', '\u2713 Emojis disabled — text fallbacks will be used');
-            }
-            else if (emojiArg === 'toggle') {
-                config.set('useEmojis', !current);
-                ctx.addMessage('system', `\u2713 Emojis ${!current ? 'enabled' : 'disabled'}`);
-            }
-            else {
-                ctx.addMessage('system', `Emojis: ${current ? 'ON' : 'OFF'}\nUsage: /emoji [on|off|toggle]`);
-            }
-            break;
-        }
-        case '/hooks': {
-            const hooksModule = await import('../hooks.js');
-            const subCmd = parts[1];
-            if (subCmd === 'list' || !subCmd) {
-                ctx.addMessage('system', hooksModule.listHooksFormatted());
-            }
-            else if (subCmd === 'add' && parts[2]) {
-                const event = parts[2];
-                const hookCommand = parts.slice(3).join(' ');
-                if (!hookCommand) {
-                    ctx.addMessage('system', 'Usage: /hooks add <event> <command>');
-                }
-                else {
-                    hooksModule.addHook({ event, name: `Hook for ${event}`, command: hookCommand, enabled: true, async: false });
-                    ctx.addMessage('system', 'Hook added');
-                }
-            }
-            else if (subCmd === 'init') {
-                hooksModule.initDefaultHooks();
-                ctx.addMessage('system', 'Default hooks initialized');
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /hooks [list|add <event> <command>|init]');
-            }
-            break;
-        }
-        case '/search': {
-            const query = parts.slice(1).join(' ');
-            if (!query) {
-                ctx.addMessage('system', 'Usage: /search <query>\nSearch conversation history');
-            }
-            else {
-                const lower = query.toLowerCase();
-                const matches = ctx.messages.filter(m => m.content.toLowerCase().includes(lower));
-                if (matches.length === 0) {
-                    ctx.addMessage('system', 'No matches found');
-                }
-                else {
-                    const results = matches.slice(-10).map(m => {
-                        const preview = m.content.slice(0, 100).replace(/\n/g, ' ');
-                        return `[${m.type}] ${preview}...`;
-                    }).join('\n\n');
-                    ctx.addMessage('system', `Found ${matches.length} matches:\n\n${results}`);
-                }
-            }
-            break;
-        }
-        case '/project': {
-            const projectConfig = await import('../project-config.js');
-            const subCmd = parts[1];
-            const cwd = process.cwd();
-            if (subCmd === 'init') {
-                const configPath = projectConfig.createProjectConfig(cwd);
-                ctx.addMessage('system', `Created project config: ${configPath}\nEdit the file to customize settings.`);
-            }
-            else if (subCmd === 'show' || !subCmd) {
-                const configPath = projectConfig.findProjectConfig(cwd);
-                if (!configPath) {
-                    ctx.addMessage('system', 'No project config found.\nRun /project init to create one.');
-                }
-                else {
-                    const cfg = projectConfig.loadProjectConfig(configPath);
-                    if (cfg) {
-                        let info = `Config: ${configPath}\n\n`;
-                        if (cfg.project)
-                            info += `Project: ${cfg.project}\n`;
-                        if (cfg.provider)
-                            info += `Provider: ${cfg.provider}\n`;
-                        if (cfg.model)
-                            info += `Model: ${cfg.model}\n`;
-                        if (cfg.tech?.length)
-                            info += `Tech: ${cfg.tech.join(', ')}\n`;
-                        if (cfg.conventions?.length)
-                            info += `\nConventions:\n${cfg.conventions.map((c) => `  - ${c}`).join('\n')}\n`;
-                        if (cfg.commands)
-                            info += `\nCommands: ${Object.keys(cfg.commands).join(', ')}\n`;
-                        ctx.addMessage('system', info);
-                    }
-                    else {
-                        ctx.addMessage('error', 'Failed to parse config');
-                    }
-                }
-            }
-            else if (subCmd === 'run' && parts[2]) {
-                const configPath = projectConfig.findProjectConfig(cwd);
-                const cfg = configPath ? projectConfig.loadProjectConfig(configPath) : null;
-                const cmdName = parts[2];
-                if (cfg?.commands?.[cmdName]) {
-                    const commandToRun = cfg.commands[cmdName];
-                    // Show the command and source for user awareness
-                    ctx.addMessage('system', `Project command "${cmdName}" from ${configPath}:\n` +
-                        `  $ ${commandToRun}\n\n` +
-                        `Type "/project run-confirm ${cmdName}" to execute, or review the .calliope config first.`);
-                }
-                else {
-                    ctx.addMessage('error', `Command not found: ${cmdName}`);
-                }
-            }
-            else if (subCmd === 'run-confirm' && parts[2]) {
-                const configPath = projectConfig.findProjectConfig(cwd);
-                const cfg = configPath ? projectConfig.loadProjectConfig(configPath) : null;
-                const cmdName = parts[2];
-                if (cfg?.commands?.[cmdName]) {
-                    const commandToRun = cfg.commands[cmdName];
-                    ctx.addMessage('system', `Running: ${commandToRun}`);
-                    const { spawn } = await import('child_process');
-                    const proc = spawn('sh', ['-c', commandToRun], { cwd, stdio: 'pipe' });
-                    let output = '';
-                    proc.stdout?.on('data', (d) => output += d.toString());
-                    proc.stderr?.on('data', (d) => output += d.toString());
-                    proc.on('close', (code) => {
-                        ctx.addMessage('system', `Exit ${code}\n${output}`);
-                    });
-                }
-                else {
-                    ctx.addMessage('error', `Command not found: ${cmdName}`);
-                }
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /project [init|show|run <cmd>|run-confirm <cmd>]');
-            }
-            break;
-        }
-        case '/route':
-        case '/autoroute': {
-            if (parts[1] === 'on') {
-                ctx.setAutoRoute(true);
-                ctx.addMessage('system', '\u2713 Auto-routing ON - model selected based on task complexity');
-            }
-            else if (parts[1] === 'off') {
-                ctx.setAutoRoute(false);
-                ctx.addMessage('system', '\u2713 Auto-routing OFF - using fixed model');
-            }
-            else if (parts[1] === 'test' && parts[2]) {
-                const testMsg = parts.slice(2).join(' ');
-                const decision = modelRouter.routeRequest(testMsg, ctx.actualProvider);
-                ctx.addMessage('system', `Route test: ${decision.tier} tier (${decision.complexity})\nModel: ${decision.model.model}\nReason: ${decision.reason}\nConfidence: ${Math.round(decision.confidence * 100)}%`);
-            }
-            else {
-                const tiers = modelRouter.getAllTiers(ctx.actualProvider);
-                ctx.addMessage('system', `Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}\n\nModel tiers for ${ctx.actualProvider}:\n  fast: ${tiers.fast.model}\n  balanced: ${tiers.balanced.model}\n  smart: ${tiers.smart.model}\n\nUsage: /route [on|off|test <message>]`);
-            }
-            break;
-        }
-        case '/summarize': {
-            const subCmd = parts[1];
-            if (subCmd === 'context' || !subCmd) {
-                const msgCount = ctx.llmMessages.current.length;
-                if (msgCount < 5) {
-                    ctx.addMessage('system', 'Not enough messages to summarize.');
-                }
-                else {
-                    const summary = summarization.extractKeyInfo(ctx.llmMessages.current);
-                    let info = 'Context Summary:\n\n';
-                    if (summary.topics.length)
-                        info += `**Topics:** ${summary.topics.join(', ')}\n`;
-                    if (summary.decisions.length)
-                        info += `**Decisions:**\n${summary.decisions.map((d) => `  - ${d}`).join('\n')}\n`;
-                    if (summary.actions.length)
-                        info += `**Actions:**\n${summary.actions.map((a) => `  - ${a}`).join('\n')}\n`;
-                    if (summary.codeChanges.length)
-                        info += `**Code Changes:**\n${summary.codeChanges.slice(0, 5).map((c) => `  - ${c}`).join('\n')}\n`;
-                    ctx.addMessage('system', info || 'No key information extracted.');
-                }
-            }
-            else if (subCmd === 'compact') {
-                // Summarize and compact the conversation
-                const result = summarization.summarizeConversation(ctx.llmMessages.current, { maxTokens: 50000 });
-                if (result.summarizedCount > 0) {
-                    ctx.llmMessages.current = result.messages;
-                    ctx.setContextTokens(ctx.estimateContextTokens());
-                    ctx.addMessage('system', `\u2713 Compacted ${result.summarizedCount} messages (${result.originalTokens} \u2192 ${result.reducedTokens} tokens)`);
-                }
-                else {
-                    ctx.addMessage('system', 'Context already within limits, no compaction needed.');
-                }
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /summarize [context|compact]');
-            }
-            break;
-        }
-        case '/upgrade':
-            ctx.addMessage('system', 'Checking for updates...');
-            try {
-                const current = getVersion();
-                const latest = await getLatestVersion();
-                if (!latest) {
-                    ctx.addMessage('error', 'Could not check for updates');
-                    break;
-                }
-                const [cMaj, cMin, cPat] = current.split('.').map(Number);
-                const [lMaj, lMin, lPat] = latest.split('.').map(Number);
-                const hasUpdate = lMaj > cMaj || (lMaj === cMaj && lMin > cMin) || (lMaj === cMaj && lMin === cMin && lPat > cPat);
-                if (hasUpdate) {
-                    ctx.setLatestVersion(latest);
-                    ctx.setModalMode('upgrade');
-                }
-                else {
-                    ctx.addMessage('system', `You're on the latest version (v${current})`);
-                }
-            }
-            catch (e) {
-                ctx.addMessage('error', `Failed to check for updates: ${e instanceof Error ? e.message : String(e)}`);
-            }
-            break;
-        case '/session':
-        case '/sessions':
-            if (parts[1] === 'list' || !parts[1]) {
-                const sessions = storage.listSessions(20);
-                if (sessions.length === 0) {
-                    ctx.addMessage('system', 'No previous sessions found.');
-                }
-                else {
-                    ctx.setAvailableSessions(sessions);
-                    ctx.setModalMode('sessions');
-                }
-            }
-            else if (parts[1] === 'info') {
-                const session = ctx.sessionRef.current;
-                if (session) {
-                    const savedMessages = storage.loadMessageHistory();
-                    const savedCount = savedMessages ? savedMessages.length : 0;
-                    const ledgerTotals = ctx.ledger?.getTotals();
-                    const latestRun = ctx.ledger?.getLatestRun();
-                    const lines = [
-                        `Session: ${session.projectName}`,
-                        `ID: ${session.id}`,
-                        `Created: ${new Date(session.createdAt).toLocaleString()}`,
-                        `Messages: ${session.messageCount}`,
-                        `Saved LLM messages: ${savedCount}`,
-                    ];
-                    if (ledgerTotals) {
-                        lines.push(`Iterations logged: ${ledgerTotals.iterations}`, `Failed approaches: ${ctx.ledger?.getFailedApproachCount() ?? 0}`);
-                    }
-                    if (latestRun) {
-                        lines.push(`Latest run: ${formatLedgerRun(latestRun)}`);
-                    }
-                    ctx.addMessage('system', lines.join('\n'));
-                }
-                else {
-                    ctx.addMessage('system', 'No active session.');
-                }
-            }
-            else if (parts[1] === 'fork') {
-                const session = ctx.sessionRef.current;
-                if (!session) {
-                    ctx.addMessage('error', 'No active session to fork.');
-                }
-                else {
-                    // Save current messages before forking
-                    storage.saveMessageHistory(ctx.llmMessages.current);
-                    if (ctx.ledger) {
-                        storage.saveIterationLedger(ctx.ledger);
-                    }
-                    const forked = storage.forkSession(session.projectPath);
-                    if (forked) {
-                        ctx.sessionRef.current = forked;
-                        ctx.addMessage('system', `Forked session: ${forked.id}\nMessages carried over: ${ctx.llmMessages.current.length}\n\nYou are now on the forked session. The original session is preserved.`);
-                    }
-                    else {
-                        ctx.addMessage('error', 'Failed to fork session. No saved messages found.');
-                    }
-                }
-            }
-            else if (parts[1] === 'save') {
-                storage.saveMessageHistory(ctx.llmMessages.current);
-                if (ctx.ledger) {
-                    storage.saveIterationLedger(ctx.ledger);
-                }
-                ctx.addMessage('system', `Saved ${ctx.llmMessages.current.length} LLM messages and current log state to session.`);
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /session [list|info|fork|save] or just /sessions');
-            }
-            break;
-        case '/log': {
-            if (!ctx.ledger) {
-                ctx.addMessage('system', 'No session log available.');
-                break;
-            }
-            const subCmd = parts[1] || 'summary';
-            if (subCmd === 'summary') {
-                const totals = ctx.ledger.getTotals();
-                const runs = ctx.ledger.getRuns(5);
-                const allFailures = ctx.ledger.getFailedApproaches();
-                const failures = allFailures.slice(-5);
-                const lines = [
-                    'Session Log',
-                    `Iterations: ${totals.iterations}`,
-                    `Failed approaches: ${ctx.ledger.getFailedApproachCount()}`,
-                    `Tokens: ${totals.totalTokens}`,
-                    `Cost: $${totals.totalCost.toFixed(4)}`,
-                    `Duration: ${formatLedgerDuration(totals.totalDurationMs)}`,
-                ];
-                if (runs.length > 0) {
-                    lines.push('', 'Recent runs:');
-                    for (const run of runs) {
-                        lines.push(`  - ${formatLedgerRun(run)}`);
-                    }
-                }
-                if (failures.length > 0) {
-                    lines.push('', 'Recent failures:');
-                    for (const failure of failures) {
-                        lines.push(`  - #${failure.iteration} ${failure.description} — ${failure.reason}`);
-                    }
-                }
-                ctx.addMessage('system', lines.join('\n'));
-            }
-            else if (subCmd === 'tail') {
-                const limit = parts[2] ? parseInt(parts[2], 10) : 10;
-                if (isNaN(limit) || limit <= 0 || limit > 100) {
-                    ctx.addMessage('error', 'Usage: /log tail [1-100]');
-                    break;
-                }
-                const entries = ctx.ledger.getEntries().slice(-limit);
-                if (entries.length === 0) {
-                    ctx.addMessage('system', 'No logged iterations yet.');
-                    break;
-                }
-                const lines = ['Recent iterations:'];
-                for (const entry of entries) {
-                    const actions = entry.actions.length > 0
-                        ? entry.actions.map(action => `${action.tool}(${action.args})${action.result === 'error' ? ' FAILED' : action.result === 'blocked' ? ' BLOCKED' : ''}`).join(', ')
-                        : 'no tool actions';
-                    lines.push(`  #${entry.iteration} [${entry.outcome}] ${formatLedgerDuration(entry.durationMs)} — ${actions}`);
-                }
-                ctx.addMessage('system', lines.join('\n'));
-            }
-            else if (subCmd === 'failures') {
-                const failures = ctx.ledger.getFailedApproaches();
-                if (failures.length === 0) {
-                    ctx.addMessage('system', 'No failed approaches recorded.');
-                    break;
-                }
-                const lines = ['Failed approaches:'];
-                for (const failure of failures.slice(-10)) {
-                    lines.push(`  - #${failure.iteration} ${failure.description} — ${failure.reason}`);
-                }
-                ctx.addMessage('system', lines.join('\n'));
-            }
-            else if (subCmd === 'reset') {
-                ctx.ledger.reset();
-                ctx.addMessage('system', 'Session log reset.');
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /log [summary|tail [N]|failures|reset]');
-            }
-            break;
-        }
-        case '/todo': {
-            const subCommand = parts[1];
-            if (subCommand === 'add' && parts.length > 2) {
-                const content = parts.slice(2).join(' ');
-                const isGlobal = content.includes('--global');
-                const isHigh = content.includes('--priority') && content.includes('high');
-                const cleanContent = content.replace(/--global|--priority\s*\w+/g, '').trim();
-                const todo = storage.addTodo(cleanContent, {
-                    global: isGlobal,
-                    priority: isHigh ? 'high' : 'normal',
-                });
-                ctx.addMessage('system', `\u2713 TODO added (#${todo.id.slice(-4)}${isGlobal ? ', global' : ''})`);
-            }
-            else if (subCommand === 'done' && parts[2]) {
-                const id = parts[2];
-                const todos = [...storage.getSessionTodos(), ...storage.getGlobalTodos()];
-                const todo = todos.find(t => t.id.endsWith(id) || t.id === id);
-                if (todo) {
-                    storage.updateTodo(todo.id, { status: 'completed' });
-                    ctx.addMessage('system', `\u2713 TODO #${id} marked done`);
-                }
-                else {
-                    ctx.addMessage('error', `TODO #${id} not found`);
-                }
-            }
-            else if (subCommand === 'list' || !subCommand) {
-                const sessionTodos = storage.getSessionTodos();
-                const globalTodos = storage.getGlobalTodos();
-                const pending = [...sessionTodos, ...globalTodos].filter(t => t.status !== 'completed');
-                const completed = [...sessionTodos, ...globalTodos].filter(t => t.status === 'completed').slice(-3);
-                if (pending.length === 0 && completed.length === 0) {
-                    ctx.addMessage('system', 'No TODOs. Use /todo add <task> to create one.');
-                }
-                else {
-                    let output = '\u{1F4CB} TODOs:\n';
-                    if (pending.length > 0) {
-                        output += pending.map(t => `  ${t.priority === 'high' ? '!' : '\u25A1'} #${t.id.slice(-4)} ${t.content}`).join('\n');
-                    }
-                    if (completed.length > 0) {
-                        output += '\n\nCompleted:\n' + completed.map(t => `  \u2713 #${t.id.slice(-4)} ${t.content}`).join('\n');
-                    }
-                    ctx.addMessage('system', output);
-                }
-            }
-            else if (subCommand === 'work' && parts[2]) {
-                const id = parts[2];
-                const todos = [...storage.getSessionTodos(), ...storage.getGlobalTodos()];
-                const todo = todos.find(t => t.id.endsWith(id) || t.id === id);
-                if (todo) {
-                    storage.setActiveTodo(todo.id);
-                    storage.updateTodo(todo.id, { status: 'in_progress' });
-                    ctx.addMessage('system', `\u2713 Working on: ${todo.content}\n\nTip: I'll help you complete this task. Describe what you need.`);
-                }
-                else {
-                    ctx.addMessage('error', `TODO #${id} not found`);
-                }
-            }
-            else if (subCommand === 'clear') {
-                storage.setActiveTodo(null);
-                ctx.addMessage('system', '\u2713 Active TODO cleared');
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /todo [add <task>|done <id>|work <id>|clear|list]');
-            }
-            break;
-        }
-        case '/plans': {
-            const subCommand = parts[1];
-            if (subCommand === 'list' || !subCommand) {
-                const plans = storage.getPlans();
-                if (plans.length === 0) {
-                    ctx.addMessage('system', 'No plans yet. Plans are created in hybrid mode.');
-                }
-                else {
-                    const list = plans.slice(0, 5).map((p) => `${p.status === 'completed' ? '\u2713' : '\u25CB'} ${p.id.slice(-4)}: ${p.title}`).join('\n');
-                    ctx.addMessage('system', `\u{1F4CB} Plans:\n${list}`);
-                }
-            }
-            else if (subCommand === 'view' && parts[2]) {
-                const plans = storage.getPlans();
-                const plan = plans.find((p) => p.id.endsWith(parts[2]) || p.id === parts[2]);
-                if (plan) {
-                    const phases = plan.phases.map((ph) => `  ${ph.status === 'completed' ? '\u2713' : '\u25CB'} ${ph.name} (${ph.risk} risk)`).join('\n');
-                    ctx.addMessage('system', `Plan: ${plan.title}\nStatus: ${plan.status}\n\nPhases:\n${phases}`);
-                }
-                else {
-                    ctx.addMessage('error', `Plan #${parts[2]} not found`);
-                }
-            }
-            else if (subCommand === 'rerun' && parts[2]) {
-                const plans = storage.getPlans();
-                const plan = plans.find((p) => p.id.endsWith(parts[2]) || p.id === parts[2]);
-                if (plan) {
-                    // Reset plan status and activate
-                    plan.status = 'in_progress';
-                    plan.phases.forEach((ph) => ph.status = 'pending');
-                    storage.savePlan(plan);
-                    storage.setActivePlan(plan);
-                    // Generate prompt for re-execution
-                    const phaseList = plan.phases.map((ph) => `- ${ph.name}`).join('\n');
-                    const prompt = `Please help me execute this plan:\n\n**${plan.title}**\n\nPhases:\n${phaseList}\n\nStart with the first phase.`;
-                    ctx.setInput(prompt);
-                    ctx.addMessage('system', `\u2713 Plan loaded: ${plan.title}\nPress Enter to start execution.`);
-                }
-                else {
-                    ctx.addMessage('error', `Plan #${parts[2]} not found`);
-                }
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /plans [list|view <id>|rerun <id>]');
-            }
-            break;
-        }
-        case '/history': {
-            const subCommand = parts[1];
-            if (subCommand === 'search' && parts[2]) {
-                const query = parts.slice(2).join(' ');
-                const results = storage.searchChatHistory(query);
-                if (results.length === 0) {
-                    ctx.addMessage('system', `No matches for "${query}"`);
-                }
-                else {
-                    const list = results.slice(-5).map((m) => `${new Date(m.timestamp).toLocaleTimeString()}: ${m.content.substring(0, 60)}...`).join('\n');
-                    ctx.addMessage('system', `\u{1F50D} Found ${results.length} matches:\n${list}`);
-                }
-            }
-            else if (subCommand === 'clear') {
-                ctx.addMessage('system', 'History is preserved per session. Start a new session for fresh history.');
-            }
-            else {
-                const history = storage.getChatHistory(5);
-                if (history.length === 0) {
-                    ctx.addMessage('system', 'No chat history yet.');
-                }
-                else {
-                    const list = history.map((m) => `${m.role}: ${m.content.substring(0, 50)}...`).join('\n');
-                    ctx.addMessage('system', `Recent history:\n${list}\n\nUse /history search <query> to search.`);
-                }
-            }
-            break;
-        }
-        case '/context': {
-            const subCommand = parts[1];
-            if (subCommand === 'load') {
-                const limit = parseInt(parts[2]) || 20;
-                const history = storage.getChatHistory(limit);
-                if (history.length > 0) {
-                    // Load history into LLM context
-                    for (const msg of history) {
-                        if (msg.role === 'user' || msg.role === 'assistant') {
-                            ctx.llmMessages.current.push({
-                                role: msg.role,
-                                content: msg.content,
-                            });
-                        }
-                    }
-                    ctx.addMessage('system', `\u2713 Loaded ${history.length} messages into context`);
-                }
-                else {
-                    ctx.addMessage('system', 'No history to load.');
-                }
-            }
-            else if (subCommand === 'summary' || !subCommand) {
-                // Enhanced context summary with model limits
-                const msgCount = ctx.llmMessages.current.length;
-                const estTokens = ctx.estimateContextTokens();
-                const modelLimit = getModelContextLimit(ctx.actualProvider, ctx.actualModel);
-                const percentage = Math.round((estTokens / modelLimit) * 100);
-                const formatK = (n) => n >= 1000 ? `${Math.round(n / 1000)}K` : String(n);
-                let status = '\u{1F7E2} Healthy';
-                if (percentage > 90)
-                    status = '\u{1F534} Critical';
-                else if (percentage > 80)
-                    status = '\u{1F7E1} Warning';
-                else if (percentage > 60)
-                    status = '\u{1F7E0} Caution';
-                ctx.addMessage('system', `**Context Status: ${status}**
-
-**Usage:** ${formatK(estTokens)} / ${formatK(modelLimit)} tokens (${percentage}%)
-**Messages:** ${msgCount}
-**Provider:** ${ctx.actualProvider}
-**Model:** ${ctx.actualModel}
-
-**Commands:**
-  /summarize compact - Auto-compress context
-  /context load [n]  - Load n messages from history
-  /clear             - Start fresh`);
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /context [load [n]|summary]\n\nShow context status or load history.');
-            }
-            break;
-        }
-        case '/scope':
-        case '/dirs': {
-            const subCmd = parts[1];
-            if (subCmd === 'details' || subCmd === 'full') {
-                ctx.addMessage('system', getScopeDetails());
+            else if (subCmd === 'details' || subCmd === 'full') {
+                ctx.addMessage('system', getScopeDetails());
             }
             else if (subCmd === 'reset') {
                 resetScope(process.cwd());
-                ctx.addMessage('system', '\u2713 Scope reset to current directory only');
+                ctx.addMessage('system', '✓ Scope reset to current directory only');
             }
             else {
                 ctx.addMessage('system', getScopeSummary());
             }
             break;
         }
-        case '/add-dir': {
-            const dirPath = parts.slice(1).join(' ').replace(/^["']|["']$/g, '');
-            if (!dirPath) {
-                ctx.addMessage('system', 'Usage: /add-dir <path>\n\nAdd a directory to the allowed scope.\nThe agent can only access files within scope.');
-            }
-            else {
-                const result = addToScope(dirPath);
-                if (result.success) {
-                    ctx.addMessage('system', `\u2713 ${result.message}`);
-                }
-                else {
-                    ctx.addMessage('error', result.message);
-                }
-            }
-            break;
-        }
-        case '/remove-dir': {
-            const dirPath = parts.slice(1).join(' ').replace(/^["']|["']$/g, '');
-            if (!dirPath) {
-                ctx.addMessage('system', 'Usage: /remove-dir <path>\n\nRemove a directory from the allowed scope.');
-            }
-            else {
-                const result = removeFromScope(dirPath);
-                if (result.success) {
-                    ctx.addMessage('system', `\u2713 ${result.message}`);
-                }
-                else {
-                    ctx.addMessage('error', result.message);
-                }
-            }
-            break;
-        }
-        case '/trust':
-        case '/untrust': {
+        case '/trust': {
             const { checkTrust, trustProject, untrustProject, listTrustedProjects, removeFromRegistry } = await import('../trust.js');
-            const trustSubCmd = command === '/untrust' ? 'remove' : (parts[1] || 'status');
+            const trustSubCmd = parts[1] || 'status';
             if (trustSubCmd === 'status') {
                 const trust = checkTrust(process.cwd());
                 ctx.addMessage('system', `Trust: ${trust.trusted ? '✓ Trusted' : '✗ Untrusted'}\n${trust.reason}${trust.changed ? '\n⚠️ CALLIOPE.md has changed since trust was granted' : ''}`);
@@ -2332,14 +842,10 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                 ctx.addMessage('system', `✓ Trusted: ${dir}`);
             }
             else if (trustSubCmd === 'remove' || trustSubCmd === 'no') {
+                // Absorbs the old /untrust
                 const dir = parts[2] || process.cwd();
-                if (command === '/untrust') {
-                    untrustProject(parts[1] || process.cwd());
-                }
-                else {
-                    untrustProject(dir);
-                }
-                ctx.addMessage('system', `✗ Untrusted: ${command === '/untrust' ? (parts[1] || process.cwd()) : dir}`);
+                untrustProject(dir);
+                ctx.addMessage('system', `✗ Untrusted: ${dir}`);
             }
             else if (trustSubCmd === 'list') {
                 const projects = listTrustedProjects();
@@ -2357,215 +863,54 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                 ctx.addMessage('system', `Removed from trust registry: ${dir}`);
             }
             else {
-                ctx.addMessage('system', 'Usage: /trust [status|add|remove|list|clear]\n  /trust add [path] - trust a project\n  /trust remove [path] - untrust a project\n  /untrust [path] - shortcut for /trust remove');
+                ctx.addMessage('system', 'Usage: /trust [status|add|remove|list|clear]\n  /trust add [path]    - trust a project\n  /trust remove [path] - untrust a project');
             }
             break;
         }
-        case '/template':
-        case '/t': {
-            const subCmd = parts[1];
-            if (subCmd === 'list' || !subCmd) {
-                if (ctx.templates.length === 0) {
-                    ctx.addMessage('system', 'No templates saved.\n\nUsage:\n  /template save <name> <prompt>\n  /template use <name>\n  /template delete <name>');
-                }
-                else {
-                    const list = ctx.templates.map((t, i) => `  ${i + 1}. ${t.name}: "${t.prompt.substring(0, 50)}${t.prompt.length > 50 ? '...' : ''}"`).join('\n');
-                    ctx.addMessage('system', `Templates:\n${list}`);
-                }
-            }
-            else if (subCmd === 'save' && parts[2]) {
-                const name = parts[2];
-                const prompt = parts.slice(3).join(' ').replace(/^["']|["']$/g, '');
-                if (!prompt) {
-                    ctx.addMessage('error', 'Usage: /template save <name> "<prompt>"');
-                }
-                else {
-                    storage.saveTemplate(name, prompt);
-                    ctx.setTemplates(prev => {
-                        const filtered = prev.filter(t => t.name !== name);
-                        return [...filtered, { name, prompt, createdAt: new Date() }];
-                    });
-                    ctx.addMessage('system', `\u2713 Template saved: ${name}`);
-                }
-            }
-            else if (subCmd === 'use' && parts[2]) {
-                const name = parts[2];
-                const template = ctx.templates.find(t => t.name === name);
-                if (template) {
-                    ctx.setInput(template.prompt);
-                    ctx.addMessage('system', `\u2713 Template loaded: ${name} (press Enter to send)`);
-                }
-                else {
-                    ctx.addMessage('error', `Template not found: ${name}`);
-                }
-            }
-            else if (subCmd === 'delete' && parts[2]) {
-                const name = parts[2];
-                const found = ctx.templates.find(t => t.name === name);
-                if (found) {
-                    storage.deleteTemplate(name);
-                    ctx.setTemplates(prev => prev.filter(t => t.name !== name));
-                    ctx.addMessage('system', `\u2713 Template deleted: ${name}`);
-                }
-                else {
-                    ctx.addMessage('error', `Template not found: ${name}`);
-                }
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /template [list|save <name> <prompt>|use <name>|delete <name>]');
-            }
-            break;
-        }
-        case '/cost':
-        case '/costs': {
+        case '/cost': {
             const subCmd = parts[1];
             if (subCmd === 'reset') {
                 storage.resetCosts();
-                ctx.addMessage('system', '\u2713 Cost tracking reset');
+                ctx.addMessage('system', '✓ Cost tracking reset');
             }
             else {
                 ctx.addMessage('system', storage.getCostSummary());
             }
             break;
         }
-        case '/bookmark':
-        case '/bm': {
+        case '/compact': {
             const subCmd = parts[1];
-            if (!subCmd || subCmd === 'list') {
-                // List bookmarks
-                if (ctx.bookmarks.length === 0) {
-                    ctx.addMessage('system', 'No bookmarks. Use /bookmark "name" to create one.');
-                }
-                else {
-                    const list = ctx.bookmarks.map((b, i) => `  ${i + 1}. \u{1F516} ${b.name} (message #${b.messageIndex})`).join('\n');
-                    ctx.addMessage('system', `Bookmarks:\n${list}\n\nUse /bookmark goto <number> to jump.`);
-                }
-            }
-            else if (subCmd === 'goto' && parts[2]) {
-                const idx = parseInt(parts[2]) - 1;
-                if (idx >= 0 && idx < ctx.bookmarks.length) {
-                    const bm = ctx.bookmarks[idx];
-                    // Save current state for undo
-                    ctx.saveUndoState();
-                    // Restore to bookmark point
-                    ctx.setMessages(ctx.messages.slice(0, bm.messageIndex + 1));
-                    ctx.llmMessages.current = ctx.llmMessages.current.slice(0, bm.llmMessageIndex + 1);
-                    ctx.setContextTokens(ctx.estimateContextTokens());
-                    ctx.addMessage('system', `\u2713 Jumped to bookmark: ${bm.name}`);
-                }
-                else {
-                    ctx.addMessage('error', `Invalid bookmark number. Use /bookmark list to see available.`);
-                }
-            }
-            else if (subCmd === 'delete' && parts[2]) {
-                const idx = parseInt(parts[2]) - 1;
-                if (idx >= 0 && idx < ctx.bookmarks.length) {
-                    const removed = ctx.bookmarks[idx];
-                    ctx.setBookmarks(prev => prev.filter((_, i) => i !== idx));
-                    ctx.addMessage('system', `\u2713 Deleted bookmark: ${removed.name}`);
-                }
-                else {
-                    ctx.addMessage('error', 'Invalid bookmark number.');
-                }
-            }
-            else {
-                // Create bookmark with given name
-                const name = parts.slice(1).join(' ').replace(/^["']|["']$/g, '');
-                const bm = {
-                    id: `bm_${Date.now()}`,
-                    name,
-                    messageIndex: ctx.messages.length - 1,
-                    llmMessageIndex: ctx.llmMessages.current.length - 1,
-                    timestamp: new Date(),
-                };
-                ctx.setBookmarks(prev => [...prev, bm]);
-                ctx.addMessage('system', `\u{1F516} Bookmark created: "${name}"`);
-            }
-            break;
-        }
-        case '/queue':
-        case '/q': {
-            // /q is now queue, use /exit to quit
-            if (command === '/q' && !parts[1]) {
-                // Just /q with no args shows queue
-                if (ctx.queuedMessages.length === 0) {
-                    ctx.addMessage('system', 'No messages queued. Type while agent is processing to queue feedback.');
-                }
-                else {
-                    const list = ctx.queuedMessages.map((m, i) => `  ${i + 1}. ${m.substring(0, 60)}${m.length > 60 ? '...' : ''}`).join('\n');
-                    ctx.addMessage('system', `\u{1F4E8} Queued messages (${ctx.queuedMessages.length}):\n${list}\n\nUse /queue clear to remove all.`);
-                }
-                break;
-            }
-            const subCmd = parts[1];
-            if (subCmd === 'clear') {
-                const count = ctx.queuedMessages.length;
-                ctx.setQueuedMessages([]);
-                ctx.addMessage('system', `\u2713 Cleared ${count} queued message${count !== 1 ? 's' : ''}`);
-            }
-            else if (subCmd === 'show' || !subCmd) {
-                if (ctx.queuedMessages.length === 0) {
-                    ctx.addMessage('system', 'No messages queued.');
+            if (subCmd === 'status') {
+                const msgCount = ctx.llmMessages.current.length;
+                if (msgCount < 5) {
+                    ctx.addMessage('system', 'Not enough messages to summarize.');
                 }
                 else {
-                    const list = ctx.queuedMessages.map((m, i) => `  ${i + 1}. ${m}`).join('\n');
-                    ctx.addMessage('system', `\u{1F4E8} Queued messages:\n${list}`);
+                    const summary = summarization.extractKeyInfo(ctx.llmMessages.current);
+                    let info = 'Context Summary:\n\n';
+                    if (summary.topics.length)
+                        info += `**Topics:** ${summary.topics.join(', ')}\n`;
+                    if (summary.decisions.length)
+                        info += `**Decisions:**\n${summary.decisions.map((d) => `  - ${d}`).join('\n')}\n`;
+                    if (summary.actions.length)
+                        info += `**Actions:**\n${summary.actions.map((a) => `  - ${a}`).join('\n')}\n`;
+                    if (summary.codeChanges.length)
+                        info += `**Code Changes:**\n${summary.codeChanges.slice(0, 5).map((c) => `  - ${c}`).join('\n')}\n`;
+                    ctx.addMessage('system', info || 'No key information extracted.');
                 }
             }
-            else if (subCmd === 'flush') {
-                // Force-process queued messages even if stuck
-                if (ctx.queuedMessages.length === 0) {
-                    ctx.addMessage('system', 'No messages to flush.');
+            else {
+                // Default: summarize and compact the conversation
+                const result = summarization.summarizeConversation(ctx.llmMessages.current, { maxTokens: 50000 });
+                if (result.summarizedCount > 0) {
+                    ctx.llmMessages.current = result.messages;
+                    ctx.setContextTokens(ctx.estimateContextTokens());
+                    ctx.addMessage('system', `✓ Compacted ${result.summarizedCount} messages (${result.originalTokens} → ${result.reducedTokens} tokens)`);
                 }
                 else {
-                    const queued = [...ctx.queuedMessages];
-                    ctx.setQueuedMessages([]);
-                    ctx.setIsProcessing(false); // Force reset processing state
-                    ctx.setThinkingState(null);
-                    ctx.setStreamingResponse('');
-                    ctx.addMessage('system', `\u{1F504} Flushing ${queued.length} queued message(s)...`);
-                    const followUp = queued.length === 1
-                        ? queued[0]
-                        : `[Multiple follow-up messages:]\n${queued.map((m, i) => `${i + 1}. ${m}`).join('\n')}`;
-                    setTimeout(() => {
-                        ctx.setIsProcessing(true);
-                        ctx.runAgent(followUp).finally(() => {
-                            ctx.setIsProcessing(false);
-                            ctx.setThinkingState(null);
-                            ctx.setStreamingResponse('');
-                        });
-                    }, 50);
+                    ctx.addMessage('system', 'Context already within limits, no compaction needed.');
                 }
             }
-            else {
-                ctx.addMessage('system', 'Usage: /queue [show|clear|flush]\n\nTip: Type while agent is processing to queue follow-up messages.');
-            }
-            break;
-        }
-        case '/flush': {
-            // Shortcut for /queue flush - force-process queued messages
-            if (ctx.queuedMessages.length === 0) {
-                ctx.addMessage('system', 'No messages to flush. Use /debug to see current state.');
-            }
-            else {
-                const queued = [...ctx.queuedMessages];
-                ctx.setQueuedMessages([]);
-                ctx.setIsProcessing(false); // Force reset processing state
-                ctx.setThinkingState(null);
-                ctx.setStreamingResponse('');
-                ctx.addMessage('system', `\u{1F504} Flushing ${queued.length} queued message(s)...`);
-                const followUp = queued.length === 1
-                    ? queued[0]
-                    : `[Multiple follow-up messages:]\n${queued.map((m, i) => `${i + 1}. ${m}`).join('\n')}`;
-                setTimeout(() => {
-                    ctx.setIsProcessing(true);
-                    ctx.runAgent(followUp).finally(() => {
-                        ctx.setIsProcessing(false);
-                        ctx.setThinkingState(null);
-                        ctx.setStreamingResponse('');
-                    });
-                }, 50);
-            }
             break;
         }
         case '/debug': {
@@ -2596,55 +941,6 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             }
             break;
         }
-        case '/unstick': {
-            // Emergency reset of processing state
-            ctx.setIsProcessing(false);
-            ctx.setThinkingState(null);
-            ctx.setStreamingResponse('');
-            ctx.setLoopActive(false);
-            ctx.setModalMode('none');
-            ctx.setPendingComplexPrompt(null);
-            // Also reset to hybrid mode if stuck in plan mode
-            if (ctx.mode === 'plan') {
-                ctx.setMode('hybrid');
-                ctx.addMessage('system', '\u{1F527} Reset processing state + switched from plan to hybrid mode.');
-            }
-            else {
-                ctx.addMessage('system', '\u{1F527} Reset processing state. You can now submit new messages.');
-            }
-            break;
-        }
-        case '/keys':
-        case '/?': {
-            // Show keybindings modal
-            ctx.setModalMode('keys');
-            break;
-        }
-        case '/work': {
-            // Quick shortcut to enter work mode
-            ctx.setMode('work');
-            ctx.addMessage('system', `Mode: ${MODE_CONFIG['work'].icon} ${MODE_CONFIG['work'].label} - ${MODE_CONFIG['work'].description}`);
-            break;
-        }
-        case '/plan': {
-            // Quick shortcut to enter plan mode
-            ctx.setMode('plan');
-            ctx.addMessage('system', `Mode: ${MODE_CONFIG['plan'].icon} ${MODE_CONFIG['plan'].label} - ${MODE_CONFIG['plan'].description}`);
-            break;
-        }
-        case '/approve': {
-            // Approve a pending plan and start execution (#19)
-            const approveMsg = parts.length > 1
-                ? `Plan approved with notes: ${parts.slice(1).join(' ')}. Execute it step by step, updating progress as you complete each step.`
-                : 'Plan approved. Execute it step by step, updating progress as you complete each step.';
-            // Switch to work mode for execution
-            ctx.setMode('work');
-            ctx.addMessage('system', `${MODE_CONFIG['work'].icon} Switched to work mode for plan execution`);
-            // Send approval as user message to the agent
-            ctx.addMessage('user', approveMsg);
-            await ctx.runAgent(approveMsg);
-            break;
-        }
         case '/resume': {
             // Resume a session by loading saved LLM message history
             // Usage: /resume [sessionId] - resume a specific session, or current session if no ID
@@ -2684,7 +980,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                     ctx.llmMessages.current.length = 0;
                     ctx.llmMessages.current.push({
                         role: 'system',
-                        content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)),
+                        content: buildFullSystemPrompt(getActiveProjectDir(ctx), ctx.actualProvider),
                     });
                     for (const msg of history) {
                         if (msg.role === 'user' || msg.role === 'assistant') {
@@ -2700,644 +996,22 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             }
             break;
         }
-        // ================================================================
-        // Circuit Breaker
-        // ================================================================
-        case '/breaker':
-        case '/cb': {
-            const subCmd = parts[1];
-            if (!ctx.circuitBreaker) {
-                ctx.addMessage('system', 'Circuit breakers not initialized. They activate automatically during agent runs.');
-                break;
-            }
-            if (subCmd === 'status' || !subCmd) {
-                const statuses = ctx.circuitBreaker.getStatus();
-                const stats = ctx.circuitBreaker.getTrackingStats();
-                const health = ctx.circuitBreaker.getHealth();
-                let msg = `Circuit Breaker Health: ${health.toUpperCase()}\n\n`;
-                for (const s of statuses) {
-                    const icon = s.state === 'open' ? '\u{1f534}' : s.state === 'half-open' ? '\u{1f7e1}' : '\u{1f7e2}';
-                    msg += `${icon} ${s.type}: ${s.state} (tripped ${s.tripCount}x)`;
-                    if (s.lastEvent)
-                        msg += ` - ${s.lastEvent.message}`;
-                    msg += '\n';
-                }
-                msg += `\nTracking: ${stats.consecutiveErrors} consecutive errors, ${stats.totalTokens.toLocaleString()} total tokens, $${stats.totalCost.toFixed(2)} cost, ${stats.idleCount} idle`;
-                ctx.addMessage('system', msg);
-            }
-            else if (subCmd === 'resume') {
-                const breakerType = parts[2];
-                ctx.circuitBreaker.resume(breakerType);
-                ctx.setBreakerHealth(ctx.circuitBreaker.getHealth());
-                ctx.addMessage('system', `\u2713 Circuit breaker${breakerType ? ` "${breakerType}"` : 's'} resumed (half-open mode, 50% more generous thresholds)`);
-            }
-            else if (subCmd === 'reset') {
-                const breakerType = parts[2];
-                ctx.circuitBreaker.reset(breakerType);
-                ctx.setBreakerHealth(ctx.circuitBreaker.getHealth());
-                ctx.addMessage('system', `\u2713 Circuit breaker${breakerType ? ` "${breakerType}"` : 's'} reset to closed`);
-            }
-            else if (subCmd === 'off') {
-                config.set('circuitBreakersEnabled', false);
-                // Also disable the current circuit breaker instance if it exists
-                if (ctx.circuitBreaker) {
-                    ctx.circuitBreaker = undefined;
-                    ctx.setBreakerHealth?.('ok');
-                }
-                ctx.addMessage('system', '\u2713 Circuit breakers disabled');
-            }
-            else if (subCmd === 'on') {
-                config.set('circuitBreakersEnabled', true);
-                ctx.addMessage('system', '\u2713 Circuit breakers enabled');
-            }
-            else if (subCmd === 'adjust') {
-                const breakerTypeString = parts[2];
-                const param = parts[3];
-                const rawValue = parts[4];
-                // Handle special 'list' command to show detailed parameter info
-                if (breakerTypeString === 'list') {
-                    ctx.addMessage('system', `Circuit Breaker Configuration Reference:
-
-📊 REPEATED-FAILURE (Consecutive Errors)
-  • maxConsecutiveErrors: Number of consecutive errors before tripping (default: 3)
-  Example: /breaker adjust repeated-failure maxConsecutiveErrors 5
-
-💰 COST-RUNAWAY (Spending Control)
-  • maxSessionCost: Maximum total cost per session in USD (default: $5.0)
-  • maxCostPerMinute: Maximum spending rate per minute in USD (default: $1.0)
-  • windowSizeMs: Sliding window size for rate calculation in milliseconds (default: 60000)
-  Examples:
-    /breaker adjust cost-runaway maxSessionCost 10.0
-    /breaker adjust cost-runaway maxCostPerMinute 2.0
-
-🔄 INFINITE-LOOP (Repetitive Behavior)
-  • maxIdenticalInWindow: Max identical tool calls in window before tripping (default: 3)
-  • windowSize: Number of recent tool calls to analyze (default: 6)
-  • detectOscillation: Detect A-B-A-B oscillation patterns (default: true)
-  Examples:
-    /breaker adjust infinite-loop maxIdenticalInWindow 5
-    /breaker adjust infinite-loop detectOscillation false
-
-🔥 TOKEN-BURN (Token Usage Limits)
-  • maxTokensPerIteration: Max tokens per single iteration (default: 200,000)
-  • maxTotalTokens: Max total tokens per session (default: 5,000,000)
-  Examples:
-    /breaker adjust token-burn maxTokensPerIteration 100000
-    /breaker adjust token-burn maxTotalTokens 1000000
-
-⏸️  STALL (Progress Detection)
-  • maxIdleIterations: Max iterations with no tool calls/content (default: 5)
-  Example: /breaker adjust stall maxIdleIterations 3
-
-⏰ WALL-CLOCK (Time Limits)
-  • maxSessionDurationMs: Max session duration in milliseconds (0 = unlimited, default: 0)
-  • maxIterationDurationMs: Max single iteration duration in milliseconds (default: 600000 = 10 min)
-  Examples:
-    /breaker adjust wall-clock maxSessionDurationMs 3600000  # 1 hour
-    /breaker adjust wall-clock maxIterationDurationMs 300000  # 5 minutes
-
-Quick Commands:
-  /breaker adjust <type>              - Show current settings for that type
-  /breaker adjust                     - Show types overview
-  /breaker status                     - Show current breaker states`);
-                    break;
-                }
-                // Show basic types overview if no type specified
-                if (!breakerTypeString) {
-                    ctx.addMessage('system', `Circuit Breaker Types Available for Configuration:
-
-  repeated-failure  - Consecutive errors before tripping
-  cost-runaway      - Spending rate and total cost limits  
-  infinite-loop     - Identical tool calls and oscillation detection
-  token-burn        - Token usage per iteration and total limits
-  stall             - Idle iterations without progress
-  wall-clock        - Time-based session and iteration limits
-
-Usage: /breaker adjust <type> [param] [value]
-       /breaker adjust list                   - Show detailed parameter reference
-
-Examples:
-  /breaker adjust repeated-failure          - Show current settings
-  /breaker adjust cost-runaway maxSessionCost 10.0
-  /breaker adjust infinite-loop detectOscillation true`);
-                    break;
-                }
-                // Cast to BreakerType and validate
-                const breakerType = breakerTypeString;
-                const validTypes = ['repeated-failure', 'cost-runaway', 'infinite-loop', 'token-burn', 'stall', 'wall-clock'];
-                if (!validTypes.includes(breakerType)) {
-                    ctx.addMessage('error', `Invalid breaker type "${breakerType}". Valid types: ${validTypes.join(', ')}`);
-                    break;
-                }
-                const currentConfig = ctx.circuitBreaker.getConfig();
-                const breakerConfig = currentConfig.breakers[breakerType];
-                // Show current configuration if no param specified
-                if (!param) {
-                    let configDisplay = `${breakerType} Circuit Breaker Settings:\n`;
-                    switch (breakerType) {
-                        case 'repeated-failure':
-                            configDisplay += `  maxConsecutiveErrors: ${breakerConfig.maxConsecutiveErrors} errors\n\nUsage: /breaker adjust repeated-failure <param> <value>\n  /breaker adjust repeated-failure maxConsecutiveErrors <number>`;
-                            break;
-                        case 'cost-runaway':
-                            configDisplay += `  maxSessionCost: ${breakerConfig.maxSessionCost} per session\n  maxCostPerMinute: ${breakerConfig.maxCostPerMinute} per minute\n  windowSizeMs: ${breakerConfig.windowSizeMs}ms\n\nUsage: /breaker adjust cost-runaway <param> <value>\n  /breaker adjust cost-runaway maxSessionCost <dollars>\n  /breaker adjust cost-runaway maxCostPerMinute <dollars>\n  /breaker adjust cost-runaway windowSizeMs <milliseconds>`;
-                            break;
-                        case 'infinite-loop':
-                            configDisplay += `  maxIdenticalInWindow: ${breakerConfig.maxIdenticalInWindow} calls\n  windowSize: ${breakerConfig.windowSize} recent calls\n  detectOscillation: ${breakerConfig.detectOscillation}\n\nUsage: /breaker adjust infinite-loop <param> <value>\n  /breaker adjust infinite-loop maxIdenticalInWindow <number>\n  /breaker adjust infinite-loop windowSize <number>\n  /breaker adjust infinite-loop detectOscillation <true|false>`;
-                            break;
-                        case 'token-burn':
-                            configDisplay += `  maxTokensPerIteration: ${breakerConfig.maxTokensPerIteration.toLocaleString()} tokens\n  maxTotalTokens: ${breakerConfig.maxTotalTokens.toLocaleString()} tokens\n\nUsage: /breaker adjust token-burn <param> <value>\n  /breaker adjust token-burn maxTokensPerIteration <number>\n  /breaker adjust token-burn maxTotalTokens <number>`;
-                            break;
-                        case 'stall':
-                            configDisplay += `  maxIdleIterations: ${breakerConfig.maxIdleIterations} iterations\n\nUsage: /breaker adjust stall <param> <value>\n  /breaker adjust stall maxIdleIterations <number>`;
-                            break;
-                        case 'wall-clock':
-                            const sessionDuration = breakerConfig.maxSessionDurationMs;
-                            const iterationDuration = breakerConfig.maxIterationDurationMs;
-                            configDisplay += `  maxSessionDurationMs: ${sessionDuration === 0 ? 'unlimited' : sessionDuration + 'ms'}\n  maxIterationDurationMs: ${iterationDuration}ms (${Math.round(iterationDuration / 60000)} minutes)\n\nUsage: /breaker adjust wall-clock <param> <value>\n  /breaker adjust wall-clock maxSessionDurationMs <milliseconds>\n  /breaker adjust wall-clock maxIterationDurationMs <milliseconds>`;
-                            break;
-                    }
-                    ctx.addMessage('system', configDisplay);
-                    break;
-                }
-                // Parse and validate the value
-                let parsedValue;
-                // Handle boolean parameters
-                if (param === 'detectOscillation') {
-                    if (rawValue === 'true')
-                        parsedValue = true;
-                    else if (rawValue === 'false')
-                        parsedValue = false;
-                    else {
-                        ctx.addMessage('error', 'detectOscillation must be "true" or "false"');
-                        break;
-                    }
-                }
-                else {
-                    // Handle numeric parameters
-                    parsedValue = parseFloat(rawValue);
-                    if (isNaN(parsedValue) || parsedValue < 0) {
-                        ctx.addMessage('error', 'Value must be a non-negative number');
-                        break;
-                    }
-                }
-                // Validate parameter names for each breaker type
-                const paramValidations = {
-                    'repeated-failure': {
-                        params: ['maxConsecutiveErrors'],
-                        validate: (param, value) => value <= 0 ? 'maxConsecutiveErrors must be > 0' : null
-                    },
-                    'cost-runaway': {
-                        params: ['maxSessionCost', 'maxCostPerMinute', 'windowSizeMs'],
-                        validate: (param, value) => value <= 0 ? `${param} must be > 0` : null
-                    },
-                    'infinite-loop': {
-                        params: ['maxIdenticalInWindow', 'windowSize', 'detectOscillation'],
-                        validate: (param, value) => {
-                            if (param === 'detectOscillation')
-                                return null; // boolean is already validated above
-                            return value <= 0 ? `${param} must be > 0` : null;
-                        }
-                    },
-                    'token-burn': {
-                        params: ['maxTokensPerIteration', 'maxTotalTokens'],
-                        validate: (param, value) => value <= 0 ? `${param} must be > 0` : null
-                    },
-                    'stall': {
-                        params: ['maxIdleIterations'],
-                        validate: (param, value) => value <= 0 ? 'maxIdleIterations must be > 0' : null
-                    },
-                    'wall-clock': {
-                        params: ['maxSessionDurationMs', 'maxIterationDurationMs'],
-                        validate: (param, value) => {
-                            if (param === 'maxSessionDurationMs' && value === 0)
-                                return null; // 0 = unlimited is valid
-                            return value < 0 ? `${param} cannot be negative` : null;
-                        }
-                    }
-                };
-                const validation = paramValidations[breakerType];
-                if (!validation.params.includes(param)) {
-                    ctx.addMessage('error', `Invalid parameter "${param}" for ${breakerType}. Valid parameters: ${validation.params.join(', ')}`);
-                    break;
-                }
-                // Run custom validation if provided
-                if (validation.validate) {
-                    const error = validation.validate(param, parsedValue);
-                    if (error) {
-                        ctx.addMessage('error', error);
-                        break;
-                    }
-                }
-                // Update the configuration
-                const oldValue = breakerConfig[param];
-                ctx.circuitBreaker.adjust(breakerType, { [param]: parsedValue });
-                // Format the success message based on parameter type
-                let formattedOld, formattedNew;
-                if (param === 'detectOscillation') {
-                    formattedOld = String(oldValue);
-                    formattedNew = String(parsedValue);
-                }
-                else if (param.includes('Cost')) {
-                    formattedOld = `${oldValue}`;
-                    formattedNew = `${parsedValue}`;
-                }
-                else if (param.includes('Ms')) {
-                    formattedOld = oldValue === 0 ? 'unlimited' : `${oldValue}ms`;
-                    formattedNew = parsedValue === 0 ? 'unlimited' : `${parsedValue}ms`;
-                }
-                else if (param.includes('Tokens')) {
-                    formattedOld = oldValue.toLocaleString();
-                    formattedNew = parsedValue.toLocaleString();
-                }
-                else {
-                    formattedOld = String(oldValue);
-                    formattedNew = String(parsedValue);
-                }
-                ctx.addMessage('system', `✅ ${breakerType} ${param}: ${formattedOld} → ${formattedNew}`);
-            }
-            else {
-                ctx.addMessage('system', `Usage: /breaker [status|resume|reset|adjust|on|off]
-  /breaker resume [type]  - Resume tripped breaker (half-open)
-  /breaker reset [type]   - Reset breaker to closed
-  /breaker adjust [type] [param] [value] - Configure breaker thresholds
-  /breaker on|off         - Enable/disable circuit breakers
-
-Breaker types: repeated-failure, cost-runaway, infinite-loop, token-burn, stall, wall-clock
-
-Quick help:
-  /breaker adjust         - Show types overview
-  /breaker adjust list    - Show detailed parameter reference`);
-            }
-            break;
-        }
-        // ================================================================
-        // Smart Routing
-        // ================================================================
-        case '/smart': {
-            const subCmd = parts[1];
-            if (subCmd === 'on') {
-                ctx.setSmartRouteActive(true);
-                config.set('smartRoutingEnabled', true);
-                ctx.addMessage('system', '\u2713 Smart routing ON - best model selected across all providers');
-            }
-            else if (subCmd === 'off') {
-                ctx.setSmartRouteActive(false);
-                config.set('smartRoutingEnabled', false);
-                ctx.addMessage('system', '\u2713 Smart routing OFF - using fixed provider/model');
-            }
-            else if (subCmd === 'cost' && parts[2]) {
-                const sensitivity = parseFloat(parts[2]);
-                if (isNaN(sensitivity) || sensitivity < 0 || sensitivity > 1) {
-                    ctx.addMessage('error', 'Cost sensitivity must be between 0 (best quality) and 1 (cheapest)');
-                }
-                else {
-                    config.set('smartRoutingCostSensitivity', sensitivity);
-                    ctx.addMessage('system', `\u2713 Smart routing cost sensitivity set to ${sensitivity} (0=quality, 1=cost)`);
-                }
-            }
-            else if (subCmd === 'test' && parts[2]) {
-                const testMsg = parts.slice(2).join(' ');
-                const routingConfig = ctx.smartRoutingConfig || {
-                    ...getDefaultSmartRoutingConfig(),
-                    enabled: true,
-                    costSensitivity: config.get('smartRoutingCostSensitivity') ?? 0.3,
-                };
-                const decision = smartRoute(testMsg, routingConfig);
-                const taskInfo = detectTaskType(testMsg);
-                let msg = `Smart Route Test:\n`;
-                msg += `  Task type: ${taskInfo.taskType} (${Math.round(taskInfo.confidence * 100)}% confidence)\n`;
-                msg += `  Complexity: ${decision.complexity}\n`;
-                msg += `  Selected: ${decision.selected.provider}/${decision.selected.model} (${decision.selected.tier} tier)\n`;
-                msg += `  Score: ${(decision.selected.score * 100).toFixed(1)}\n`;
-                if (decision.alternatives.length > 0) {
-                    msg += `  Alternatives:\n`;
-                    for (const alt of decision.alternatives.slice(0, 3)) {
-                        msg += `    - ${alt.provider}/${alt.model} (score: ${(alt.score * 100).toFixed(1)})\n`;
-                    }
-                }
-                ctx.addMessage('system', msg);
-            }
-            else {
-                ctx.addMessage('system', `Smart routing: ${ctx.smartRouteActive ? 'ON' : 'OFF'}
-Cost sensitivity: ${config.get('smartRoutingCostSensitivity') ?? 0.3}
-
-Usage: /smart [on|off|cost <0-1>|test <message>]
-  /smart on            - Enable cross-provider routing
-  /smart off           - Disable, use fixed provider
-  /smart cost <0-1>    - Set cost sensitivity (0=quality, 1=cheapest)
-  /smart test <msg>    - Test routing decision for a message`);
-            }
-            break;
-        }
-        // ================================================================
-        // Swarm Mode
-        // ================================================================
-        case '/swarm':
-        case '/council': {
-            const subCmd = parts[1];
-            const swarmCwd = ctx.sessionRef.current?.projectPath ?? process.cwd();
-            if (!ctx.agtermEnabled) {
-                ctx.addMessage('system', 'Agents mode not enabled. Start with --agents flag to use agent swarms.');
-                break;
-            }
-            // /swarm coordinate — multi-agent coordination (formerly /council)
-            if (subCmd === 'coordinate' || subCmd === 'coord') {
-                const coordSubCmd = parts[2];
-                if (coordSubCmd === 'templates') {
-                    const templates = Object.values(COUNCIL_TEMPLATES);
-                    let msg = 'Swarm Coordination Templates:\n';
-                    for (const t of templates) {
-                        msg += `\n  ${t.name} - ${t.description}`;
-                        msg += `\n    Mode: ${t.mode}, Agents: ${t.members.map(m => m.name).join(', ')}`;
-                    }
-                    ctx.addMessage('system', msg);
-                }
-                else if (coordSubCmd === 'status') {
-                    const sessionId = parts[3];
-                    if (sessionId) {
-                        const session = councilManager.getAllSessions().find(s => s.id.startsWith(sessionId));
-                        if (session) {
-                            let msg = councilManager.formatSessionStatus(session);
-                            if (session.status === 'completed' && session.result) {
-                                msg += `\n\nResult:\n${session.result.slice(0, 500)}${(session.result.length > 500) ? '...' : ''}`;
-                            }
-                            ctx.addMessage('system', msg);
-                        }
-                        else {
-                            ctx.addMessage('system', `Coordination session not found: ${sessionId}`);
-                        }
-                    }
-                    else {
-                        const sessions = councilManager.getAllSessions();
-                        if (sessions.length === 0) {
-                            ctx.addMessage('system', 'No coordination sessions.');
-                        }
-                        else {
-                            const lines = sessions.map(s => `  ${s.id.slice(0, 8)} [${s.config.mode}] ${s.status} - ${s.prompt.slice(0, 50)}`);
-                            ctx.addMessage('system', `Coordination Sessions:\n${lines.join('\n')}`);
-                        }
-                    }
-                }
-                else if (coordSubCmd === 'list') {
-                    const sessions = councilManager.getAllSessions();
-                    const stats = councilManager.getStats();
-                    let msg = `Coordination Stats: ${stats.totalSessions} total, ${stats.activeSessions} active, ${stats.completedSessions} completed, ${stats.failedSessions} failed\n`;
-                    for (const s of sessions) {
-                        msg += `\n  ${s.id.slice(0, 8)} [${s.config.mode}] ${s.status} - ${s.prompt.slice(0, 60)}`;
-                    }
-                    ctx.addMessage('system', msg);
-                }
-                else if (coordSubCmd === 'cancel' && parts[3]) {
-                    const session = councilManager.getAllSessions().find(s => s.id.startsWith(parts[3]));
-                    if (session) {
-                        await councilManager.cancelCouncil(session.id);
-                        ctx.addMessage('system', `\u2713 Coordination ${parts[3]} cancelled.`);
-                    }
-                    else {
-                        ctx.addMessage('system', `Coordination session not found: ${parts[3]}`);
-                    }
-                }
-                else if (coordSubCmd && !['help'].includes(coordSubCmd)) {
-                    // /swarm coordinate <objective>
-                    const prompt = parts.slice(2).join(' ');
-                    let cleanPrompt = prompt;
-                    let template;
-                    let mode = 'competitive';
-                    const templateMatch = prompt.match(/--template\s+(\S+)/);
-                    if (templateMatch) {
-                        template = templateMatch[1];
-                        cleanPrompt = cleanPrompt.replace(templateMatch[0], '').trim();
-                    }
-                    const modeMatch = prompt.match(/--mode\s+(competitive|collaborative|consensus|overseer)/);
-                    if (modeMatch) {
-                        mode = modeMatch[1];
-                        cleanPrompt = cleanPrompt.replace(modeMatch[0], '').trim();
-                    }
-                    try {
-                        let session;
-                        if (template) {
-                            session = await councilManager.startFromTemplate(template, cleanPrompt, swarmCwd);
-                        }
-                        else {
-                            const { randomUUID } = await import('crypto');
-                            const members = [
-                                { id: randomUUID(), name: 'Agent A', agent: 'claude', weight: 1.0 },
-                                { id: randomUUID(), name: 'Agent B', agent: 'claude', weight: 1.0 },
-                                { id: randomUUID(), name: 'Agent C', agent: 'claude', weight: 1.0 },
-                            ];
-                            session = await councilManager.startCouncil(cleanPrompt, { mode, members }, swarmCwd);
-                        }
-                        watchAsyncLedgerRun(ctx.ledger, 'council', cleanPrompt, () => councilManager.getSession(session.id));
-                        ctx.addMessage('system', `\u2713 Swarm coordination started: ${session.id.slice(0, 8)}\nMode: ${session.config.mode}\nAgents: ${session.config.members.map(m => m.name).join(', ')}\n\nUse /swarm coord status ${session.id.slice(0, 8)} to check progress.`);
-                    }
-                    catch (err) {
-                        ctx.addMessage('error', `Failed to start coordination: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-                else {
-                    ctx.addMessage('system', `Swarm Coordination: Multi-agent teams working toward shared objectives.
-
-Modes:
-  competitive    — Agents work independently, best result wins
-  collaborative  — Pipeline: each agent builds on previous work
-  consensus      — Agents vote on approach, supermajority decides
-  overseer       — Lead decomposes, delegates, reviews, coordinates
-
-Usage:
-  /swarm coord <objective>               Start with default competitive mode
-  /swarm coord <objective> [options]     Start with explicit options
-  /swarm coord status [id]               Show session status
-  /swarm coord list                      List all sessions
-  /swarm coord templates                 Show available templates
-  /swarm coord cancel <id>               Cancel a running session
-
-Options:
-  --template code-review|architecture|security-audit|brainstorm|debate
-  --mode competitive|collaborative|consensus|overseer`);
-                }
-            }
-            else if (subCmd === 'templates') {
-                // Shortcut: /swarm templates → show coordination templates
-                const templates = Object.values(COUNCIL_TEMPLATES);
-                let msg = 'Swarm Coordination Templates:\n';
-                for (const t of templates) {
-                    msg += `\n  ${t.name} - ${t.description}`;
-                    msg += `\n    Mode: ${t.mode}, Agents: ${t.members.map(m => m.name).join(', ')}`;
-                }
-                ctx.addMessage('system', msg);
-            }
-            else if (subCmd === 'start' || (subCmd && !['status', 'list', 'cancel', 'templates', 'coordinate', 'coord', 'help'].includes(subCmd))) {
-                // /swarm start <prompt> or /swarm <prompt> — task decomposition
-                const promptStart = subCmd === 'start' ? 2 : 1;
-                const prompt = parts.slice(promptStart).join(' ');
-                if (!prompt) {
-                    ctx.addMessage('system', 'Usage: /swarm <task description>\n  /swarm start <task> [--strategy parallel|sequential|map-reduce|pipeline] [--aggregation concatenate|merge-dedupe|summarize|structured]');
-                    break;
-                }
-                let strategy = 'parallel';
-                let aggregation = 'concatenate';
-                let cleanPrompt = prompt;
-                const strategyMatch = prompt.match(/--strategy\s+(parallel|sequential|map-reduce|pipeline)/);
-                if (strategyMatch) {
-                    strategy = strategyMatch[1];
-                    cleanPrompt = cleanPrompt.replace(strategyMatch[0], '').trim();
-                }
-                const aggMatch = prompt.match(/--aggregation\s+(concatenate|merge-dedupe|summarize|structured)/);
-                if (aggMatch) {
-                    aggregation = aggMatch[1];
-                    cleanPrompt = cleanPrompt.replace(aggMatch[0], '').trim();
-                }
-                try {
-                    const session = await swarmManager.startSwarm(cleanPrompt, { decomposition: strategy, aggregation }, swarmCwd);
-                    watchAsyncLedgerRun(ctx.ledger, 'swarm', cleanPrompt, () => swarmManager.getSession(session.id));
-                    ctx.addMessage('system', `\u2713 Swarm started: ${session.id.slice(0, 8)}\nStrategy: ${strategy} \u2192 ${aggregation}\nStatus: ${session.status}\n\nUse /swarm status ${session.id.slice(0, 8)} to check progress.`);
-                }
-                catch (err) {
-                    ctx.addMessage('error', `Failed to start swarm: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            else if (subCmd === 'status') {
-                // Show both swarm and coordination sessions
-                const sessionId = parts[2];
-                if (sessionId) {
-                    // Check decomposition swarms first, then coordination
-                    const swarmSession = swarmManager.getAllSessions().find(s => s.id.startsWith(sessionId));
-                    const coordSession = councilManager.getAllSessions().find(s => s.id.startsWith(sessionId));
-                    if (swarmSession) {
-                        let msg = swarmManager.formatSessionStatus(swarmSession);
-                        if (swarmSession.status === 'completed' && swarmSession.result) {
-                            msg += `\n\nResult:\n${swarmSession.result.slice(0, 500)}${(swarmSession.result.length > 500) ? '...' : ''}`;
-                        }
-                        ctx.addMessage('system', msg);
-                    }
-                    else if (coordSession) {
-                        let msg = councilManager.formatSessionStatus(coordSession);
-                        if (coordSession.status === 'completed' && coordSession.result) {
-                            msg += `\n\nResult:\n${coordSession.result.slice(0, 500)}${(coordSession.result.length > 500) ? '...' : ''}`;
-                        }
-                        ctx.addMessage('system', msg);
-                    }
-                    else {
-                        ctx.addMessage('system', `Swarm session not found: ${sessionId}`);
-                    }
-                }
-                else {
-                    const swarmSessions = swarmManager.getAllSessions();
-                    const coordSessions = councilManager.getAllSessions();
-                    if (swarmSessions.length === 0 && coordSessions.length === 0) {
-                        ctx.addMessage('system', 'No swarm sessions.');
-                    }
-                    else {
-                        const lines = [];
-                        for (const s of swarmSessions) {
-                            const subtaskInfo = s.subtasks.length > 0
-                                ? ` (${s.subtasks.filter(st => st.status === 'completed').length}/${s.subtasks.length} done)`
-                                : '';
-                            lines.push(`  ${s.id.slice(0, 8)} [decompose] ${s.status}${subtaskInfo} - ${s.prompt.slice(0, 50)}`);
-                        }
-                        for (const s of coordSessions) {
-                            lines.push(`  ${s.id.slice(0, 8)} [${s.config.mode}] ${s.status} - ${s.prompt.slice(0, 50)}`);
-                        }
-                        ctx.addMessage('system', `Swarm Sessions:\n${lines.join('\n')}`);
-                    }
-                }
-            }
-            else if (subCmd === 'list') {
-                const swarmSessions = swarmManager.getAllSessions();
-                const swarmStats = swarmManager.getStats();
-                const coordSessions = councilManager.getAllSessions();
-                const coordStats = councilManager.getStats();
-                let msg = `Decomposition: ${swarmStats.totalSessions} total, ${swarmStats.activeSessions} active, ${swarmStats.completedSessions} completed\n`;
-                msg += `Coordination: ${coordStats.totalSessions} total, ${coordStats.activeSessions} active, ${coordStats.completedSessions} completed\n`;
-                for (const s of swarmSessions) {
-                    msg += `\n  ${s.id.slice(0, 8)} [decompose] ${s.status} - ${s.prompt.slice(0, 60)}`;
-                }
-                for (const s of coordSessions) {
-                    msg += `\n  ${s.id.slice(0, 8)} [${s.config.mode}] ${s.status} - ${s.prompt.slice(0, 60)}`;
-                }
-                ctx.addMessage('system', msg);
-            }
-            else if (subCmd === 'cancel' && parts[2]) {
-                const swarmSession = swarmManager.getAllSessions().find(s => s.id.startsWith(parts[2]));
-                const coordSession = councilManager.getAllSessions().find(s => s.id.startsWith(parts[2]));
-                if (swarmSession) {
-                    await swarmManager.cancelSwarm(swarmSession.id);
-                    ctx.addMessage('system', `\u2713 Swarm ${parts[2]} cancelled.`);
-                }
-                else if (coordSession) {
-                    await councilManager.cancelCouncil(coordSession.id);
-                    ctx.addMessage('system', `\u2713 Coordination ${parts[2]} cancelled.`);
-                }
-                else {
-                    ctx.addMessage('system', `Swarm session not found: ${parts[2]}`);
-                }
-            }
-            else {
-                ctx.addMessage('system', `Agent Swarms: Decompose tasks and coordinate multi-agent teams.
-
-Decomposition (parallel workers):
-  /swarm <task>                          Decompose and execute in parallel
-  /swarm start <task> [options]          Start with explicit strategy
-
-Coordination (multi-agent teamwork):
-  /swarm coord <objective>               Start coordinated agents
-  /swarm coord <objective> [options]     Start with explicit mode
-  /swarm coord templates                 Show coordination templates
-
-Management:
-  /swarm status [id]                     Show session status
-  /swarm list                            List all sessions
-  /swarm cancel <id>                     Cancel a session
-
-Decomposition options:
-  --strategy parallel|sequential|map-reduce|pipeline
-  --aggregation concatenate|merge-dedupe|summarize|structured
-
-Coordination options:
-  --mode competitive|collaborative|consensus|overseer
-  --template code-review|architecture|security-audit|brainstorm|debate
-
-Requires --agents flag.`);
-            }
-            break;
-        }
-        case '/checkpoint':
-        case '/cp': {
-            const { listCheckpoints, clearCheckpoints } = await import('../checkpoint.js');
-            const cpSubCmd = parts[1] || 'list';
-            if (cpSubCmd === 'list') {
-                const filterPath = parts[2];
-                const checkpoints = listCheckpoints(filterPath);
+        case '/restore': {
+            const { restoreFromCheckpoint, listCheckpoints } = await import('../checkpoint.js');
+            const restorePath = parts[1];
+            if (!restorePath) {
+                // No arg: list available checkpoints (absorbs the old /checkpoint list)
+                const checkpoints = listCheckpoints();
                 if (checkpoints.length === 0) {
-                    ctx.addMessage('system', filterPath
-                        ? `No checkpoints found for: ${filterPath}`
-                        : 'No checkpoints found. Checkpoints are created automatically when files are overwritten.');
+                    ctx.addMessage('system', 'No checkpoints found. Checkpoints are created automatically (as git commits) before destructive tool calls, and require a git repository.');
                 }
                 else {
                     const list = checkpoints.slice(0, 20).map((cp, i) => {
-                        const relPath = path.relative(process.cwd(), cp.filePath);
                         const time = new Date(cp.timestamp).toLocaleString();
-                        const size = cp.size > 1024 ? `${(cp.size / 1024).toFixed(1)}KB` : `${cp.size}B`;
-                        return `  ${i}. ${relPath} (${size}) - ${time}`;
+                        return `  ${i}. ${cp.hash} ${cp.subject} - ${time}`;
                     }).join('\n');
-                    ctx.addMessage('system', `Checkpoints (newest first):\n${list}${checkpoints.length > 20 ? `\n  ... and ${checkpoints.length - 20} more` : ''}`);
+                    ctx.addMessage('system', `Checkpoints (newest first):\n${list}${checkpoints.length > 20 ? `\n  ... and ${checkpoints.length - 20} more` : ''}\n\nUse /restore <path> [index] to restore a file.`);
                 }
-            }
-            else if (cpSubCmd === 'clear') {
-                const days = parts[2] ? parseInt(parts[2]) : undefined;
-                const removed = clearCheckpoints(days);
-                ctx.addMessage('system', `Cleared ${removed} checkpoint${removed !== 1 ? 's' : ''}${days ? ` older than ${days} days` : ''}.`);
-            }
-            else {
-                ctx.addMessage('system', 'Usage: /checkpoint [list|clear]\n  /checkpoint list [path] - list checkpoints\n  /checkpoint clear [days] - clear old checkpoints\n  /restore <path> [index] - restore a file');
-            }
-            break;
-        }
-        case '/restore': {
-            const { restoreCheckpoint, listCheckpoints } = await import('../checkpoint.js');
-            const restorePath = parts[1];
-            if (!restorePath) {
-                ctx.addMessage('error', 'Usage: /restore <path> [index]\n  Restores a file from its most recent checkpoint.\n  Use /checkpoint list to see available checkpoints.');
                 break;
             }
             const idx = parts[2] ? parseInt(parts[2]) : 0;
@@ -3347,174 +1021,17 @@ Requires --agents flag.`);
                 ctx.addMessage('error', `No checkpoints found for: ${restorePath}`);
                 break;
             }
-            const restored = restoreCheckpoint(absRestorePath, idx);
+            const restored = restoreFromCheckpoint(absRestorePath, idx);
             if (restored !== undefined) {
                 const relPath = path.relative(process.cwd(), absRestorePath);
                 const cp = checkpoints[idx];
-                ctx.addMessage('system', `✓ Restored ${relPath} from checkpoint (${new Date(cp.timestamp).toLocaleString()})`);
+                ctx.addMessage('system', `✓ Restored ${relPath} from checkpoint ${cp.hash} (${new Date(cp.timestamp).toLocaleString()})`);
             }
             else {
                 ctx.addMessage('error', `Failed to restore: checkpoint index ${idx} not found for ${restorePath}`);
             }
             break;
         }
-        // ================================================================
-        // Background Jobs
-        // ================================================================
-        case '/bg': {
-            const bgPrompt = parts.slice(1).join(' ');
-            if (!bgPrompt) {
-                ctx.addMessage('error', 'Usage: /bg <prompt> — run a task in the background');
-                break;
-            }
-            const bgJob = createJob(bgPrompt, { provider: ctx.actualProvider, model: ctx.actualModel });
-            ctx.addMessage('system', `Background job ${bgJob.id} created: "${bgPrompt.length > 60 ? bgPrompt.slice(0, 57) + '...' : bgPrompt}"`);
-            // Run the job using the agent
-            runJob(bgJob.id, async (prompt, signal) => {
-                const { chat } = await import('../providers/index.js');
-                const { TOOLS } = await import('../tools.js');
-                const { executeTool: execTool } = await import('../tools.js');
-                const cwd = ctx.sessionRef.current?.projectPath || process.cwd();
-                const maxIterations = resolveIterationLimit(config.get('maxIterations'));
-                const bgMessages = [
-                    { role: 'system', content: buildFullSystemPrompt(ctx.persona, cwd) },
-                    { role: 'user', content: prompt },
-                ];
-                let iterations = 0;
-                let lastContent = '';
-                while (!signal.aborted && iterations < maxIterations) {
-                    iterations++;
-                    const response = await chat(ctx.provider, bgMessages, TOOLS, ctx.model);
-                    if (!response.toolCalls?.length) {
-                        lastContent = response.content;
-                        break;
-                    }
-                    bgMessages.push({ role: 'assistant', content: response.content, toolCalls: response.toolCalls });
-                    for (const tc of response.toolCalls) {
-                        const result = await execTool(tc, cwd);
-                        bgMessages.push({ role: 'tool', content: result.result, toolCallId: tc.id });
-                        if (signal.aborted)
-                            break;
-                    }
-                }
-                if (signal.aborted) {
-                    const error = new Error('Background job cancelled');
-                    error.name = 'AbortError';
-                    throw error;
-                }
-                return { result: lastContent, iterations };
-            }).then(completed => {
-                ctx.addMessage('system', `Background job ${completed.id} ${completed.status}: ${completed.result?.slice(0, 200) || completed.error || 'done'}`);
-            }).catch(() => { });
-            break;
-        }
-        case '/jobs': {
-            ctx.addMessage('system', formatJobsList());
-            break;
-        }
-        case '/job': {
-            const jobId = parts[1];
-            if (!jobId) {
-                ctx.addMessage('error', 'Usage: /job <id> — show job details');
-                break;
-            }
-            const jobInfo = getJob(jobId);
-            if (!jobInfo) {
-                ctx.addMessage('error', `Job "${jobId}" not found.`);
-            }
-            else {
-                ctx.addMessage('system', formatJob(jobInfo) + (jobInfo.result ? `\n\nResult:\n${jobInfo.result.slice(0, 2000)}` : ''));
-            }
-            break;
-        }
-        case '/cancel': {
-            const cancelId = parts[1];
-            if (!cancelId) {
-                ctx.addMessage('error', 'Usage: /cancel <job-id>');
-                break;
-            }
-            const cancelled = cancelJob(cancelId);
-            ctx.addMessage('system', cancelled ? `Cancelled job ${cancelId}` : `Could not cancel ${cancelId} (not running or not found)`);
-            break;
-        }
-        case '/clear-jobs': {
-            const cleared = clearFinishedJobs();
-            ctx.addMessage('system', cleared > 0 ? `Cleared ${cleared} finished job(s).` : 'No finished jobs to clear.');
-            break;
-        }
-        // ================================================================
-        // Recordings
-        // ================================================================
-        case '/recordings': {
-            const recs = listRecordings();
-            if (recs.length === 0) {
-                ctx.addMessage('system', 'No recordings found.');
-            }
-            else {
-                const lines = recs.slice(0, 20).map(r => {
-                    const dur = r.duration > 0 ? ` (${Math.floor(r.duration / 60000)}m${Math.floor((r.duration % 60000) / 1000)}s)` : '';
-                    return `  ${r.id}  ${r.startTime}  ${r.eventCount} events${dur}`;
-                });
-                ctx.addMessage('system', `Recordings (${recs.length} total):\n${lines.join('\n')}`);
-            }
-            break;
-        }
-        case '/recording': {
-            const recId = parts[1];
-            if (!recId) {
-                ctx.addMessage('error', 'Usage: /recording <id> — show recording details');
-                break;
-            }
-            const rec = loadRecording(recId);
-            if (!rec) {
-                ctx.addMessage('error', `Recording "${recId}" not found.`);
-            }
-            else {
-                ctx.addMessage('system', formatRecording(rec));
-            }
-            break;
-        }
-        case '/delete-recording': {
-            const delRecId = parts[1];
-            if (!delRecId) {
-                ctx.addMessage('error', 'Usage: /delete-recording <id>');
-                break;
-            }
-            const delResult = deleteRecording(delRecId);
-            ctx.addMessage('system', delResult ? `Deleted recording ${delRecId}` : `Recording "${delRecId}" not found.`);
-            break;
-        }
-        // ================================================================
-        // API Server
-        // ================================================================
-        case '/serve': {
-            if (isApiServerRunning()) {
-                ctx.addMessage('system', 'API server is already running.');
-                break;
-            }
-            const servePort = parts[1] ? parseInt(parts[1], 10) : 3100;
-            if (isNaN(servePort) || servePort < 1 || servePort > 65535) {
-                ctx.addMessage('error', 'Invalid port. Usage: /serve [port]');
-                break;
-            }
-            try {
-                const info = await startApiServer({ port: servePort, host: '127.0.0.1' });
-                ctx.addMessage('system', `API server started on http://${info.host}:${info.port}`);
-            }
-            catch (err) {
-                ctx.addMessage('error', `Failed to start API server: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            break;
-        }
-        case '/serve-stop': {
-            if (!isApiServerRunning()) {
-                ctx.addMessage('system', 'API server is not running.');
-                break;
-            }
-            await stopApiServer();
-            ctx.addMessage('system', 'API server stopped.');
-            break;
-        }
         case '/exit':
         case '/quit':
             process.exit(0);