cmdr-agent 1.0.2 → 1.2.0

package/dist/src/cli/repl.js

@@ -1,10 +1,14 @@
 /**
  * Interactive REPL — the primary cmdr interface.
  *
+ * Uses Ink (React for CLI) for robust terminal management,
+ * matching the approach of Claude Code and Gemini CLI.
+ *
  * Streaming output, tool execution display, markdown rendering,
  * AMOLED black + green/purple aesthetic.
  */
-import * as readline from 'readline';
+import React from 'react';
+import { render } from 'ink';
 import { Agent } from '../core/agent.js';
 import { OllamaAdapter } from '../llm/ollama.js';
 import { ToolRegistry } from '../tools/registry.js';
@@ -14,9 +18,8 @@ import { Orchestrator } from '../core/orchestrator.js';
 import { SessionManager } from '../session/session-manager.js';
 import { discoverProject } from '../session/project-context.js';
 import { buildSystemPrompt } from '../session/prompt-builder.js';
-import { startThinking, startToolExec, stopSpinner, spinnerSuccess, spinnerFail, getCompletionSummary } from './spinner.js';
-import { renderWelcome, renderToolExec, renderError, PROMPT_SYMBOL, GREEN, PURPLE, DIM, WHITE, CYAN, renderInfo, GREEN_DIM, YELLOW, RED, SUCCESS_SYMBOL, ERROR_SYMBOL, } from './theme.js';
-import { isSlashCommand, parseSlashCommand, getCommand, } from './commands.js';
+import { resolveContextLength } from '../llm/model-registry.js';
+import { renderWelcome, renderError, GREEN, PURPLE, DIM, WHITE, renderInfo, YELLOW, RED, } from './theme.js';
 import { PermissionManager } from '../core/permissions.js';
 import { saveSession, loadSession, findRecentSession, DebouncedSaver } from '../session/session-persistence.js';
 import { PluginManager } from '../plugins/plugin-manager.js';
@@ -24,6 +27,8 @@ import { McpClient } from '../plugins/mcp-client.js';
 import { loadConfig } from '../config/config-loader.js';
 import { CostTracker } from '../session/cost-tracker.js';
 import { UndoManager } from '../session/undo-manager.js';
+import { startThinking, stopSpinner, spinnerSuccess, spinnerFail, getCompletionSummary, startToolExec } from './spinner.js';
+import App from './ink/App.js';
 export async function startRepl(options) {
     const cwd = process.cwd();
     const verbose = options.verbose ?? false;
@@ -42,8 +47,9 @@ export async function startRepl(options) {
     const projectInfo = projectContext.language !== 'unknown'
         ? `${projectContext.language}${projectContext.framework ? ' / ' + projectContext.framework : ''}`
         : cwd.split('/').pop() || 'unknown';
-    // Session
-    const session = new SessionManager(projectContext);
+    // Session — resolve model's actual context length
+    const modelContextLength = await resolveContextLength(options.model, options.ollamaUrl);
+    const session = new SessionManager(projectContext, modelContextLength);
     // Build system prompt with project context
     const systemPrompt = buildSystemPrompt({
         basePrompt: SOLO_CODER.systemPrompt,
@@ -86,7 +92,6 @@ export async function startRepl(options) {
     // Permission manager
     const permissionManager = new PermissionManager(options.dangerouslySkipPermissions ? 'yolo' : 'normal');
     await permissionManager.loadSettings();
-    // CLI flag overrides persisted mode
     if (options.dangerouslySkipPermissions) {
         permissionManager.setMode('yolo');
     }
@@ -104,21 +109,20 @@ export async function startRepl(options) {
         }
     }
     // Create agent
-    let currentModel = options.model;
+    const currentModel = options.model;
     const agent = new Agent({ ...SOLO_CODER, model: currentModel, systemPrompt }, adapter, toolRegistry, cwd, permissionManager);
-    // --- Welcome ---
+    // --- Welcome banner (prints to normal terminal before Ink takes over) ---
     const modeLabel = permissionManager.getMode() === 'yolo'
         ? YELLOW('⚠ yolo (all tools auto-approved)')
         : permissionManager.getMode() === 'strict'
             ? RED('strict (all tools require approval)')
             : GREEN('normal (write tools require approval)');
-    console.log(renderWelcome(currentModel, projectInfo));
+    console.log(renderWelcome(currentModel, projectInfo, options.version));
     console.log(`  ${DIM('Permissions:')} ${modeLabel}`);
     if (activeTeamConfig) {
         const teamAgents = activeTeamConfig.agents.map(a => a.name).join(', ');
         console.log(`  ${DIM('Team:')} ${PURPLE(activeTeamConfig.name)} ${DIM(`(${teamAgents})`)}`);
     }
-    // Show CMDR.md loading status
     if (projectContext.cmdrInstructions) {
         const lineCount = projectContext.cmdrInstructions.split('\n').length;
         console.log(`  ${DIM(`CMDR.md loaded (${lineCount} lines)`)}`);
@@ -155,438 +159,49 @@ export async function startRepl(options) {
         }
     };
     console.log('');
-    // --- Handle initial prompt if provided ---
+    // --- Handle one-shot prompt (non-interactive) ---
     if (options.initialPrompt) {
-        await handleUserMessage(options.initialPrompt, agent, session, currentModel, permissionManager, verbose, adapter, costTracker, undoManager);
+        await handleOneShot(options.initialPrompt, agent, session, currentModel, permissionManager, verbose, adapter, costTracker, undoManager);
         await doSave();
         return;
     }
-    // --- Interactive REPL ---
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: PROMPT_SYMBOL,
-        terminal: true,
-    });
-    rl.prompt();
-    // --- Paste detection ---
-    // Buffer lines arriving within 50ms of each other and join as single input
-    let pasteBuffer = [];
-    let pasteTimer = null;
-    const PASTE_THRESHOLD_MS = 50;
-    // Async queue — ensures commands are processed sequentially
-    let processing = false;
-    let closed = false;
-    async function processInput(input) {
-        processing = true;
-        try {
-            await processLine(input);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(renderError(msg));
-        }
-        finally {
-            processing = false;
-            if (closed) {
-                process.exit(0);
-            }
-            else {
-                rl.prompt();
-            }
-        }
-    }
-    function flushPasteBuffer() {
-        pasteTimer = null;
-        if (pasteBuffer.length === 0)
-            return;
-        const lines = pasteBuffer.slice();
-        pasteBuffer = [];
-        if (lines.length > 1) {
-            console.log(`  ${DIM(`+${lines.length} lines pasted`)}`);
-        }
-        const merged = lines.join('\n').trim();
-        if (!merged) {
-            rl.prompt();
-            return;
-        }
-        processInput(merged);
-    }
-    async function processLine(input) {
-        // Slash commands
-        if (isSlashCommand(input)) {
-            const { name, args } = parseSlashCommand(input);
-            const cmd = getCommand(name);
-            if (!cmd) {
-                console.log(renderError(`Unknown command: /${name}. Type /help for available commands.`));
-                return;
-            }
-            const result = await cmd.execute(args, {
-                session: session.getState(),
-                switchModel: (model) => {
-                    currentModel = model;
-                },
-                clearHistory: () => {
-                    session.clear();
-                    agent.reset();
-                    permissionManager.resetSession();
-                },
-                ollamaUrl: options.ollamaUrl,
-                adapter,
-                model: currentModel,
-                agentTokenUsage: agent.getState().tokenUsage,
-                permissionManager,
-            });
-            if (result === '__QUIT__') {
-                autoSaver.cancel();
-                session.syncFromAgent(agent.getHistory());
-                if (session.messages.length > 0) {
-                    const sid = await saveSession(session.getState(), currentModel);
-                    console.log(`\n  ${DIM('Session saved:')} ${DIM(sid)}`);
-                }
-                console.log(`\n  ${PURPLE('Goodbye.')} ${DIM('Session ended.')}\n`);
-                closed = true;
-                rl.close();
-                return;
-            }
-            if (result === '__COMPACT__') {
-                session.syncFromAgent(agent.getHistory());
-                const beforeTokens = session.tokenCount;
-                const stats = await session.compact(adapter, currentModel);
-                agent.replaceMessages(session.messages);
-                const afterTokens = session.tokenCount;
-                console.log(renderInfo(`${DIM(`◇ compacted: ${stats.before} messages → ${stats.after} messages (saved ~${stats.tokensSaved} tokens)`)}`));
-                return;
-            }
-            if (result === '__DIFF__') {
-                const gitTool = toolRegistry.get('git_diff');
-                if (gitTool) {
-                    const diffResult = await gitTool.execute({ staged: false }, {
-                        agent: { name: 'cmdr', role: 'assistant', model: currentModel },
-                        cwd,
-                    });
-                    console.log(`\n${WHITE(diffResult.data)}\n`);
-                }
-                return;
-            }
-            if (result === '__SESSION_SAVE__') {
-                session.syncFromAgent(agent.getHistory());
-                if (session.messages.length > 0) {
-                    const sid = await saveSession(session.getState(), currentModel);
-                    console.log(renderInfo(`Session saved: ${DIM(sid)}`));
-                }
-                else {
-                    console.log(renderInfo('No messages to save.'));
-                }
-                return;
-            }
-            if (typeof result === 'string' && result.startsWith('__SESSION_RESUME__:')) {
-                const sessionId = result.slice('__SESSION_RESUME__:'.length);
-                const saved = await loadSession(sessionId);
-                if (saved) {
-                    agent.replaceMessages(saved.messages);
-                    session.syncFromAgent(saved.messages);
-                    console.log(renderInfo(`Resumed session ${DIM(saved.id)} (${saved.messages.length} messages)`));
-                }
-                else {
-                    console.log(renderError(`Session not found: ${sessionId}`));
-                }
-                return;
-            }
-            if (typeof result === 'string' && result.startsWith('__TEAM_SWITCH__:')) {
-                const preset = result.slice('__TEAM_SWITCH__:'.length);
-                const teamCfg = getTeamPreset(preset);
-                if (teamCfg) {
-                    activeTeamConfig = teamCfg;
-                    const teamAgents = teamCfg.agents.map(a => a.name).join(', ');
-                    console.log(renderInfo(`Switched to team: ${PURPLE(teamCfg.name)} (${teamAgents})`));
-                }
-                else {
-                    console.log(renderError(`Unknown team: ${preset}. Use: review, fullstack, security`));
-                }
-                return;
-            }
-            if (result === '__AGENTS_STATUS__') {
-                if (!activeTeamConfig) {
-                    console.log(renderInfo(`Solo mode (agent: ${GREEN('cmdr')}). Use /team <preset> for multi-agent.`));
-                }
-                else {
-                    const status = orchestrator.getStatus();
-                    const lines = ['', `  ${PURPLE.bold(`Team: ${activeTeamConfig.name}`)}`, ''];
-                    for (const agentCfg of activeTeamConfig.agents) {
-                        const agentStatus = status?.agents.find(a => a.name === agentCfg.name);
-                        const statusLabel = agentStatus ? DIM(agentStatus.status) : DIM('idle');
-                        lines.push(`  ${GREEN('•')} ${WHITE(agentCfg.name.padEnd(12))} ${statusLabel}`);
-                    }
-                    lines.push('');
-                    console.log(lines.join('\n'));
-                }
-                return;
-            }
-            if (result === '__TASKS_STATUS__') {
-                const status = orchestrator.getStatus();
-                if (!status) {
-                    console.log(renderInfo('No active team or tasks.'));
-                }
-                else {
-                    const s = status.tasks;
-                    if (s) {
-                        console.log(renderInfo(`Tasks: ${GREEN(`${s.completed} done`)} · ${YELLOW(`${s.in_progress} running`)} · ${DIM(`${s.pending} pending`)} · ${s.failed > 0 ? RED(`${s.failed} failed`) : DIM('0 failed')}`));
-                    }
-                }
-                return;
-            }
-            if (result === '__COST__') {
-                const summary = costTracker.getSummary();
-                const elapsed = costTracker.formatElapsed();
-                const lines = [
-                    '',
-                    `  ${PURPLE.bold('Token usage')}`,
-                    '',
-                    `  ${DIM('Model:')}          ${WHITE(summary.model)}`,
-                    `  ${DIM('Turns:')}          ${WHITE(String(summary.turns))}`,
-                    `  ${DIM('Input tokens:')}   ${WHITE(String(summary.totalInputTokens))}`,
-                    `  ${DIM('Output tokens:')}  ${WHITE(String(summary.totalOutputTokens))}`,
-                    `  ${DIM('Total tokens:')}   ${GREEN(String(summary.totalTokens))}`,
-                    `  ${DIM('Tool calls:')}     ${WHITE(String(summary.totalToolCalls))}`,
-                    `  ${DIM('Avg/turn:')}       ${WHITE(String(summary.avgTokensPerTurn))}`,
-                    `  ${DIM('Session time:')}   ${WHITE(elapsed)}`,
-                    '',
-                ];
-                console.log(lines.join('\n'));
-                return;
-            }
-            if (result === '__UNDO__') {
-                if (undoManager.count === 0) {
-                    console.log(renderInfo('Nothing to undo.'));
-                }
-                else {
-                    const change = await undoManager.undoLast();
-                    if (change) {
-                        const action = change.originalContent === null ? 'deleted' : 'restored';
-                        const fname = change.path.split('/').pop() ?? change.path;
-                        console.log(renderInfo(`Undid ${change.type} on ${GREEN(fname)} (${action})`));
-                    }
-                }
-                return;
-            }
-            if (typeof result === 'string' && result.startsWith('__PLUGIN__:')) {
-                const sub = result.slice('__PLUGIN__:'.length).trim();
-                if (sub === 'list' || !sub) {
-                    const plugins = pluginManager.list();
-                    if (plugins.length === 0) {
-                        console.log(renderInfo('No plugins loaded. Add plugins to ~/.cmdr/config.toml'));
-                    }
-                    else {
-                        const lines = ['', `  ${PURPLE.bold('Loaded plugins')}`, ''];
-                        for (const p of plugins) {
-                            const hooks = p.hooks ? Object.keys(p.hooks).length : 0;
-                            const tools = p.tools?.length ?? 0;
-                            console.log(`  ${GREEN('•')} ${WHITE(p.name)} v${p.version} ${DIM(`(${hooks} hooks, ${tools} tools)`)}`);
-                        }
-                        lines.push('');
-                        console.log(lines.join('\n'));
-                    }
-                }
-                return;
-            }
-            if (typeof result === 'string' && result.startsWith('__MCP__:')) {
-                const sub = result.slice('__MCP__:'.length).trim().split(/\s+/);
-                const action = sub[0];
-                if (action === 'list' || !action) {
-                    const conns = mcpClient.listConnections();
-                    if (conns.length === 0) {
-                        console.log(renderInfo('No MCP servers connected. Add to ~/.cmdr/config.toml or use /mcp connect <name> <url>'));
-                    }
-                    else {
-                        const lines = ['', `  ${PURPLE.bold('MCP servers')}`, ''];
-                        for (const c of conns) {
-                            const status = c.connected ? GREEN('connected') : RED('disconnected');
-                            lines.push(`  ${GREEN('•')} ${WHITE(c.name)} ${DIM(c.url)} ${status} ${DIM(`(${c.tools} tools)`)}`);
-                        }
-                        lines.push('');
-                        console.log(lines.join('\n'));
-                    }
-                }
-                else if (action === 'connect') {
-                    const name = sub[1];
-                    const url = sub[2];
-                    if (!name || !url) {
-                        console.log(renderInfo('Usage: /mcp connect <name> <url>'));
-                    }
-                    else {
-                        try {
-                            const tools = await mcpClient.connect({ name, url });
-                            mcpClient.registerTools(toolRegistry);
-                            console.log(renderInfo(`Connected to ${name}: ${tools.length} tools discovered`));
-                        }
-                        catch (err) {
-                            const msg = err instanceof Error ? err.message : String(err);
-                            console.log(renderError(msg));
-                        }
-                    }
-                }
-                else if (action === 'disconnect') {
-                    const name = sub[1];
-                    if (name && mcpClient.disconnect(name)) {
-                        console.log(renderInfo(`Disconnected from ${name}`));
-                    }
-                    else {
-                        console.log(renderError(`MCP server "${name}" not found`));
-                    }
-                }
-                return;
-            }
-            if (result)
-                console.log(result);
-            return;
-        }
-        // Regular message — team mode or solo mode
-        if (activeTeamConfig) {
-            await handleTeamMessage(input, orchestrator, activeTeamConfig, currentModel, verbose);
-        }
-        else {
-            await handleUserMessage(input, agent, session, currentModel, permissionManager, verbose, adapter, costTracker, undoManager, () => {
-                autoSaver.schedule(doSave);
-            });
-        }
-    }
-    rl.on('line', (line) => {
-        pasteBuffer.push(line);
-        if (pasteTimer)
-            clearTimeout(pasteTimer);
-        pasteTimer = setTimeout(flushPasteBuffer, PASTE_THRESHOLD_MS);
+    // --- Interactive REPL via Ink ---
+    const app = render(React.createElement(App, {
+        agent,
+        session,
+        model: currentModel,
+        permissionManager,
+        adapter,
+        orchestrator,
+        activeTeamConfig,
+        costTracker,
+        undoManager,
+        pluginManager,
+        mcpClient,
+        toolRegistry,
+        ollamaUrl: options.ollamaUrl,
+        verbose,
+        doSave,
+        autoSaver,
+    }), {
+        exitOnCtrlC: false, // We handle Ctrl+C ourselves
+        patchConsole: false, // Ban console logs from being intercepted during banner
     });
-    rl.on('close', async () => {
-        autoSaver.cancel();
-        if (!closed) {
-            session.syncFromAgent(agent.getHistory());
-            if (session.messages.length > 0) {
-                try {
-                    const sid = await saveSession(session.getState(), currentModel);
-                    console.log(`\n  ${DIM('Session saved:')} ${DIM(sid)}`);
-                }
-                catch {
-                    // best effort
-                }
-            }
-            console.log(`\n  ${PURPLE('Goodbye.')} ${DIM('Session ended.')}\n`);
-        }
-        if (processing) {
-            closed = true;
-        }
-        else {
-            process.exit(0);
-        }
-    });
-}
-// ---------------------------------------------------------------------------
-// Approval prompt — asks the user to approve a tool call
-// ---------------------------------------------------------------------------
-function promptApproval(toolName, input, riskLevel) {
-    return new Promise((resolve) => {
-        const riskColor = riskLevel === 'dangerous' ? RED : YELLOW;
-        const riskLabel = riskColor(riskLevel.toUpperCase());
-        // Show the tool call details
-        console.log('');
-        console.log(`  ${YELLOW('⚠')}  ${WHITE('Tool approval required')} ${DIM('[')}${riskLabel}${DIM(']')}`);
-        console.log(`  ${DIM('Tool:')}  ${CYAN(toolName)}`);
-        // Show a summary of key arguments
-        for (const [key, val] of Object.entries(input)) {
-            const display = typeof val === 'string'
-                ? val.length > 120 ? val.slice(0, 120) + DIM('...') : val
-                : JSON.stringify(val).slice(0, 120);
-            console.log(`  ${DIM(key + ':')}  ${WHITE(display)}`);
-        }
-        console.log('');
-        console.log(`  ${GREEN('y')}${DIM('es')}  ${DIM('/')}  ${RED('n')}${DIM('o')}  ${DIM('/')}  ${PURPLE('a')}${DIM('lways allow this tool')}`);
-        // Create a one-shot readline for the approval prompt
-        const approvalRl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-            terminal: true,
-        });
-        approvalRl.question(`  ${YELLOW('?')} `, (answer) => {
-            approvalRl.close();
-            const trimmed = answer.trim().toLowerCase();
-            if (trimmed === 'y' || trimmed === 'yes' || trimmed === '') {
-                resolve('allow');
-            }
-            else if (trimmed === 'a' || trimmed === 'always') {
-                resolve('allow-always');
-            }
-            else {
-                resolve('deny');
-            }
-        });
-    });
-}
-// ---------------------------------------------------------------------------
-// Tool result summary — collapsed single-line display
-// ---------------------------------------------------------------------------
-function summarizeToolResult(toolName, input, content, isError) {
-    const lineCount = content.split('\n').length;
-    const prefix = isError ? ERROR_SYMBOL : SUCCESS_SYMBOL;
-    let summary;
-    switch (toolName) {
-        case 'file_read': {
-            const file = input.path ?? 'unknown';
-            const fname = file.split('/').pop() ?? file;
-            summary = `${fname} (${lineCount} lines)`;
-            break;
-        }
-        case 'glob': {
-            const pattern = input.pattern ?? '*';
-            const matches = content === '(no matches)' ? 0 : lineCount;
-            summary = `${pattern} (${matches} matches)`;
-            break;
-        }
-        case 'bash': {
-            const cmd = input.command ?? '';
-            const truncCmd = cmd.length > 60 ? cmd.slice(0, 57) + '...' : cmd;
-            // Extract exit code from result if present
-            const exitMatch = content.match(/\[exit code: (\d+)\]/);
-            const exitCode = exitMatch ? exitMatch[1] : '0';
-            summary = `\`${truncCmd}\` exit=${exitCode} (${lineCount} lines)`;
-            break;
-        }
-        case 'grep': {
-            const pattern = input.pattern ?? '';
-            const matches = content === '(no matches)' ? 0 : lineCount;
-            summary = `/${pattern}/ (${matches} matches)`;
-            break;
-        }
-        case 'think': {
-            const thought = input.thought ?? '';
-            const preview = thought.length > 60 ? thought.slice(0, 57) + '...' : thought;
-            summary = preview;
-            break;
-        }
-        default: {
-            const bytes = Buffer.byteLength(content, 'utf-8');
-            summary = `${bytes > 1024 ? Math.round(bytes / 1024) + ' KB' : bytes + ' B'}`;
-            break;
-        }
-    }
-    return `  ${prefix} ${DIM(toolName)}  ${DIM(summary)}`;
+    await app.waitUntilExit();
 }
 // ---------------------------------------------------------------------------
-// Message handler — streaming output with tool execution display
+// One-shot handler (non-interactive --prompt mode)
 // ---------------------------------------------------------------------------
-async function handleUserMessage(message, agent, session, model, permissionManager, verbose, adapter, costTracker, undoManager, onAfterResponse) {
-    console.log(''); // spacing
+async function handleOneShot(message, agent, session, model, permissionManager, verbose, adapter, costTracker, undoManager) {
+    console.log('');
     startThinking();
     let fullOutput = '';
     let firstText = true;
     let currentTool = '';
     let currentToolInput = {};
     let toolCallCount = 0;
-    // Build callbacks with the approval gate
-    const callbacks = {
-        onToolApproval: (toolName, input, riskLevel) => promptApproval(toolName, input, riskLevel),
-    };
     try {
-        for await (const event of agent.stream(message, callbacks)) {
+        for await (const event of agent.stream(message)) {
             switch (event.type) {
                 case 'text': {
                     if (firstText) {
@@ -596,8 +211,6 @@ async function handleUserMessage(message, agent, session, model, permissionManag
                     }
                     const chunk = event.data;
                     fullOutput += chunk;
-                    // Stream raw text token-by-token (no markdown on partial chunks)
-                    // Handle newlines by adding the prefix
                     const formatted = chunk.replace(/\n/g, `\n  ${PURPLE('│')} `);
                     process.stdout.write(formatted);
                     break;
@@ -605,7 +218,6 @@ async function handleUserMessage(message, agent, session, model, permissionManag
                 case 'tool_use': {
                     stopSpinner();
                     if (!firstText) {
-                        // Terminate previous text stream line
                         process.stdout.write('\n');
                         firstText = true;
                     }
@@ -613,46 +225,36 @@ async function handleUserMessage(message, agent, session, model, permissionManag
                     currentTool = block.name;
                     currentToolInput = block.input;
                     toolCallCount++;
-                    // Record file state for undo before write/edit tools
-                    if (undoManager && (block.name === 'file_write' || block.name === 'file_edit')) {
+                    if (block.name === 'file_write' || block.name === 'file_edit') {
                         const filePath = (block.input.path ?? block.input.file_path);
-                        if (filePath) {
+                        if (filePath)
                             await undoManager.recordBefore(filePath, block.name === 'file_write' ? 'write' : 'edit');
-                        }
                     }
-                    console.log(renderToolExec(block.name, block.input));
+                    const toolSummary = Object.entries(block.input)
+                        .map(([k, v]) => {
+                        const val = typeof v === 'string' ? v.slice(0, 80) : JSON.stringify(v).slice(0, 80);
+                        return `${DIM(k + ':')} ${WHITE(val)}`;
+                    })
+                        .join(' ');
+                    console.log(`  ${GREEN('⚡')} ${GREEN.bold(block.name)} ${toolSummary}`);
                     startToolExec(block.name);
                     break;
                 }
                 case 'tool_result': {
                     const block = event.data;
-                    if (block.is_error) {
+                    if (block.is_error)
                         spinnerFail(currentTool);
-                    }
-                    else {
+                    else
                         spinnerSuccess(currentTool);
-                    }
-                    if (verbose) {
-                        // Full output in verbose mode
-                        const truncated = block.content.length > 2000
-                            ? block.content.slice(0, 2000) + DIM('\n... (truncated)')
-                            : block.content;
-                        const prefix = block.is_error ? ERROR_SYMBOL : SUCCESS_SYMBOL;
-                        console.log(`  ${prefix} ${DIM(currentTool + ':')} ${block.is_error ? RED(truncated) : DIM(truncated)}`);
-                    }
-                    else {
-                        console.log(summarizeToolResult(currentTool, currentToolInput, block.content, block.is_error));
-                    }
                     currentTool = '';
                     currentToolInput = {};
                     startThinking();
                     firstText = true;
                     break;
                 }
-                case 'done': {
+                case 'done':
                     stopSpinner();
                     break;
-                }
                 case 'error': {
                     stopSpinner();
                     const err = event.data;
@@ -665,22 +267,12 @@ async function handleUserMessage(message, agent, session, model, permissionManag
     catch (err) {
         stopSpinner();
         const msg = err instanceof Error ? err.message : String(err);
-        if (msg.includes('not found') || msg.includes('404') || (msg.includes('model') && msg.includes('pull'))) {
-            console.error(renderError(`Model '${model}' not found. Run ${GREEN('/models')} to see available models or ${GREEN('/model <name>')} to switch.`));
-        }
-        else {
-            console.error(renderError(msg));
-        }
+        console.error(renderError(msg));
     }
-    // Ensure we end the text block with a newline
-    if (!firstText) {
+    if (!firstText)
         process.stdout.write('\n');
-    }
-    // Add spacing after response
-    if (fullOutput) {
+    if (fullOutput)
         console.log('');
-    }
-    // Show turn summary with whimsical verb
     const state = agent.getState();
     const tokens = state.tokenUsage;
     const summary = getCompletionSummary();
@@ -688,72 +280,7 @@ async function handleUserMessage(message, agent, session, model, permissionManag
         ? `  ${DIM('·')}  ${DIM(`${tokens.input_tokens} in / ${tokens.output_tokens} out`)}`
         : '';
     console.log(`  ${DIM(summary)}${tokenInfo}`);
-    // Record cost data
-    costTracker?.record(model, tokens.input_tokens, tokens.output_tokens, toolCallCount);
-    // Sync agent messages into session for compaction tracking
+    costTracker.record(model, tokens.input_tokens, tokens.output_tokens, toolCallCount);
     session.syncFromAgent(agent.getHistory());
-    // Auto-compact if context is getting full
-    if (session.shouldCompact()) {
-        try {
-            const stats = await session.compact(adapter, model);
-            agent.replaceMessages(session.messages);
-            console.log(`  ${DIM(`◇ compacted: ${stats.before} messages → ${stats.after} messages (saved ~${stats.tokensSaved} tokens)`)}`);
-        }
-        catch {
-            // best effort — don't break the REPL
-        }
-    }
-    // Trigger debounced auto-save
-    onAfterResponse?.();
-    console.log(GREEN_DIM('─'.repeat(60)));
-    console.log('');
-}
-// ---------------------------------------------------------------------------
-// Team message handler — runs goal through the orchestrator
-// ---------------------------------------------------------------------------
-async function handleTeamMessage(goal, orchestrator, teamConfig, model, verbose) {
-    console.log('');
-    console.log(`  ${PURPLE('◈')} Running team ${PURPLE.bold(teamConfig.name)} with ${teamConfig.agents.length} agents...`);
-    console.log('');
-    startThinking();
-    try {
-        const result = await orchestrator.runTeam(teamConfig, goal);
-        stopSpinner();
-        // Display results from each agent
-        for (const [agentName, agentResult] of result.agentResults) {
-            const status = agentResult.success ? GREEN('✓') : RED('✗');
-            console.log(`  ${status} ${CYAN(agentName)}`);
-            if (agentResult.output) {
-                const lines = agentResult.output.split('\n');
-                const displayLines = verbose ? lines : lines.slice(0, 20);
-                for (const line of displayLines) {
-                    console.log(`  ${PURPLE('│')} ${line}`);
-                }
-                if (!verbose && lines.length > 20) {
-                    console.log(`  ${PURPLE('│')} ${DIM(`... ${lines.length - 20} more lines (use --verbose)`)}`);
-                }
-                console.log('');
-            }
-            // Tool call summary
-            if (agentResult.toolCalls.length > 0) {
-                const tools = agentResult.toolCalls.map(t => t.toolName);
-                const unique = [...new Set(tools)];
-                console.log(`  ${DIM(`  tools: ${unique.join(', ')} (${tools.length} calls)`)}`);
-            }
-        }
-        // Summary
-        const usage = result.totalTokenUsage;
-        const summary = getCompletionSummary();
-        const tokenInfo = `${usage.input_tokens} in / ${usage.output_tokens} out`;
-        console.log(`  ${DIM(summary)}  ${DIM('·')}  ${DIM(tokenInfo)}`);
-        console.log(`  ${result.success ? GREEN('Team completed successfully') : RED('Team had failures')}`);
-    }
-    catch (err) {
-        stopSpinner();
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(renderError(msg));
-    }
-    console.log(GREEN_DIM('─'.repeat(60)));
-    console.log('');
 }
 //# sourceMappingURL=repl.js.map