attocode 0.1.0

package/dist/src/commands/handler.js

@@ -0,0 +1,1320 @@
+/**
+ * Unified Command Handler
+ *
+ * Handles all slash commands for both REPL and TUI modes.
+ * Uses CommandContext.output for all output, making it mode-agnostic.
+ */
+import { persistenceDebug, saveCheckpointToStore, } from '../integrations/persistence.js';
+import { formatServerList, getContextUsage, formatCompactionResult } from '../integrations/index.js';
+import { formatSessionsTable } from '../session-picker.js';
+// =============================================================================
+// ANSI COLOR UTILITIES
+// =============================================================================
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+};
+/**
+ * Apply ANSI color to text.
+ */
+function c(text, color) {
+    return `${colors[color]}${text}${colors.reset}`;
+}
+// =============================================================================
+// HELP TEXT
+// =============================================================================
+function getHelpText() {
+    return `
+${c('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'dim')}
+${c('                           ATTOCODE HELP', 'bold')}
+${c('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'dim')}
+
+${c('GENERAL', 'bold')}
+  ${c('/help', 'cyan')}              Show this help (alias: /h, /?)
+  ${c('/status', 'cyan')}            Show session stats, metrics & token usage
+  ${c('/clear', 'cyan')}             Clear the screen
+  ${c('/reset', 'cyan')}             Reset agent state (clears conversation)
+  ${c('/quit', 'cyan')}              Exit attocode (alias: /exit, /q)
+
+${c('AGENT MODES', 'bold')}
+  ${c('/mode', 'cyan')}              Show current mode and available modes
+  ${c('/mode <name>', 'cyan')}       Switch to mode (build, plan, review, debug)
+  ${c('/plan', 'cyan')}              Toggle plan mode (writes queued for approval)
+
+${c('PLAN APPROVAL (in Plan Mode)', 'bold')}
+  ${c('/show-plan', 'cyan')}         Show pending plan with proposed changes
+  ${c('/approve', 'cyan')}           Approve and execute all pending changes
+  ${c('/approve <n>', 'cyan')}       Approve and execute first n changes only
+  ${c('/reject', 'cyan')}            Reject and discard all pending changes
+
+${c('SESSIONS & PERSISTENCE', 'bold')}
+  ${c('/save', 'cyan')}              Save current session to disk
+  ${c('/load <id>', 'cyan')}         Load a previous session by ID
+  ${c('/sessions', 'cyan')}          List all saved sessions with timestamps
+  ${c('/resume', 'cyan')}            Resume most recent session (auto-loads last checkpoint)
+
+${c('CONTEXT MANAGEMENT', 'bold')}
+  ${c('/context', 'cyan')}           Show context window usage (tokens used/available)
+  ${c('/context breakdown', 'cyan')} Detailed token breakdown by category
+  ${c('/compact', 'cyan')}           Summarize & compress context to free tokens
+  ${c('/compact status', 'cyan')}    Check if compaction is recommended
+
+${c('CHECKPOINTS & THREADS', 'bold')}
+  ${c('/checkpoint [label]', 'cyan')} Create a named checkpoint (alias: /cp)
+  ${c('/checkpoints', 'cyan')}       List all checkpoints (alias: /cps)
+  ${c('/restore <id>', 'cyan')}      Restore conversation to a checkpoint
+  ${c('/rollback [n]', 'cyan')}      Rollback n steps (default: 1) (alias: /rb)
+  ${c('/fork <name>', 'cyan')}       Fork conversation into a new thread
+  ${c('/threads', 'cyan')}           List all conversation threads
+  ${c('/switch <id>', 'cyan')}       Switch to a different thread
+
+${c('REASONING MODES', 'bold')}
+  ${c('/react <task>', 'cyan')}      Run with ReAct (Reason + Act) pattern
+  ${c('/team <task>', 'cyan')}       Run with multi-agent team coordination
+
+${c('SUBAGENTS', 'bold')}
+  ${c('/agents', 'cyan')}            List all available agents with descriptions
+  ${c('/spawn <agent> <task>', 'cyan')} Spawn a specific agent to handle task
+  ${c('/find <query>', 'cyan')}      Find agents by keyword search
+  ${c('/suggest <task>', 'cyan')}    AI-powered agent suggestion for task
+  ${c('/auto <task>', 'cyan')}       Auto-route task to best agent
+
+${c('MCP INTEGRATION', 'bold')}
+  ${c('/mcp', 'cyan')}               List MCP servers and connection status
+  ${c('/mcp connect <name>', 'cyan')} Connect to an MCP server
+  ${c('/mcp disconnect <name>', 'cyan')} Disconnect from server
+  ${c('/mcp tools', 'cyan')}         List all available MCP tools
+  ${c('/mcp search <query>', 'cyan')} Search & lazy-load MCP tools
+  ${c('/mcp stats', 'cyan')}         Show MCP context usage statistics
+
+${c('BUDGET & ECONOMICS', 'bold')}
+  ${c('/budget', 'cyan')}            Show token/cost budget and usage
+  ${c('/extend <type> <n>', 'cyan')} Extend budget limit
+
+${c('PERMISSIONS & SECURITY', 'bold')}
+  ${c('/grants', 'cyan')}            Show active permission grants
+  ${c('/audit', 'cyan')}             Show security audit log
+
+${c('DEBUGGING & TESTING', 'bold')}
+  ${c('/skills', 'cyan')}            List loaded skills
+  ${c('/sandbox', 'cyan')}           Show sandbox modes available
+  ${c('/shell', 'cyan')}             Show PTY shell integration info
+  ${c('/lsp', 'cyan')}               Show LSP integration status
+  ${c('/tui', 'cyan')}               Show TUI features & capabilities
+
+${c('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'dim')}
+${c('SHORTCUTS', 'bold')}
+  ${c('Ctrl+C', 'yellow')}  Exit          ${c('Ctrl+L', 'yellow')}  Clear screen
+${c('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'dim')}
+`;
+}
+// =============================================================================
+// MAIN COMMAND HANDLER
+// =============================================================================
+/**
+ * Handle a slash command.
+ *
+ * @param cmd - Command string (with leading slash)
+ * @param args - Command arguments
+ * @param ctx - Command context with agent, output, integrations
+ * @returns 'quit' to exit, void otherwise
+ */
+export async function handleCommand(cmd, args, ctx) {
+    const { agent, sessionId, output, integrations } = ctx;
+    const { sessionStore, mcpClient, compactor } = integrations;
+    switch (cmd) {
+        // =========================================================================
+        // GENERAL COMMANDS
+        // =========================================================================
+        case '/quit':
+        case '/exit':
+        case '/q':
+            return 'quit';
+        case '/help':
+        case '/h':
+        case '/?':
+            output.log(getHelpText());
+            break;
+        case '/status': {
+            const metrics = agent.getMetrics();
+            const state = agent.getState();
+            // Get goals summary if SQLite store
+            let goalsSummary = '';
+            if ('listActiveGoals' in sessionStore) {
+                const sqlStore = sessionStore;
+                const activeGoals = sqlStore.listActiveGoals();
+                if (activeGoals.length > 0) {
+                    let totalCurrent = 0;
+                    let totalExpected = 0;
+                    const goalLines = [];
+                    for (const goal of activeGoals) {
+                        if (goal.progressTotal) {
+                            totalCurrent += goal.progressCurrent;
+                            totalExpected += goal.progressTotal;
+                            const pct = Math.round((goal.progressCurrent / goal.progressTotal) * 100);
+                            goalLines.push(`  - ${goal.goalText} (${goal.progressCurrent}/${goal.progressTotal} - ${pct}%)`);
+                        }
+                        else {
+                            goalLines.push(`  - ${goal.goalText}`);
+                        }
+                    }
+                    goalsSummary = `\n${c('Active Goals:', 'bold')} (${activeGoals.length})`;
+                    if (totalExpected > 0) {
+                        const overallPct = Math.round((totalCurrent / totalExpected) * 100);
+                        goalsSummary += c(` [Overall: ${overallPct}%]`, 'cyan');
+                    }
+                    goalsSummary += '\n' + goalLines.slice(0, 5).join('\n');
+                    if (activeGoals.length > 5) {
+                        goalsSummary += c(`\n  ... and ${activeGoals.length - 5} more`, 'dim');
+                    }
+                }
+            }
+            output.log(`
+${c('Session Status:', 'bold')}
+  Session ID:      ${sessionId}
+  Status:          ${state.status}
+  Iteration:       ${state.iteration}
+  Messages:        ${state.messages.length}
+
+${c('Token Usage:', 'bold')}
+  Input tokens:    ${metrics.inputTokens.toLocaleString()}
+  Output tokens:   ${metrics.outputTokens.toLocaleString()}
+  Total tokens:    ${metrics.totalTokens.toLocaleString()}
+
+${c('Activity:', 'bold')}
+  LLM calls:       ${metrics.llmCalls}
+  Tool calls:      ${metrics.toolCalls}
+  Duration:        ${metrics.duration}ms
+  Est. Cost:       $${metrics.estimatedCost.toFixed(4)}
+${goalsSummary}`);
+            break;
+        }
+        case '/clear':
+            output.clear();
+            output.log(c(`Production Agent - Session: ${sessionId}`, 'cyan'));
+            break;
+        case '/reset':
+            agent.reset();
+            output.log(c('+ Agent state reset', 'green'));
+            break;
+        // =========================================================================
+        // MODE MANAGEMENT
+        // =========================================================================
+        case '/mode': {
+            if (args.length === 0) {
+                const modeInfo = agent.getModeInfo();
+                const hasPlan = agent.hasPendingPlan();
+                const pendingCount = agent.getPendingChangeCount();
+                output.log(`
+${c('Current Mode:', 'bold')} ${modeInfo.color}${modeInfo.icon} ${modeInfo.name}\x1b[0m
+${hasPlan ? c(`  Pending Plan: ${pendingCount} change(s) awaiting approval`, 'yellow') : ''}
+
+${agent.getAvailableModes()}
+
+${c('Usage:', 'dim')} /mode <name> to switch, /plan to toggle plan mode`);
+            }
+            else {
+                const newMode = args[0].toLowerCase();
+                agent.setMode(newMode);
+                const modeInfo = agent.getModeInfo();
+                output.log(`${c('Mode changed to:', 'green')} ${modeInfo.color}${modeInfo.icon} ${modeInfo.name}\x1b[0m`);
+                if (newMode !== 'plan' && agent.hasPendingPlan()) {
+                    output.log(c('Warning: You have a pending plan. Use /show-plan to view, /approve or /reject to resolve.', 'yellow'));
+                }
+            }
+            break;
+        }
+        case '/plan': {
+            const newMode = agent.togglePlanMode();
+            const modeInfo = agent.getModeInfo();
+            output.log(`${c('Mode toggled to:', 'green')} ${modeInfo.color}${modeInfo.icon} ${modeInfo.name}\x1b[0m`);
+            if (newMode === 'plan') {
+                output.log(c(`
+In Plan Mode:
+  - You can explore the codebase and use all tools
+  - Write operations will be QUEUED for approval
+  - Use /show-plan to see queued changes
+  - Use /approve to execute, /reject to discard
+`, 'dim'));
+            }
+            else if (agent.hasPendingPlan()) {
+                output.log(c('Note: You have a pending plan. Use /show-plan, /approve, or /reject.', 'yellow'));
+            }
+            break;
+        }
+        // =========================================================================
+        // PLAN APPROVAL COMMANDS
+        // =========================================================================
+        case '/show-plan': {
+            if (!agent.hasPendingPlan()) {
+                output.log(c('No pending plan. Enter plan mode with /plan and make requests that would modify files.', 'dim'));
+            }
+            else {
+                output.log(`\n${agent.formatPendingPlan()}`);
+            }
+            break;
+        }
+        case '/approve': {
+            if (!agent.hasPendingPlan()) {
+                output.log(c('No pending plan to approve.', 'dim'));
+                break;
+            }
+            const count = args[0] ? parseInt(args[0], 10) : undefined;
+            if (args[0] && (isNaN(count) || count < 1)) {
+                output.log(c('Invalid count. Use /approve or /approve <number>', 'red'));
+                break;
+            }
+            const pendingCount = agent.getPendingChangeCount();
+            const toApprove = count ?? pendingCount;
+            output.log(c(`Approving ${toApprove} of ${pendingCount} change(s)...`, 'yellow'));
+            const result = await agent.approvePlan(count);
+            if (result.success) {
+                output.log(c(`\n+ Successfully executed ${result.executed} change(s)`, 'green'));
+            }
+            else {
+                output.log(c(`\n! Executed ${result.executed} change(s) with ${result.errors.length} error(s):`, 'yellow'));
+                for (const err of result.errors) {
+                    output.log(c(`  - ${err}`, 'red'));
+                }
+            }
+            if (agent.getMode() === 'plan') {
+                agent.setMode('build');
+                output.log(c('\nSwitched to Build mode.', 'dim'));
+            }
+            break;
+        }
+        case '/reject': {
+            if (!agent.hasPendingPlan()) {
+                output.log(c('No pending plan to reject.', 'dim'));
+                break;
+            }
+            const pendingCount = agent.getPendingChangeCount();
+            agent.rejectPlan();
+            output.log(c(`x Rejected plan with ${pendingCount} change(s). All proposed changes discarded.`, 'yellow'));
+            if (agent.getMode() === 'plan') {
+                agent.setMode('build');
+                output.log(c('Switched to Build mode.', 'dim'));
+            }
+            break;
+        }
+        // =========================================================================
+        // GOALS
+        // =========================================================================
+        case '/goals':
+            if ('listActiveGoals' in sessionStore) {
+                const sqliteStore = sessionStore;
+                const subCmd = args[0]?.toLowerCase();
+                if (!subCmd || subCmd === 'list') {
+                    const goals = sqliteStore.listActiveGoals();
+                    if (goals.length === 0) {
+                        output.log(c('No active goals. Use /goals add <text> to create one.', 'dim'));
+                    }
+                    else {
+                        output.log(c('\nActive Goals:', 'bold'));
+                        for (const goal of goals) {
+                            const progress = goal.progressTotal
+                                ? ` (${goal.progressCurrent}/${goal.progressTotal})`
+                                : '';
+                            const priority = goal.priority === 1 ? c(' [HIGH]', 'red') :
+                                goal.priority === 3 ? c(' [low]', 'dim') : '';
+                            output.log(`  - ${goal.goalText}${progress}${priority}`);
+                            output.log(c(`    ID: ${goal.id}`, 'dim'));
+                        }
+                    }
+                }
+                else if (subCmd === 'add' && args.length > 1) {
+                    const goalText = args.slice(1).join(' ');
+                    const goalId = sqliteStore.createGoal(goalText);
+                    output.log(c(`+ Goal created: ${goalId}`, 'green'));
+                }
+                else if (subCmd === 'done' && args[1]) {
+                    sqliteStore.completeGoal(args[1]);
+                    output.log(c(`+ Goal completed: ${args[1]}`, 'green'));
+                }
+                else if (subCmd === 'progress' && args[1] && args[2] && args[3]) {
+                    sqliteStore.updateGoal(args[1], {
+                        progressCurrent: parseInt(args[2], 10),
+                        progressTotal: parseInt(args[3], 10),
+                    });
+                    output.log(c(`+ Progress updated: ${args[2]}/${args[3]}`, 'green'));
+                }
+                else if (subCmd === 'all') {
+                    const goals = sqliteStore.listGoals();
+                    output.log(c('\nAll Goals:', 'bold'));
+                    for (const goal of goals) {
+                        const status = goal.status === 'completed' ? c('+', 'green') :
+                            goal.status === 'abandoned' ? c('x', 'red') : ' ';
+                        output.log(`  ${status} ${goal.goalText} [${goal.status}]`);
+                    }
+                }
+                else if (subCmd === 'junctures') {
+                    const junctures = sqliteStore.listJunctures(undefined, 10);
+                    if (junctures.length === 0) {
+                        output.log(c('No junctures logged yet.', 'dim'));
+                    }
+                    else {
+                        output.log(c('\nRecent Key Moments:', 'bold'));
+                        for (const j of junctures) {
+                            const icon = j.type === 'failure' ? c('x', 'red') :
+                                j.type === 'breakthrough' ? c('*', 'yellow') :
+                                    j.type === 'decision' ? c('>', 'cyan') : c('~', 'magenta');
+                            output.log(`  ${icon} [${j.type}] ${j.description}`);
+                            if (j.outcome)
+                                output.log(c(`     -> ${j.outcome}`, 'dim'));
+                        }
+                    }
+                }
+                else {
+                    output.log(c('Usage:', 'bold'));
+                    output.log(c('  /goals              - List active goals', 'dim'));
+                    output.log(c('  /goals add <text>   - Create a new goal', 'dim'));
+                    output.log(c('  /goals done <id>    - Mark goal as completed', 'dim'));
+                    output.log(c('  /goals progress <id> <current> <total> - Update progress', 'dim'));
+                    output.log(c('  /goals all          - List all goals (including completed)', 'dim'));
+                    output.log(c('  /goals junctures    - Show recent key moments', 'dim'));
+                }
+            }
+            else {
+                output.log(c('Goals require SQLite store (not available with JSONL fallback)', 'yellow'));
+            }
+            break;
+        case '/handoff':
+            if ('exportSessionManifest' in sessionStore) {
+                const sqliteStore = sessionStore;
+                const format = args[0]?.toLowerCase() || 'markdown';
+                if (format === 'json') {
+                    const manifest = sqliteStore.exportSessionManifest();
+                    if (manifest) {
+                        output.log(JSON.stringify(manifest, null, 2));
+                    }
+                    else {
+                        output.log(c('No active session to export', 'yellow'));
+                    }
+                }
+                else {
+                    const markdown = sqliteStore.exportSessionMarkdown();
+                    output.log(markdown);
+                }
+            }
+            else {
+                output.log(c('Handoff requires SQLite store (not available with JSONL fallback)', 'yellow'));
+            }
+            break;
+        // =========================================================================
+        // REASONING MODES
+        // =========================================================================
+        case '/react':
+            if (args.length === 0) {
+                output.log(c('Usage: /react <task>', 'yellow'));
+            }
+            else {
+                const task = args.join(' ');
+                output.log(c(`\nRunning with ReAct pattern: ${task}`, 'cyan'));
+                try {
+                    const trace = await agent.runWithReAct(task);
+                    output.log(c('\n--- ReAct Trace ---', 'magenta'));
+                    output.log(agent.formatReActTrace(trace));
+                    output.log(c('-------------------', 'magenta'));
+                }
+                catch (error) {
+                    output.log(c(`Error: ${error.message}`, 'red'));
+                }
+            }
+            break;
+        case '/team':
+            if (args.length === 0) {
+                output.log(c('Usage: /team <task>', 'yellow'));
+            }
+            else {
+                const task = args.join(' ');
+                output.log(c(`\nRunning with team: ${task}`, 'cyan'));
+                try {
+                    const { CODER_ROLE, REVIEWER_ROLE, RESEARCHER_ROLE } = await import('../integrations/multi-agent.js');
+                    const result = await agent.runWithTeam({ id: `team-${Date.now()}`, goal: task, context: '' }, [RESEARCHER_ROLE, CODER_ROLE, REVIEWER_ROLE]);
+                    output.log(c('\n--- Team Result ---', 'magenta'));
+                    output.log(`Success: ${result.success}`);
+                    output.log(`Coordinator: ${result.coordinator}`);
+                    if (result.consensus) {
+                        output.log(`Consensus: ${result.consensus.agreed ? 'Agreed' : 'Disagreed'} - ${result.consensus.result}`);
+                    }
+                    output.log(c('-------------------', 'magenta'));
+                }
+                catch (error) {
+                    output.log(c(`Error: ${error.message}`, 'red'));
+                }
+            }
+            break;
+        // =========================================================================
+        // CHECKPOINTS & THREADS
+        // =========================================================================
+        case '/checkpoint':
+        case '/cp':
+            try {
+                const label = args.length > 0 ? args.join(' ') : undefined;
+                const checkpoint = agent.createCheckpoint(label);
+                output.log(c(`+ Checkpoint created: ${checkpoint.id}${label ? ` (${label})` : ''}`, 'green'));
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        case '/checkpoints':
+        case '/cps':
+            try {
+                const checkpoints = agent.getCheckpoints();
+                if (checkpoints.length === 0) {
+                    output.log(c('No checkpoints.', 'dim'));
+                }
+                else {
+                    output.log(c('\nCheckpoints:', 'bold'));
+                    checkpoints.forEach(cp => {
+                        output.log(`  ${c(cp.id, 'cyan')}${cp.label ? ` - ${cp.label}` : ''}`);
+                    });
+                }
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        case '/restore':
+            if (args.length === 0) {
+                output.log(c('Usage: /restore <checkpoint-id>', 'yellow'));
+            }
+            else {
+                const success = agent.restoreCheckpoint(args[0]);
+                output.log(success ? c(`+ Restored: ${args[0]}`, 'green') : c(`x Not found: ${args[0]}`, 'red'));
+            }
+            break;
+        case '/rollback':
+        case '/rb': {
+            const steps = args.length > 0 ? parseInt(args[0], 10) : 1;
+            if (isNaN(steps) || steps < 1) {
+                output.log(c('Usage: /rollback <steps>', 'yellow'));
+            }
+            else {
+                const success = agent.rollback(steps);
+                output.log(success ? c(`+ Rolled back ${steps} steps`, 'green') : c('x Rollback failed', 'red'));
+            }
+            break;
+        }
+        case '/fork':
+            if (args.length === 0) {
+                output.log(c('Usage: /fork <name>', 'yellow'));
+            }
+            else {
+                try {
+                    const threadId = agent.fork(args.join(' '));
+                    output.log(c(`+ Forked: ${threadId}`, 'green'));
+                }
+                catch (error) {
+                    output.log(c(`Error: ${error.message}`, 'red'));
+                }
+            }
+            break;
+        case '/threads':
+            try {
+                const threads = agent.getAllThreads();
+                if (threads.length === 0) {
+                    output.log(c('No threads.', 'dim'));
+                }
+                else {
+                    output.log(c('\nThreads:', 'bold'));
+                    threads.forEach((t) => {
+                        output.log(`  ${c(t.id, 'cyan')}${t.name ? ` - ${t.name}` : ''} (${t.messages?.length || 0} messages)`);
+                    });
+                }
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        case '/switch':
+            if (args.length === 0) {
+                output.log(c('Usage: /switch <thread-id>', 'yellow'));
+            }
+            else {
+                const success = agent.switchThread(args[0]);
+                output.log(success ? c(`+ Switched to: ${args[0]}`, 'green') : c(`x Not found: ${args[0]}`, 'red'));
+            }
+            break;
+        // =========================================================================
+        // SECURITY
+        // =========================================================================
+        case '/grants':
+            try {
+                const grants = agent.getActiveGrants();
+                if (grants.length === 0) {
+                    output.log(c('No active permission grants.', 'dim'));
+                }
+                else {
+                    output.log(c('\nActive Grants:', 'bold'));
+                    grants.forEach((g) => {
+                        output.log(`  ${c(g.id, 'cyan')} - ${g.toolName} (${g.grantedBy})`);
+                    });
+                }
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        case '/audit':
+            try {
+                const log = agent.getAuditLog();
+                if (log.length === 0) {
+                    output.log(c('No audit entries.', 'dim'));
+                }
+                else {
+                    output.log(c('\nAudit Log:', 'bold'));
+                    log.slice(-10).forEach((entry) => {
+                        const status = entry.approved ? c('+', 'green') : c('x', 'red');
+                        output.log(`  ${status} ${entry.action} - ${entry.tool || 'n/a'}`);
+                    });
+                }
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        // =========================================================================
+        // BUDGET
+        // =========================================================================
+        case '/budget':
+            try {
+                const usage = agent.getBudgetUsage();
+                const limits = agent.getBudgetLimits();
+                const progress = agent.getProgress();
+                if (!usage || !limits) {
+                    output.log(c('Economics not available.', 'dim'));
+                }
+                else {
+                    output.log(`
+${c('Budget Usage:', 'bold')}
+  Tokens:      ${usage.tokens.toLocaleString()} / ${limits.maxTokens.toLocaleString()} (${usage.percentUsed.toFixed(1)}%)
+  Cost:        $${usage.cost.toFixed(4)} / $${limits.maxCost.toFixed(2)}
+  Duration:    ${Math.round(usage.duration / 1000)}s / ${Math.round(limits.maxDuration / 1000)}s
+  Iterations:  ${usage.iterations} / ${limits.maxIterations}
+
+${c('Progress:', 'bold')}
+  Files read:     ${progress?.filesRead || 0}
+  Files modified: ${progress?.filesModified || 0}
+  Commands run:   ${progress?.commandsRun || 0}
+  Status:         ${progress?.isStuck ? c('STUCK', 'red') : c('Active', 'green')}
+`);
+                }
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        case '/extend':
+            if (args.length === 0) {
+                output.log(c('Usage: /extend <tokens|cost|time> <amount>', 'yellow'));
+            }
+            else {
+                const [what, amount] = args;
+                const value = parseFloat(amount);
+                if (isNaN(value)) {
+                    output.log(c('Invalid amount', 'red'));
+                }
+                else {
+                    const limits = agent.getBudgetLimits();
+                    if (!limits) {
+                        output.log(c('Economics not available', 'dim'));
+                    }
+                    else {
+                        switch (what) {
+                            case 'tokens':
+                                agent.extendBudget({ maxTokens: limits.maxTokens + value });
+                                output.log(c(`+ Token budget extended to ${(limits.maxTokens + value).toLocaleString()}`, 'green'));
+                                break;
+                            case 'cost':
+                                agent.extendBudget({ maxCost: limits.maxCost + value });
+                                output.log(c(`+ Cost budget extended to $${(limits.maxCost + value).toFixed(2)}`, 'green'));
+                                break;
+                            case 'time':
+                                agent.extendBudget({ maxDuration: limits.maxDuration + value * 1000 });
+                                output.log(c(`+ Time budget extended to ${Math.round((limits.maxDuration + value * 1000) / 1000)}s`, 'green'));
+                                break;
+                            default:
+                                output.log(c('Unknown budget type. Use: tokens, cost, or time', 'yellow'));
+                        }
+                    }
+                }
+            }
+            break;
+        // =========================================================================
+        // SUBAGENTS
+        // =========================================================================
+        case '/agents':
+            try {
+                const agentList = agent.formatAgentList();
+                output.log(c('\nAvailable Agents:', 'bold'));
+                output.log(agentList);
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        case '/spawn':
+            if (args.length < 2) {
+                output.log(c('Usage: /spawn <agent-name> <task>', 'yellow'));
+            }
+            else {
+                const agentName = args[0];
+                const task = args.slice(1).join(' ');
+                output.log(c(`\nSpawning ${agentName}: ${task}`, 'cyan'));
+                try {
+                    const result = await agent.spawnAgent(agentName, task);
+                    output.log(c('\n--- Agent Result ---', 'magenta'));
+                    output.log(`Success: ${result.success}`);
+                    output.log(`Output: ${result.output}`);
+                    output.log(c(`\nTokens: ${result.metrics.tokens} | Tools: ${result.metrics.toolCalls} | Duration: ${result.metrics.duration}ms`, 'dim'));
+                    output.log(c('--------------------', 'magenta'));
+                }
+                catch (error) {
+                    output.log(c(`Error: ${error.message}`, 'red'));
+                }
+            }
+            break;
+        case '/find':
+            if (args.length === 0) {
+                output.log(c('Usage: /find <query>', 'yellow'));
+            }
+            else {
+                const query = args.join(' ');
+                output.log(c(`\nFinding agents for: "${query}"`, 'cyan'));
+                const matches = agent.findAgentsForTask(query);
+                if (matches.length === 0) {
+                    output.log(c('No matching agents found.', 'dim'));
+                }
+                else {
+                    output.log(c('\nMatching Agents:', 'bold'));
+                    matches.forEach((a, i) => {
+                        output.log(`  ${i + 1}. ${c(a.name, 'cyan')} (${a.source})`);
+                        output.log(`     ${a.description.split('.')[0]}`);
+                        if (a.capabilities?.length) {
+                            output.log(c(`     Capabilities: ${a.capabilities.join(', ')}`, 'dim'));
+                        }
+                    });
+                    output.log(c('\nUse /spawn <agent-name> <task> to run an agent.', 'dim'));
+                }
+            }
+            break;
+        case '/suggest':
+            if (args.length === 0) {
+                output.log(c('Usage: /suggest <task description>', 'yellow'));
+            }
+            else {
+                const taskDesc = args.join(' ');
+                output.log(c(`\nAnalyzing task: "${taskDesc}"`, 'cyan'));
+                try {
+                    const { suggestions, shouldDelegate, delegateAgent } = await agent.suggestAgentForTask(taskDesc);
+                    if (suggestions.length === 0) {
+                        output.log(c('\nNo specialized agent recommended. Main agent should handle this task.', 'dim'));
+                    }
+                    else {
+                        output.log(c('\nAgent Suggestions:', 'bold'));
+                        suggestions.forEach((s, i) => {
+                            const confidenceBar = '='.repeat(Math.round(s.confidence * 10)) + '-'.repeat(10 - Math.round(s.confidence * 10));
+                            output.log(`  ${i + 1}. ${c(s.agent.name, 'cyan')} [${confidenceBar}] ${(s.confidence * 100).toFixed(0)}%`);
+                            output.log(`     ${s.reason}`);
+                        });
+                        if (shouldDelegate && delegateAgent) {
+                            output.log(c(`\nRecommendation: Delegate to "${delegateAgent}"`, 'green'));
+                            output.log(c(`   Run: /spawn ${delegateAgent} ${taskDesc}`, 'dim'));
+                        }
+                        else {
+                            output.log(c('\nRecommendation: Main agent should handle this task.', 'dim'));
+                        }
+                    }
+                }
+                catch (error) {
+                    output.log(c(`Error: ${error.message}`, 'red'));
+                }
+            }
+            break;
+        case '/auto':
+            if (args.length === 0) {
+                output.log(c('Usage: /auto <task>', 'yellow'));
+            }
+            else {
+                const autoTask = args.join(' ');
+                output.log(c(`\nAuto-routing: "${autoTask}"`, 'cyan'));
+                try {
+                    // Create a confirmation callback
+                    const confirmDelegate = async (suggestedAgent, reason) => {
+                        output.log(c(`\nSuggested agent: ${suggestedAgent.name}`, 'yellow'));
+                        output.log(c(`   Reason: ${reason}`, 'dim'));
+                        if (ctx.confirm) {
+                            return ctx.confirm('Delegate to this agent?');
+                        }
+                        if (ctx.rl) {
+                            const answer = await ctx.rl.question(c('   Delegate to this agent? (y/n): ', 'yellow'));
+                            return answer.toLowerCase().startsWith('y');
+                        }
+                        return false;
+                    };
+                    const result = await agent.runWithAutoRouting(autoTask, {
+                        confidenceThreshold: 0.75,
+                        confirmDelegate,
+                    });
+                    if ('output' in result) {
+                        output.log(c('\n--- Subagent Result ---', 'magenta'));
+                        output.log(`Success: ${result.success}`);
+                        output.log(result.output);
+                        output.log(c(`\nTokens: ${result.metrics.tokens} | Duration: ${result.metrics.duration}ms`, 'dim'));
+                        output.log(c('-----------------------', 'magenta'));
+                    }
+                    else {
+                        output.log(c('\n--- Assistant ---', 'magenta'));
+                        output.log(result.response);
+                        output.log(c('-----------------', 'magenta'));
+                        output.log(c(`\nTokens: ${result.metrics.inputTokens} in / ${result.metrics.outputTokens} out | Tools: ${result.metrics.toolCalls}`, 'dim'));
+                    }
+                }
+                catch (error) {
+                    output.log(c(`Error: ${error.message}`, 'red'));
+                }
+            }
+            break;
+        // =========================================================================
+        // MCP INTEGRATION
+        // =========================================================================
+        case '/mcp':
+            if (args.length === 0) {
+                const servers = mcpClient.listServers();
+                output.log(formatServerList(servers));
+            }
+            else if (args[0] === 'connect' && args[1]) {
+                output.log(c(`Connecting to ${args[1]}...`, 'cyan'));
+                try {
+                    await mcpClient.connectServer(args[1]);
+                    output.log(c(`+ Connected to ${args[1]}`, 'green'));
+                    const tools = mcpClient.getAllTools();
+                    for (const tool of tools) {
+                        agent.addTool(tool);
+                    }
+                    output.log(c(`  Added ${tools.length} tools from MCP servers`, 'dim'));
+                }
+                catch (error) {
+                    output.log(c(`Error: ${error.message}`, 'red'));
+                }
+            }
+            else if (args[0] === 'disconnect' && args[1]) {
+                await mcpClient.disconnectServer(args[1]);
+                output.log(c(`+ Disconnected from ${args[1]}`, 'green'));
+            }
+            else if (args[0] === 'tools') {
+                const tools = mcpClient.getAllTools();
+                if (tools.length === 0) {
+                    output.log(c('No MCP tools available.', 'dim'));
+                }
+                else {
+                    output.log(c('\nMCP Tools:', 'bold'));
+                    tools.forEach(t => {
+                        const loaded = mcpClient.isToolLoaded(t.name);
+                        const status = loaded ? c('+', 'green') : c('o', 'dim');
+                        output.log(`  ${status} ${c(t.name, 'cyan')} - ${t.description?.slice(0, 60) || 'No description'}...`);
+                    });
+                    const stats = mcpClient.getContextStats();
+                    output.log(c(`\n  Legend: + = full schema loaded, o = summary only`, 'dim'));
+                    output.log(c(`  Loaded: ${stats.loadedCount}/${stats.totalTools} tools`, 'dim'));
+                }
+            }
+            else if (args[0] === 'search') {
+                const query = args.slice(1).join(' ');
+                if (!query) {
+                    output.log(c('Usage: /mcp search <query>', 'yellow'));
+                }
+                else {
+                    output.log(c(`Searching for: "${query}"...`, 'cyan'));
+                    const results = mcpClient.searchTools(query, { limit: 10 });
+                    if (results.length === 0) {
+                        output.log(c('No matching tools found.', 'dim'));
+                    }
+                    else {
+                        output.log(c(`\nFound ${results.length} tool(s):`, 'bold'));
+                        results.forEach(r => {
+                            output.log(`  ${c(r.name, 'cyan')} (${r.serverName})`);
+                            output.log(`    ${r.description}`);
+                        });
+                        const loadedTools = mcpClient.loadTools(results.map(r => r.name));
+                        for (const tool of loadedTools) {
+                            agent.addTool(tool);
+                        }
+                        output.log(c(`\n+ Loaded ${loadedTools.length} tool(s). They are now available for use.`, 'green'));
+                    }
+                }
+            }
+            else if (args[0] === 'stats') {
+                const stats = mcpClient.getContextStats();
+                const fullLoadEstimate = stats.totalTools * 200;
+                const currentTokens = stats.summaryTokens + stats.definitionTokens;
+                const savingsPercent = fullLoadEstimate > 0
+                    ? Math.round((1 - currentTokens / fullLoadEstimate) * 100)
+                    : 0;
+                output.log(`
+${c('MCP Context Usage:', 'bold')}
+  Tool summaries:    ${stats.summaryCount.toString().padStart(3)} tools (~${stats.summaryTokens.toLocaleString()} tokens)
+  Full definitions:  ${stats.loadedCount.toString().padStart(3)} tools (~${stats.definitionTokens.toLocaleString()} tokens)
+  Total:             ${stats.totalTools.toString().padStart(3)} tools (~${currentTokens.toLocaleString()} tokens)
+
+  Context savings:   ${savingsPercent}% vs loading all full schemas
+  ${savingsPercent > 50 ? c('+ Good - lazy loading is saving context', 'green') : c('! Consider using lazy loading more', 'yellow')}
+
+${c('Tip:', 'dim')} Use /mcp search <query> to load specific tools on-demand.
+`);
+            }
+            else {
+                output.log(c('Usage:', 'bold'));
+                output.log(c('  /mcp                - List servers', 'dim'));
+                output.log(c('  /mcp connect <name> - Connect to server', 'dim'));
+                output.log(c('  /mcp disconnect <name> - Disconnect', 'dim'));
+                output.log(c('  /mcp tools          - List available tools', 'dim'));
+                output.log(c('  /mcp search <query> - Search & load tools', 'dim'));
+                output.log(c('  /mcp stats          - Show context usage stats', 'dim'));
+            }
+            break;
+        // =========================================================================
+        // SESSION MANAGEMENT
+        // =========================================================================
+        case '/save':
+            try {
+                const state = agent.getState();
+                const metrics = agent.getMetrics();
+                const saveCheckpointId = `ckpt-manual-${Date.now().toString(36)}`;
+                persistenceDebug.log('/save command - creating checkpoint', {
+                    checkpointId: saveCheckpointId,
+                    messageCount: state.messages?.length ?? 0,
+                });
+                saveCheckpointToStore(sessionStore, {
+                    id: saveCheckpointId,
+                    label: 'manual-save',
+                    messages: state.messages,
+                    iteration: state.iteration,
+                    metrics: metrics,
+                    plan: state.plan,
+                    memoryContext: state.memoryContext,
+                });
+                output.log(c(`+ Session saved: ${sessionId} (checkpoint: ${saveCheckpointId})`, 'green'));
+            }
+            catch (error) {
+                persistenceDebug.error('/save command failed', error);
+                output.log(c(`Error saving session: ${error.message}`, 'red'));
+            }
+            break;
+        case '/load':
+            if (args.length === 0) {
+                output.log(c('Usage: /load <session-id>', 'yellow'));
+                output.log(c('  Use /sessions to list available sessions', 'dim'));
+            }
+            else {
+                const loadId = args[0];
+                try {
+                    let checkpointData;
+                    if ('loadLatestCheckpoint' in sessionStore && typeof sessionStore.loadLatestCheckpoint === 'function') {
+                        const sqliteCheckpoint = sessionStore.loadLatestCheckpoint(loadId);
+                        if (sqliteCheckpoint?.state) {
+                            checkpointData = sqliteCheckpoint.state;
+                        }
+                    }
+                    if (!checkpointData) {
+                        const entries = await sessionStore.loadSession(loadId);
+                        if (entries.length === 0) {
+                            output.log(c(`No entries found for session: ${loadId}`, 'yellow'));
+                            break;
+                        }
+                        const checkpoint = [...entries].reverse().find(e => e.type === 'checkpoint');
+                        checkpointData = checkpoint?.data;
+                    }
+                    if (checkpointData?.messages) {
+                        agent.loadState({
+                            messages: checkpointData.messages,
+                            iteration: checkpointData.iteration,
+                            metrics: checkpointData.metrics,
+                            plan: checkpointData.plan,
+                            memoryContext: checkpointData.memoryContext,
+                        });
+                        output.log(c(`+ Loaded ${checkpointData.messages.length} messages from ${loadId}`, 'green'));
+                    }
+                    else {
+                        output.log(c('No checkpoint found in session', 'yellow'));
+                    }
+                }
+                catch (error) {
+                    output.log(c(`Error loading session: ${error.message}`, 'red'));
+                }
+            }
+            break;
+        case '/resume':
+            try {
+                const recentSession = sessionStore.getRecentSession();
+                if (!recentSession) {
+                    output.log(c('No previous sessions found', 'yellow'));
+                }
+                else {
+                    output.log(c(`Found recent session: ${recentSession.id}`, 'dim'));
+                    output.log(c(`   Created: ${new Date(recentSession.createdAt).toLocaleString()}`, 'dim'));
+                    output.log(c(`   Messages: ${recentSession.messageCount}`, 'dim'));
+                    let resumeCheckpointData;
+                    if ('loadLatestCheckpoint' in sessionStore && typeof sessionStore.loadLatestCheckpoint === 'function') {
+                        const sqliteCheckpoint = sessionStore.loadLatestCheckpoint(recentSession.id);
+                        if (sqliteCheckpoint?.state) {
+                            resumeCheckpointData = sqliteCheckpoint.state;
+                        }
+                    }
+                    if (!resumeCheckpointData) {
+                        const entriesResult = sessionStore.loadSession(recentSession.id);
+                        const entries = Array.isArray(entriesResult) ? entriesResult : await entriesResult;
+                        const checkpoint = [...entries].reverse().find(e => e.type === 'checkpoint');
+                        if (checkpoint?.data) {
+                            resumeCheckpointData = checkpoint.data;
+                        }
+                        else {
+                            const messages = entries
+                                .filter((e) => e.type === 'message')
+                                .map((e) => e.data);
+                            if (messages.length > 0) {
+                                agent.loadState({ messages: messages });
+                                output.log(c(`+ Resumed ${messages.length} messages from last session`, 'green'));
+                            }
+                            else {
+                                output.log(c('No messages found in last session', 'yellow'));
+                            }
+                        }
+                    }
+                    if (resumeCheckpointData?.messages) {
+                        agent.loadState({
+                            messages: resumeCheckpointData.messages,
+                            iteration: resumeCheckpointData.iteration,
+                            metrics: resumeCheckpointData.metrics,
+                            plan: resumeCheckpointData.plan,
+                            memoryContext: resumeCheckpointData.memoryContext,
+                        });
+                        output.log(c(`+ Resumed ${resumeCheckpointData.messages.length} messages from last session`, 'green'));
+                        if (resumeCheckpointData.iteration) {
+                            output.log(c(`   Iteration: ${resumeCheckpointData.iteration}`, 'dim'));
+                        }
+                        if (resumeCheckpointData.plan) {
+                            output.log(c(`   Plan restored`, 'dim'));
+                        }
+                        if ('getPendingPlan' in sessionStore && typeof sessionStore.getPendingPlan === 'function') {
+                            const pendingPlan = sessionStore.getPendingPlan(recentSession.id);
+                            if (pendingPlan && pendingPlan.status === 'pending') {
+                                output.log(c(`\nFound pending plan: "${pendingPlan.task}"`, 'yellow'));
+                                output.log(c(`   ${pendingPlan.proposedChanges.length} change(s) awaiting approval`, 'yellow'));
+                                output.log(c('   Use /show-plan to view, /approve to execute, /reject to discard', 'dim'));
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                output.log(c(`Error resuming session: ${error.message}`, 'red'));
+            }
+            break;
+        case '/sessions':
+            try {
+                const sessions = await sessionStore.listSessions();
+                output.log(formatSessionsTable(sessions));
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        // =========================================================================
+        // CONTEXT MANAGEMENT
+        // =========================================================================
+        case '/compact':
+            try {
+                const state = agent.getState();
+                const contextUsage = getContextUsage(state.messages, 80000);
+                if (args[0] === 'status') {
+                    output.log(`
+${c('Context Status:', 'bold')}
+  Messages:    ${state.messages.length}
+  Est. Tokens: ${contextUsage.tokens.toLocaleString()}
+  Usage:       ${contextUsage.percent}%
+  Threshold:   80%
+  Should Compact: ${contextUsage.shouldCompact ? c('Yes', 'yellow') : c('No', 'green')}
+`);
+                }
+                else {
+                    if (state.messages.length < 5) {
+                        output.log(c('Not enough messages to compact.', 'dim'));
+                    }
+                    else {
+                        output.log(c('Compacting context...', 'cyan'));
+                        const result = await compactor.compact(state.messages);
+                        agent.loadMessages(result.preservedMessages);
+                        output.log(formatCompactionResult(result));
+                    }
+                }
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        case '/context':
+            try {
+                const state = agent.getState();
+                if (args[0] === 'breakdown') {
+                    // Detailed token breakdown
+                    const mcpStats = mcpClient.getContextStats();
+                    const systemPrompt = agent.getSystemPromptWithMode();
+                    const estimateTokens = (str) => Math.ceil(str.length / 3.2);
+                    const systemTokens = estimateTokens(systemPrompt);
+                    const mcpTokens = mcpStats.summaryTokens + mcpStats.definitionTokens;
+                    const agentTools = agent.getTools().filter(t => !t.name.startsWith('mcp_'));
+                    const agentToolTokens = agentTools.length * 150;
+                    const convTokens = state.messages
+                        .filter(m => m.role !== 'system')
+                        .reduce((sum, m) => sum + estimateTokens(m.content), 0);
+                    const totalTokens = systemTokens + mcpTokens + agentToolTokens + convTokens;
+                    const messageCount = state.messages.filter(m => m.role !== 'system').length;
+                    const sysPct = totalTokens > 0 ? Math.round((systemTokens / totalTokens) * 100) : 0;
+                    const mcpPct = totalTokens > 0 ? Math.round((mcpTokens / totalTokens) * 100) : 0;
+                    const agentPct = totalTokens > 0 ? Math.round((agentToolTokens / totalTokens) * 100) : 0;
+                    const convPct = totalTokens > 0 ? Math.round((convTokens / totalTokens) * 100) : 0;
+                    output.log(`
+${c('Context Token Breakdown', 'bold')} (Total: ~${totalTokens.toLocaleString()} tokens)
+
+${c('  Category             Tokens    % of Total', 'dim')}
+  System prompt:     ${systemTokens.toLocaleString().padStart(7)} tokens  ${sysPct.toString().padStart(3)}%
+  MCP tools:         ${mcpTokens.toLocaleString().padStart(7)} tokens  ${mcpPct.toString().padStart(3)}%  (${mcpStats.loadedCount} loaded / ${mcpStats.totalTools} total)
+  Agent tools:       ${agentToolTokens.toLocaleString().padStart(7)} tokens  ${agentPct.toString().padStart(3)}%  (${agentTools.length} tools)
+  Conversation:      ${convTokens.toLocaleString().padStart(7)} tokens  ${convPct.toString().padStart(3)}%  (${messageCount} messages)
+`);
+                }
+                else {
+                    // Simple context overview
+                    const mcpStats = mcpClient.getContextStats();
+                    const systemPrompt = agent.getSystemPromptWithMode();
+                    const estimateTokens = (str) => Math.ceil(str.length / 3.2);
+                    const systemTokens = estimateTokens(systemPrompt);
+                    const mcpTokens = mcpStats.summaryTokens + mcpStats.definitionTokens;
+                    const agentTools = agent.getTools().filter(t => !t.name.startsWith('mcp_'));
+                    const agentToolTokens = agentTools.length * 150;
+                    const baseTokens = systemTokens + mcpTokens + agentToolTokens;
+                    const convTokens = state.messages
+                        .filter(m => m.role !== 'system')
+                        .reduce((sum, m) => sum + estimateTokens(m.content), 0);
+                    const totalTokens = baseTokens + convTokens;
+                    const contextLimit = 80000;
+                    const percent = Math.round((totalTokens / contextLimit) * 100);
+                    const shouldCompact = percent >= 80;
+                    const bar = '='.repeat(Math.min(20, Math.round(percent / 5))) +
+                        '-'.repeat(Math.max(0, 20 - Math.round(percent / 5)));
+                    const color = percent >= 80 ? 'red' : percent >= 60 ? 'yellow' : 'green';
+                    output.log(`
+${c('Context Window:', 'bold')}
+  [${c(bar, color)}] ${percent}%
+  Base:     ~${baseTokens.toLocaleString()} tokens (system + ${agentTools.length} agent tools)
+  MCP:      ~${mcpTokens.toLocaleString()} tokens (${mcpStats.loadedCount}/${mcpStats.totalTools} tools loaded)
+  Messages: ${state.messages.filter(m => m.role !== 'system').length} (~${convTokens.toLocaleString()} tokens)
+  Total:    ~${totalTokens.toLocaleString()} / ${(contextLimit / 1000).toFixed(0)}k tokens
+  ${shouldCompact ? c('! Consider running /compact', 'yellow') : c('+ Healthy', 'green')}
+`);
+                }
+            }
+            catch (error) {
+                output.log(c(`Error: ${error.message}`, 'red'));
+            }
+            break;
+        // =========================================================================
+        // THEME
+        // =========================================================================
+        case '/theme':
+            try {
+                const { getThemeNames, getTheme } = await import('../tui/theme/index.js');
+                const themes = getThemeNames();
+                if (args.length === 0) {
+                    output.log(`
+${c('Available Themes:', 'bold')}
+${themes.map(t => `  ${c(t, 'cyan')}`).join('\n')}
+
+${c('Usage:', 'dim')} /theme <name>
+${c('Note:', 'dim')} Theme switching is visual in TUI mode. REPL mode uses fixed ANSI colors.
+`);
+                }
+                else {
+                    const themeName = args[0];
+                    if (themes.includes(themeName)) {
+                        const selectedTheme = getTheme(themeName);
+                        output.log(c(`+ Theme set to: ${themeName}`, 'green'));
+                        output.log(c(`  Primary: ${selectedTheme.colors.primary}`, 'dim'));
+                        output.log(c(`  Note: Full theme support requires TUI mode`, 'dim'));
+                    }
+                    else {
+                        output.log(c(`Unknown theme: ${themeName}`, 'red'));
+                        output.log(c(`Available: ${themes.join(', ')}`, 'dim'));
+                    }
+                }
+            }
+            catch (error) {
+                output.log(c(`Error loading themes: ${error.message}`, 'red'));
+            }
+            break;
+        // =========================================================================
+        // DEBUGGING & TESTING
+        // =========================================================================
+        case '/skills':
+            try {
+                const skills = agent.getSkills();
+                if (skills.length === 0) {
+                    output.log(c('No skills loaded.', 'dim'));
+                    output.log(c('Add .md files to .skills/ directory to create skills.', 'dim'));
+                }
+                else {
+                    output.log(c('\nLoaded Skills:', 'bold'));
+                    skills.forEach((skill) => {
+                        const active = skill.active ? c('+', 'green') : c('o', 'dim');
+                        output.log(`  ${active} ${c(skill.name, 'cyan')} - ${skill.description || 'No description'}`);
+                        if (skill.triggers?.length > 0) {
+                            output.log(c(`      Triggers: ${skill.triggers.join(', ')}`, 'dim'));
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                output.log(c(`Skills not available: ${error.message}`, 'yellow'));
+            }
+            break;
+        case '/sandbox':
+            try {
+                const { createSandboxManager } = await import('../integrations/sandbox/index.js');
+                const sandboxManager = createSandboxManager({ mode: 'auto', verbose: true });
+                const available = await sandboxManager.getAvailableSandboxes();
+                output.log(c('\nSandbox Modes:', 'bold'));
+                for (const { mode, available: isAvailable } of available) {
+                    const icon = isAvailable ? c('+', 'green') : c('x', 'red');
+                    const desc = {
+                        auto: 'Auto-detect best available sandbox',
+                        seatbelt: 'macOS sandbox-exec with Seatbelt profiles',
+                        landlock: 'Linux Landlock LSM / bubblewrap / firejail',
+                        docker: 'Docker container isolation',
+                        basic: 'Allowlist-based command validation',
+                        none: 'No sandboxing (passthrough)',
+                    };
+                    output.log(`  ${icon} ${c(mode.padEnd(10), 'cyan')} ${desc[mode] || ''}`);
+                }
+                const sandbox = await sandboxManager.getSandbox();
+                output.log(c(`\nActive sandbox: ${sandbox.getType()}`, 'green'));
+                if (args[0] === 'test') {
+                    output.log(c('\nTesting sandbox with "echo hello"...', 'dim'));
+                    const result = await sandboxManager.execute('echo hello');
+                    output.log(`  Exit code: ${result.exitCode}`);
+                    output.log(`  Output: ${result.stdout.trim()}`);
+                    output.log(`  Sandboxed: ${sandbox.getType() !== 'none' ? 'Yes' : 'No'}`);
+                }
+                else {
+                    output.log(c('\nUse /sandbox test to run a test command.', 'dim'));
+                }
+                await sandboxManager.cleanup();
+            }
+            catch (error) {
+                output.log(c(`Sandbox error: ${error.message}`, 'red'));
+            }
+            break;
+        case '/shell':
+            try {
+                const { createPTYShell } = await import('../integrations/pty-shell.js');
+                if (args[0] === 'test') {
+                    output.log(c('\nTesting persistent PTY shell...', 'cyan'));
+                    const shell = createPTYShell({ timeout: 5000 });
+                    await shell.start();
+                    output.log(c('  1. Setting variable: export TEST_VAR="hello"', 'dim'));
+                    await shell.execute('export TEST_VAR="hello"');
+                    output.log(c('  2. Reading variable back...', 'dim'));
+                    const result = await shell.execute('echo $TEST_VAR');
+                    output.log(`     Result: ${result.output}`);
+                    output.log(`     Exit code: ${result.exitCode}`);
+                    output.log(c('  3. Checking state persistence...', 'dim'));
+                    const state = shell.getState();
+                    output.log(`     CWD: ${state.cwd}`);
+                    output.log(`     Commands run: ${state.history.length}`);
+                    output.log(`     Shell running: ${state.isRunning}`);
+                    await shell.cleanup();
+                    output.log(c('\n+ PTY shell test passed!', 'green'));
+                }
+                else {
+                    output.log(`
+${c('PTY Shell:', 'bold')}
+  The persistent shell maintains state between commands:
+  - Working directory persists across cd commands
+  - Environment variables are retained
+  - Command history is tracked
+
+  ${c('Use /shell test to run a quick test.', 'dim')}
+`);
+                }
+            }
+            catch (error) {
+                output.log(c(`Shell error: ${error.message}`, 'red'));
+            }
+            break;
+        case '/lsp':
+            output.log(`
+${c('LSP Integration:', 'bold')}
+  The LSP-enhanced file tools provide real-time diagnostics:
+
+${c('LSP-Enhanced Tools:', 'bold')}
+  - ${c('lsp_edit_file', 'cyan')} - Edit with diagnostics feedback
+  - ${c('lsp_write_file', 'cyan')} - Write with diagnostics feedback
+
+${c('How it works:', 'dim')}
+  1. After edit/write, LSP server analyzes the file
+  2. Returns errors, warnings, and hints inline
+  3. Agent can self-correct based on feedback
+`);
+            break;
+        case '/tui':
+            output.log(`
+${c('TUI (Terminal UI):', 'bold')}
+  Status: ${c('Active', 'green')}
+
+${c('Features:', 'bold')}
+  - Syntax highlighting for code blocks
+  - Colored tool call display
+  - Progress spinners
+  - Error/success styling
+
+${c('Code Highlighting Languages:', 'dim')}
+  Python, JavaScript, TypeScript
+
+${c('Test it:', 'dim')}
+  Ask the agent to write code, e.g.:
+  "Write a Python function to calculate factorial"
+`);
+            break;
+        // =========================================================================
+        // UNKNOWN COMMAND
+        // =========================================================================
+        default:
+            output.log(c(`Unknown command: ${cmd}. Type /help`, 'yellow'));
+    }
+    output.log('');
+}
+// =============================================================================
+// CONSOLE OUTPUT ADAPTER
+// =============================================================================
+/**
+ * Create a CommandOutput that writes to console.
+ * Used by REPL mode.
+ */
+export function createConsoleOutput() {
+    return {
+        log: (message) => console.log(message),
+        error: (message) => console.error(message),
+        clear: () => console.clear(),
+    };
+}
+//# sourceMappingURL=handler.js.map