@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/repl.js

@@ -1,1151 +0,0 @@
-/**
- * REPL (Read-Eval-Print Loop)
- *
- * Main orchestration for the interactive agent session.
- * Coordinates between input, agent execution, and output.
- *
- * Uses event-driven architecture with Footer component for:
- * - Persistent todo list while agent runs
- * - Persistent input prompt (always visible)
- * - Input queueing during agent execution
- * - Esc to cancel running agent
- */
-import { exec } from 'child_process';
-import { getToolPermissionInfo } from './agent.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import pc from 'picocolors';
-import { debug, debugError } from './debug.js';
-import { debugLog } from './utils/debug-log.js';
-import { getNextMode, MODE_INFO } from './ui/types.js';
-import { createInitialState, updateTodos, setAgentRunning } from './state.js';
-import { Footer } from './ui/footer.js';
-import * as conversation from './ui/conversation.js';
-import * as overlays from './ui/overlays.js';
-import * as terminal from './ui/terminal.js';
-import { TerminalRenderer, RenderMode } from './ui/terminal-renderer.js';
-import { resolveCommand } from './commands.js';
-// Note: All overlay imports (showConfigOverlay, showModelOverlay, showThemeOverlay, showMascotOverlay, etc.)
-// are now handled by command handlers in ./commands/handlers/
-import { showToolsOverlay } from './ui/tools-overlay.js';
-import { registerFooterCallbacks } from './ui/overlay-controller.js';
-import { getCustomCommandRegistry, commandRegistry, registerAllHandlers } from './commands/index.js';
-import { getPermissionMode } from './settings/index.js';
-// Note: findBacklogPath, parseBacklogItems moved to command handlers
-import { isOverlayActive } from './shared-handlers.js';
-import { getActiveProject } from './tools/project-db.js';
-import { getAnchorManager } from './anchors/index.js';
-import { isMemoryInput, handleMemoryInput } from './input-handlers/index.js';
-// Helper functions extracted to reduce file size
-import { selectToolNamesByIntent } from './repl-helpers.js';
-// =============================================================================
-// REPL Class
-// =============================================================================
-export class REPL {
-    agent;
-    model;
-    currentModel; // Can be hot-switched
-    provider;
-    version;
-    showFiltering;
-    onModeChange;
-    onAgentFinish;
-    clearSubagentTracking;
-    startTime;
-    initialCommand;
-    state;
-    footer;
-    renderer;
-    // Session stats
-    sessionInputTokens = 0;
-    sessionOutputTokens = 0;
-    sessionRequests = 0;
-    // Running state
-    isRunning = false;
-    shouldReturnToMenu = false;
-    agentRunning = false;
-    abortController = null;
-    // Promise for waiting on REPL exit
-    exitResolve = null;
-    // Text buffer flush function (set during processMessage, allows permission handler to flush)
-    textBufferFlusher = null;
-    constructor(options) {
-        this.agent = options.agent;
-        this.model = options.model;
-        this.currentModel = options.model; // Start with same model, can be hot-switched
-        this.provider = options.provider ?? 'unknown';
-        this.version = options.version ?? '0.0.1';
-        this.showFiltering = options.showFiltering ?? false;
-        this.onModeChange = options.onModeChange;
-        this.onAgentFinish = options.onAgentFinish;
-        this.clearSubagentTracking = options.clearSubagentTracking;
-        this.startTime = new Date();
-        this.initialCommand = options.initialCommand;
-        this.state = createInitialState(this.model);
-        // Map permission mode setting to AgentMode
-        const permissionMode = getPermissionMode();
-        const initialMode = permissionMode === 'bypass' ? 'auto-accept' :
-            permissionMode === 'plan' ? 'plan' : 'normal';
-        this.footer = new Footer({
-            showSeparators: true,
-            initialMode,
-        });
-        // Initialize TerminalRenderer in REPL mode
-        // TODO: Scroll regions disabled until incremental rebuild is complete
-        this.renderer = new TerminalRenderer({
-            initialMode: RenderMode.REPL,
-            useScrollRegions: false, // DISABLED: Use legacy mode for now
-            debug: false,
-        });
-        // Connect footer to renderer (enables external renderer mode on footer)
-        this.renderer.setFooter(this.footer);
-        // Connect conversation output to renderer
-        conversation.setRenderer(this.renderer);
-        // Note: renderer.start() is called in run(), not here
-        // This ensures proper startup sequence: footer.start() → renderer.start() → printWelcome()
-        // Notify external state handler of initial mode
-        if (this.onModeChange && initialMode !== 'normal') {
-            this.onModeChange(initialMode);
-        }
-        // Set up event handlers
-        this.setupEventHandlers();
-        // Notify that footer is ready with pause/resume/setSuggestion functions
-        if (options.onFooterReady) {
-            options.onFooterReady(() => { this.footer.pauseAnimation(); }, () => { this.footer.resumeAnimation(); }, (action) => { this.footer.setSuggestion(action); });
-        }
-        // Provide text buffer flush function (for permission handler to flush before overlay)
-        if (options.onTextBufferReady) {
-            options.onTextBufferReady(() => {
-                if (this.textBufferFlusher) {
-                    this.textBufferFlusher();
-                }
-            });
-        }
-        // Provide subagent tracking callbacks (for agent to report subagent activity)
-        if (options.onSubagentReady) {
-            options.onSubagentReady({
-                onStart: (agentId, agentType, description) => {
-                    this.footer.onSubagentStart(agentId, agentType, description);
-                },
-                onToolUse: (agentId, toolName, summary) => {
-                    this.footer.onSubagentToolUse(agentId, toolName, summary);
-                },
-                onEnd: (agentId, success, tokenCount, error) => {
-                    this.footer.onSubagentEnd(agentId, success, tokenCount, error);
-                },
-            });
-        }
-        // Register footer callbacks for overlay controller (used by tools like ask_user)
-        registerFooterCallbacks(() => { this.footer.pauseAnimation(); }, () => { this.footer.resumeAnimation(); });
-        // Register all command handlers (idempotent - safe to call multiple times)
-        registerAllHandlers();
-    }
-    /**
-     * Reload project-specific anchors when switching projects
-     * Clears old project anchors and loads new project anchors
-     */
-    reloadProjectAnchors(oldProjectId, newProjectId) {
-        // Clear old project anchors (if any)
-        if (oldProjectId) {
-            const clearedCount = this.agent.clearAnchors({ projectId: oldProjectId });
-            debug('anchors', `Cleared ${String(clearedCount)} anchors for project ${oldProjectId}`);
-        }
-        // Load new project anchors from disk
-        const newProjectAnchors = getAnchorManager(newProjectId).getAll({ scope: 'persistent' });
-        debug('anchors', `Loading ${String(newProjectAnchors.length)} anchors for project ${newProjectId}`);
-        // Add new project anchors to the agent
-        for (const anchor of newProjectAnchors) {
-            this.agent.addAnchor({
-                id: anchor.id,
-                content: anchor.content,
-                priority: anchor.priority,
-                scope: anchor.scope,
-                tags: anchor.tags,
-                projectId: newProjectId,
-            });
-        }
-        if (newProjectAnchors.length > 0) {
-            conversation.printInfo(`  Anchors: ${String(newProjectAnchors.length)} loaded for project`);
-        }
-    }
-    /**
-     * Set up Footer event handlers
-     */
-    setupEventHandlers() {
-        // Handle submit - process message or it gets queued by Footer
-        this.footer.on('submit', (input) => {
-            if (!this.agentRunning && input.trim()) {
-                void this.handleSubmit(input);
-            }
-            // If agent is running, Footer automatically queues the input
-        });
-        // Handle slash commands
-        this.footer.on('command', (command, args) => {
-            debugLog('REPL:command', `received /${command}`);
-            // NOTE: Don't pause footer here - let overlays pause when ready to render
-            // This prevents blank screen flash when overlays have slow constructors
-            void this.handleCommand(command, args).then((shouldContinue) => {
-                debugLog('REPL:command', 'handler complete');
-                if (!shouldContinue) {
-                    // Exiting - don't restart input, just resolve
-                    this.isRunning = false;
-                    if (this.exitResolve) {
-                        this.exitResolve();
-                    }
-                }
-                else {
-                    // Overlays handle their own pause/resume via lifecycle
-                    // For non-overlay commands, we need to restart the input prompt
-                    // (finishInput() stopped it when user pressed Enter)
-                    this.footer.restartInput();
-                }
-            });
-        });
-        // Handle Esc - abort running agent
-        this.footer.on('escape', () => {
-            if (this.agentRunning && this.abortController) {
-                this.abortController.abort();
-                conversation.printWarning('Agent execution cancelled');
-            }
-        });
-        // Handle Ctrl+C - exit REPL
-        this.footer.on('cancel', () => {
-            this.isRunning = false;
-            if (this.exitResolve) {
-                this.exitResolve();
-            }
-        });
-        // Handle Shift+Tab - cycle modes
-        this.footer.on('modeChange', () => {
-            this.cycleMode();
-        });
-    }
-    /**
-     * Cycle through agent modes (normal -> auto-accept -> plan -> normal)
-     */
-    cycleMode() {
-        const currentMode = this.footer.getMode();
-        const nextMode = getNextMode(currentMode);
-        this.footer.setMode(nextMode);
-        // Notify external state handler
-        if (this.onModeChange) {
-            this.onModeChange(nextMode);
-        }
-        // Show feedback
-        const modeInfo = MODE_INFO[nextMode];
-        this.footer.clearForOutput();
-        conversation.printInfo(`Mode: ${modeInfo.label} - ${modeInfo.description}`);
-        this.footer.forceRender();
-    }
-    // ===========================================================================
-    // Public API
-    // ===========================================================================
-    /**
-     * Start the REPL (event-driven)
-     */
-    async run() {
-        this.isRunning = true;
-        // Set terminal title, clear screen, and show welcome
-        terminal.setTitle('compilr');
-        terminal.clearScreen();
-        conversation.printWelcome(this.model, this.version, getActiveProject()?.displayName ?? null);
-        // Start footer (begins render loop and input capture)
-        this.footer.start();
-        // Start renderer (in legacy mode, this is mostly a no-op)
-        this.renderer.start();
-        // Set project name in footer
-        const activeProject = getActiveProject();
-        if (activeProject) {
-            this.footer.setProjectName(activeProject.displayName);
-        }
-        // Execute initial command if provided (e.g., /design from project menu)
-        if (this.initialCommand) {
-            const cmd = this.initialCommand;
-            // Give footer a moment to render before running command
-            setTimeout(() => {
-                void this.handleCommand(cmd, '');
-            }, 100);
-        }
-        // Wait for exit signal
-        await this.waitForExit();
-        // Cleanup
-        this.footer.stop();
-        this.renderer.stop();
-        // Only print goodbye when actually exiting (not when returning to menu)
-        if (!this.shouldReturnToMenu) {
-            terminal.writeLine('');
-            conversation.printInfo('Goodbye!');
-        }
-    }
-    /**
-     * Wait for REPL exit
-     */
-    waitForExit() {
-        return new Promise((resolve) => {
-            this.exitResolve = resolve;
-        });
-    }
-    /**
-     * Get current model
-     */
-    getCurrentModel() {
-        return this.currentModel;
-    }
-    /**
-     * Get current provider
-     */
-    getProvider() {
-        return this.provider;
-    }
-    /**
-     * Set model for hot-switching (within same provider)
-     */
-    setModel(model) {
-        this.currentModel = model;
-        conversation.printInfo(`Model switched to: ${model}`);
-    }
-    /**
-     * Set the agent mode programmatically (e.g., from permission handler)
-     */
-    setMode(mode) {
-        this.footer.setMode(mode);
-        // Notify external state handler
-        if (this.onModeChange) {
-            this.onModeChange(mode);
-        }
-        // Show feedback
-        const modeInfo = MODE_INFO[mode];
-        this.footer.clearForOutput();
-        conversation.printInfo(`Mode: ${modeInfo.label} - ${modeInfo.description}`);
-        this.footer.forceRender();
-    }
-    /**
-     * Stop the REPL
-     */
-    stop() {
-        this.isRunning = false;
-        this.footer.stop();
-        this.renderer.stop();
-        if (this.exitResolve) {
-            this.exitResolve();
-        }
-    }
-    /**
-     * Check if the user requested to return to the startup menu
-     */
-    wantsReturnToMenu() {
-        return this.shouldReturnToMenu;
-    }
-    /**
-     * Handle submitted input (processes message and queued inputs)
-     */
-    async handleSubmit(input) {
-        // Clear any previous suggestion when new input is submitted
-        this.footer.setSuggestion(null);
-        // Handle memory prefix: "# note" creates a persistent anchor
-        if (isMemoryInput(input)) {
-            handleMemoryInput(input, { agent: this.agent, footer: this.footer });
-            return;
-        }
-        await this.processMessage(input);
-        // Process queued inputs (FIFO)
-        while (this.footer.hasQueuedInput() && this.isRunning) {
-            const queued = this.footer.popQueuedInput();
-            if (queued) {
-                await this.processMessage(queued);
-            }
-        }
-    }
-    // ===========================================================================
-    // Command Handling
-    // ===========================================================================
-    /**
-     * Create command context for handler execution.
-     */
-    getCommandContext() {
-        return {
-            // Agent and model
-            agent: this.agent,
-            model: this.model,
-            currentModel: this.currentModel,
-            provider: this.provider,
-            version: this.version,
-            // UI components
-            footer: this.footer,
-            state: this.state,
-            // Session info
-            startTime: this.startTime,
-            sessionInputTokens: this.sessionInputTokens,
-            sessionOutputTokens: this.sessionOutputTokens,
-            sessionRequests: this.sessionRequests,
-            // Callbacks
-            onModeChange: this.onModeChange,
-            setShouldReturnToMenu: (value) => {
-                this.shouldReturnToMenu = value;
-            },
-            // REPL methods (bound to this instance)
-            processMessage: (message, options) => this.processMessage(message, options),
-            handleCommand: (cmd, cmdArgs) => this.handleCommand(cmd, cmdArgs),
-            setModel: (model) => {
-                this.setModel(model);
-            },
-            // UI helper methods
-            showTools: () => this.showTools(),
-            showTokens: () => {
-                this.showTokens();
-            },
-            showContext: () => {
-                this.showContext();
-            },
-            showStatus: () => {
-                this.showStatus();
-            },
-            showTodos: () => {
-                this.showTodos();
-            },
-            handleCompact: () => this.handleCompact(),
-            handleExport: (exportArgs) => this.handleExport(exportArgs),
-            reloadProjectAnchors: (oldId, newId) => {
-                this.reloadProjectAnchors(oldId, newId);
-            },
-        };
-    }
-    /**
-     * Handle slash command
-     * Returns false if REPL should exit
-     */
-    async handleCommand(command, args) {
-        // Resolve aliases to canonical command name
-        const resolved = resolveCommand(command);
-        if (!resolved) {
-            // Check if it's a custom command
-            const customRegistry = getCustomCommandRegistry();
-            if (customRegistry.has(command)) {
-                // Expand custom command and send as message
-                const customArgs = args ? args.split(' ').filter(a => a.trim()) : [];
-                const expanded = customRegistry.expand(command, customArgs);
-                if (expanded) {
-                    // Resume animation before processing (it was paused for overlay commands)
-                    this.footer.resumeAnimation();
-                    // Process as a regular message
-                    await this.processMessage(expanded);
-                    return true;
-                }
-            }
-            conversation.printWarning(`Unknown command: /${command}`);
-            conversation.printInfo('Type /help to see available commands');
-            return true;
-        }
-        // Try command registry first (for extracted handlers)
-        const ctx = this.getCommandContext();
-        const registryResult = await commandRegistry.execute(resolved, args, ctx);
-        if (registryResult !== null) {
-            return registryResult;
-        }
-        // All commands are now handled by the registry
-        // This shouldn't happen if resolveCommand works correctly
-        conversation.printWarning(`Unknown command: /${command}`);
-        return true;
-    }
-    // ===========================================================================
-    // Message Processing
-    // ===========================================================================
-    /**
-     * Strip '@' prefix from @path mentions before sending to agent
-     * The '@' is UI syntax for path autocomplete, not part of the actual path
-     * Only strips @ when it's at start of a word (not in middle like email@domain.com)
-     */
-    stripAtMentions(input) {
-        // Match @ at start of string or after whitespace, followed by non-whitespace
-        return input.replace(/(^|\s)@(\S+)/g, '$1$2');
-    }
-    /**
-     * Process a message to the agent
-     * @param input - The full message to send to the agent
-     * @param options - Optional settings
-     * @param options.displayMessage - What to show the user (defaults to input)
-     * @param options.skipPlanModeCheck - Skip plan mode handling (for /design, /refine)
-     */
-    async processMessage(input, options) {
-        // Print user message to conversation (show displayMessage or original)
-        this.footer.clearForOutput();
-        conversation.printUserMessage(options?.displayMessage ?? input);
-        this.footer.forceRender();
-        // Strip @ prefix from path mentions before sending to agent
-        const cleanedInput = this.stripAtMentions(input);
-        // Check current mode (unless skipped for skill-based commands)
-        const mode = this.footer.getMode();
-        // Plan mode - placeholder for now (skip for /design, /refine which handle their own flow)
-        if (mode === 'plan' && !options?.skipPlanModeCheck) {
-            this.footer.clearForOutput();
-            conversation.printInfo('📋 Plan Mode (coming soon)');
-            conversation.printInfo('In plan mode, the agent will analyze your request and create');
-            conversation.printInfo('a detailed execution plan without performing any actions.');
-            conversation.printInfo('');
-            conversation.printInfo('For now, switch to Normal or Auto-accept mode with Shift+Tab.');
-            terminal.writeLine('');
-            this.footer.forceRender();
-            return;
-        }
-        // Get all tool names and filter based on intent (use cleaned input)
-        const allToolNames = this.agent.getToolDefinitions().map((t) => t.name);
-        const selectedNames = selectToolNamesByIntent(cleanedInput, allToolNames);
-        // Show filtering analysis if enabled
-        if (this.showFiltering) {
-            const saved = allToolNames.length - selectedNames.length;
-            const pct = Math.round((saved / allToolNames.length) * 100);
-            this.footer.clearForOutput();
-            conversation.printInfo(`[Tool Filtering] ${String(selectedNames.length)}/${String(allToolNames.length)} tools, ~${String(pct)}% reduction`);
-            this.footer.forceRender();
-        }
-        // Start agent running state
-        this.agentRunning = true;
-        setAgentRunning(this.state, true);
-        this.footer.setAgentRunning(true);
-        // Clear subagent tracking to prevent stale data from previous runs
-        // (both in agent.ts and in footer's SubagentRenderer)
-        this.clearSubagentTracking?.();
-        this.footer.clearSubagents();
-        this.abortController = new AbortController();
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        let llmCalls = 0;
-        let hasTextOutput = false;
-        let usedTools = false;
-        let lastToolInput = null;
-        // Event-based rendering: accumulate text, render complete blocks
-        let textAccumulator = '';
-        // Set up text buffer flusher so permission handler can flush before showing overlay
-        this.textBufferFlusher = () => {
-            if (textAccumulator.trim()) {
-                this.footer.clearForOutput();
-                conversation.printAssistantResponse(textAccumulator.trim());
-                terminal.writeLine('');
-                this.footer.forceRender();
-                textAccumulator = '';
-            }
-        };
-        debug('processMessage', 'Starting agent stream', {
-            inputLength: cleanedInput.length,
-            toolCount: selectedNames.length,
-            model: this.currentModel,
-        });
-        try {
-            for await (const event of this.agent.stream(cleanedInput, {
-                toolFilter: selectedNames,
-                signal: this.abortController.signal,
-                chatOptions: { model: this.currentModel },
-            })) {
-                debug('processMessage', `Event received: ${event.type}`, event);
-                // Check if aborted
-                if (this.abortController.signal.aborted) {
-                    debug('processMessage', 'Aborted');
-                    break;
-                }
-                if (event.type === 'llm_chunk') {
-                    if (event.chunk.type === 'text' && event.chunk.text) {
-                        // Event-based rendering: accumulate text until tool_start or stream end
-                        // This allows complete code blocks to be rendered with syntax highlighting
-                        textAccumulator += event.chunk.text;
-                        hasTextOutput = true;
-                    }
-                    else if (event.chunk.type === 'done' && event.chunk.usage) {
-                        const tokens = event.chunk.usage.inputTokens + event.chunk.usage.outputTokens;
-                        this.footer.addTokens(tokens);
-                        totalInputTokens += event.chunk.usage.inputTokens;
-                        totalOutputTokens += event.chunk.usage.outputTokens;
-                        llmCalls++;
-                    }
-                }
-                else if (event.type === 'tool_start') {
-                    // Event-based rendering: flush accumulated text before tool output
-                    // Exception: For ask_user/ask_user_simple tools, we'll buffer the text and print after overlay closes
-                    // to avoid the text interfering with the overlay rendering
-                    // Also skip if an overlay is currently active (e.g., permission overlay)
-                    const isAskUserTool = event.name === 'ask_user' || event.name === 'ask_user_simple';
-                    const shouldBuffer = isAskUserTool || isOverlayActive();
-                    if (textAccumulator.trim() && !shouldBuffer) {
-                        this.footer.clearForOutput();
-                        conversation.printAssistantResponse(textAccumulator.trim());
-                        terminal.writeLine('');
-                        this.footer.forceRender();
-                        textAccumulator = '';
-                    }
-                    usedTools = true;
-                    lastToolInput = event.input;
-                    // Show tool in spinner (but not silent tools)
-                    if (event.name !== 'todo_read' && event.name !== 'todo_write' && event.name !== 'suggest') {
-                        // For task tool, show subagent type
-                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                        if (event.name === 'task' && event.input) {
-                            const inputObj = event.input;
-                            const subagentType = typeof inputObj.subagent_type === 'string' ? inputObj.subagent_type : 'general';
-                            const description = typeof inputObj.description === 'string' ? inputObj.description : '';
-                            this.footer.setCurrentTool(`task(${subagentType}): ${description}`);
-                        }
-                        else {
-                            this.footer.setCurrentTool(event.name);
-                        }
-                    }
-                    // Note: Diff is shown in the permission handler (index.ts) BEFORE the prompt
-                }
-                else if (event.type === 'tool_end') {
-                    const toolName = event.name;
-                    const toolInput = lastToolInput;
-                    const result = event.result;
-                    lastToolInput = null;
-                    // Handle todo_write - update state and render
-                    if (toolName === 'todo_write' && toolInput && Array.isArray(toolInput.todos)) {
-                        const todos = toolInput.todos.map((t) => {
-                            const content = typeof t.content === 'string' ? t.content :
-                                typeof t.title === 'string' ? t.title :
-                                    typeof t.task === 'string' ? t.task :
-                                        typeof t.description === 'string' ? t.description :
-                                            typeof t.text === 'string' ? t.text : 'Untitled task';
-                            const status = (typeof t.status === 'string' && ['pending', 'in_progress', 'completed'].includes(t.status)
-                                ? t.status
-                                : 'pending');
-                            const activeForm = typeof t.activeForm === 'string' ? t.activeForm : undefined;
-                            return { content, status, activeForm };
-                        });
-                        updateTodos(this.state, todos);
-                        this.footer.setTodos(todos);
-                        this.footer.setCurrentTool(null);
-                        continue;
-                    }
-                    // Skip todo_read display
-                    if (toolName === 'todo_read') {
-                        this.footer.setCurrentTool(null);
-                        continue;
-                    }
-                    // Skip suggest tool display (suggestion is shown in input prompt)
-                    if (toolName === 'suggest') {
-                        this.footer.setCurrentTool(null);
-                        this.footer.forceRender();
-                        continue;
-                    }
-                    // Handle ask_user/ask_user_simple tools - print buffered text now that overlay is done
-                    if (toolName === 'ask_user' || toolName === 'ask_user_simple') {
-                        // Print any accumulated text that was buffered before the overlay
-                        if (textAccumulator.trim()) {
-                            this.footer.clearForOutput();
-                            conversation.printAssistantResponse(textAccumulator.trim());
-                            terminal.writeLine('');
-                            textAccumulator = '';
-                        }
-                        this.footer.setCurrentTool(null);
-                        this.footer.forceRender();
-                        continue;
-                    }
-                    // Handle edit tool - diff was already shown on tool_start (no output needed)
-                    if (toolName === 'edit') {
-                        // Just clear the tool indicator, diff was shown before permission prompt
-                        this.footer.setCurrentTool(null);
-                        this.footer.forceRender();
-                        continue;
-                    }
-                    // Handle task tool - print sub-agent completion summary to scrolling zone
-                    // Format: ● Explore(description) \n   ⎿  Done (stats)
-                    if (toolName === 'task') {
-                        this.footer.setCurrentTool(null);
-                        // Get stats BEFORE clearing (so we have the data to print)
-                        const stats = this.footer.getLastSubagentStats();
-                        // Clear footer BEFORE clearing subagent data (so lastRenderHeight is still accurate)
-                        this.footer.clearForOutput();
-                        // Print the completion summary to scrolling zone
-                        if (stats) {
-                            conversation.printSubagentResponse(stats);
-                        }
-                        // Now clear the subagent data
-                        this.footer.clearSubagents();
-                        this.footer.forceRender();
-                        continue;
-                    }
-                    // Clear footer for output (for tools that actually print output)
-                    this.footer.clearForOutput();
-                    // Build argument summary for other tools
-                    let argSummary = '';
-                    if (toolInput) {
-                        const path = toolInput.path ?? toolInput.file_path ?? toolInput.filePath;
-                        const command = toolInput.command;
-                        const pattern = toolInput.pattern;
-                        if (typeof path === 'string') {
-                            argSummary = path.split('/').pop() ?? path;
-                        }
-                        else if (typeof command === 'string') {
-                            argSummary = command.length > 40 ? command.slice(0, 40) + '...' : command;
-                        }
-                        else if (typeof pattern === 'string') {
-                            argSummary = pattern;
-                        }
-                    }
-                    // Format result summary
-                    let resultSummary = '';
-                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                    if (result && typeof result === 'object') {
-                        const resultObj = result;
-                        if (resultObj.error) {
-                            const errorObj = resultObj.error;
-                            const errorMsg = typeof errorObj.message === 'string' ? errorObj.message : JSON.stringify(resultObj.error);
-                            resultSummary = pc.red(`Error: ${errorMsg.slice(0, 60)}`);
-                        }
-                        else if (resultObj.result !== undefined) {
-                            resultSummary = conversation.formatToolResult(resultObj.result);
-                        }
-                    }
-                    // Print tool log
-                    conversation.printToolExecution(toolName, argSummary, resultSummary);
-                    // Re-render footer after output
-                    this.footer.setCurrentTool(null);
-                    this.footer.forceRender();
-                }
-                else if (event.type === 'guardrail_warning') {
-                    // Show guardrail warning to user (non-blocking)
-                    const result = event.result;
-                    const name = result.guardrail?.name ?? 'Unknown';
-                    const message = event.message || result.guardrail?.message || 'Risky operation detected';
-                    const category = result.guardrail?.tags?.[0] ?? 'general';
-                    this.footer.clearForOutput();
-                    conversation.printWarning(`[${category}] ${name}: ${message}`);
-                    this.footer.forceRender();
-                }
-                else if (event.type === 'guardrail_blocked') {
-                    // Show guardrail block message (operation was prevented)
-                    const message = event.message || 'Operation blocked by guardrail';
-                    this.footer.clearForOutput();
-                    conversation.printError(`Blocked: ${message}`);
-                    this.footer.forceRender();
-                }
-            }
-            debug('processMessage', 'Stream completed', {
-                hasTextOutput,
-                usedTools,
-                totalInputTokens,
-                totalOutputTokens,
-                llmCalls,
-                textAccumulatorLength: textAccumulator.length,
-            });
-            // Skip stats if aborted
-            if (this.abortController.signal.aborted) {
-                this.agentRunning = false;
-                setAgentRunning(this.state, false);
-                this.footer.setAgentRunning(false);
-                this.abortController = null;
-                return;
-            }
-            // Event-based rendering: flush any remaining accumulated text
-            if (textAccumulator.trim()) {
-                this.footer.clearForOutput();
-                conversation.printAssistantResponse(textAccumulator.trim());
-                terminal.writeLine('');
-                textAccumulator = '';
-            }
-            // Warn if tools used but no text
-            if (usedTools && !hasTextOutput) {
-                this.footer.clearForOutput();
-                conversation.printWarning('No text response from model - try a more capable model');
-            }
-            // Update session stats
-            this.sessionInputTokens += totalInputTokens;
-            this.sessionOutputTokens += totalOutputTokens;
-            this.sessionRequests++;
-            // Clear subagents BEFORE printing stats so footer won't show them afterward
-            this.footer.clearSubagents();
-            // Show token usage
-            if (totalInputTokens > 0 || totalOutputTokens > 0) {
-                this.footer.clearForOutput();
-                const total = totalInputTokens + totalOutputTokens;
-                const sessionTotal = this.sessionInputTokens + this.sessionOutputTokens;
-                conversation.printInfo(`[Tokens: ${total.toLocaleString()} (${totalInputTokens.toLocaleString()} in / ${totalOutputTokens.toLocaleString()} out) - ${String(llmCalls)} LLM call(s)]`);
-                conversation.printInfo(`[Session: ${sessionTotal.toLocaleString()} total (${String(this.sessionRequests)} requests)]`);
-                terminal.writeLine('');
-                this.footer.forceRender();
-            }
-            // Stop spinner and re-render footer (AFTER all output is printed)
-            this.agentRunning = false;
-            setAgentRunning(this.state, false);
-            this.footer.setAgentRunning(false);
-        }
-        catch (error) {
-            debugError('processMessage', error);
-            if (error.name !== 'AbortError') {
-                this.footer.clearForOutput();
-                conversation.printError(error.message);
-                this.footer.forceRender();
-            }
-        }
-        finally {
-            // Ensure agent is stopped even on error
-            this.agentRunning = false;
-            setAgentRunning(this.state, false);
-            this.footer.setAgentRunning(false);
-            this.abortController = null;
-            // Clear text buffer flusher
-            this.textBufferFlusher = null;
-            // Ensure footer is rendered and isPaused is reset
-            // (clearForOutput sets isPaused=true, forceRender resets it)
-            this.footer.forceRender();
-            // Notify that agent has finished (for applying deferred suggestions)
-            this.onAgentFinish?.();
-        }
-    }
-    // ===========================================================================
-    // Helper Commands
-    // ===========================================================================
-    async handleCompact() {
-        const contextManager = this.agent.getContextManager();
-        if (!contextManager) {
-            this.footer.clearForOutput();
-            conversation.printWarning('Context manager not available');
-            this.footer.forceRender();
-            return;
-        }
-        const history = this.agent.getHistory();
-        if (history.length === 0) {
-            this.footer.clearForOutput();
-            conversation.printInfo('No conversation history to compact');
-            this.footer.forceRender();
-            return;
-        }
-        const stats = contextManager.getStats(history.length);
-        this.footer.clearForOutput();
-        conversation.printInfo(`Current: ${stats.currentTokens.toLocaleString()} tokens, ${String(history.length)} messages`);
-        const confirmed = await overlays.showConfirmation('Compact conversation history?');
-        if (!confirmed) {
-            this.footer.forceRender();
-            return;
-        }
-        // Show spinner during compaction
-        this.footer.setSpinnerText('Compacting context');
-        setAgentRunning(this.state, true);
-        this.footer.setAgentRunning(true);
-        this.footer.forceRender(); // Render immediately before blocking operation
-        try {
-            // Use the agent's compact() method - handles summarization, tool pairing, and hints
-            const result = (await this.agent.compact());
-            // Stop spinner and clear for output
-            setAgentRunning(this.state, false);
-            this.footer.setAgentRunning(false);
-            this.footer.setSpinnerText(null);
-            this.footer.clearForOutput();
-            if (!result.success) {
-                conversation.printWarning('Compaction not available (no context manager)');
-                this.footer.forceRender();
-                return;
-            }
-            // Build status message
-            const newHistory = this.agent.getHistory();
-            const statusParts = [
-                `Compacted: ${String(result.originalTokens ?? 0).replace(/\B(?=(\d{3})+(?!\d))/g, ',')} → ${String(result.summaryTokens ?? 0).replace(/\B(?=(\d{3})+(?!\d))/g, ',')} tokens`,
-                `(${String(history.length)} → ${String(newHistory.length)} messages, ${String(result.messagesPreserved ?? 0)} preserved)`,
-            ];
-            // Add smart compaction category info
-            if (result.categoryStats) {
-                const actions = [];
-                if (result.categoryStats.toolResults.action === 'compacted') {
-                    actions.push('tool results → files');
-                }
-                if (result.categoryStats.history.action === 'summarized') {
-                    actions.push('history → summary');
-                }
-                if (actions.length > 0) {
-                    statusParts.push(`[${actions.join(', ')}]`);
-                }
-            }
-            // Add files created info
-            if (result.filesCreated && result.filesCreated.length > 0) {
-                statusParts.push(`[${String(result.filesCreated.length)} file(s) created]`);
-            }
-            // Add file tracking info
-            if (result.restorationHintsInjected) {
-                const fileTracker = this.agent.getFileTracker();
-                const trackerStats = fileTracker?.getStats();
-                const filesTracked = trackerStats ? trackerStats.total : 0;
-                statusParts.push(`[${String(filesTracked)} files tracked]`);
-            }
-            // Add repair info if tool_results were fixed
-            if (result.toolResultsRepaired && result.toolResultsRepaired > 0) {
-                statusParts.push(`[${String(result.toolResultsRepaired)} orphaned tool results removed]`);
-            }
-            conversation.printSuccess(statusParts.join(' '));
-        }
-        catch (error) {
-            // Stop spinner on error too
-            setAgentRunning(this.state, false);
-            this.footer.setAgentRunning(false);
-            this.footer.setSpinnerText(null);
-            this.footer.clearForOutput();
-            conversation.printError(`Compaction failed: ${error.message}`);
-        }
-        this.footer.forceRender();
-    }
-    async showTools() {
-        const tools = this.agent.getToolDefinitions().map((t) => {
-            // Extract parameters from inputSchema
-            const parameters = [];
-            const props = t.inputSchema.properties;
-            const required = t.inputSchema.required ?? [];
-            for (const [name, schema] of Object.entries(props)) {
-                parameters.push({
-                    name,
-                    type: schema.type ?? 'unknown',
-                    description: schema.description,
-                    required: required.includes(name),
-                });
-            }
-            // Look up permission info
-            const permissionInfo = getToolPermissionInfo(t.name);
-            const permission = permissionInfo
-                ? { level: permissionInfo.level, description: permissionInfo.description }
-                : undefined;
-            // For task tool, extract just the intro (before verbose agent types list)
-            let description = t.description;
-            if (t.name === 'task' && description.includes('Available agent types:')) {
-                description = description.split('Available agent types:')[0].trim();
-            }
-            return {
-                name: t.name,
-                description,
-                parameters,
-                permission,
-            };
-        });
-        // Overlay lifecycle handles footer pause/resume
-        await showToolsOverlay(tools);
-    }
-    showTokens() {
-        this.footer.clearForOutput();
-        overlays.showTokenUsage({
-            inputTokens: this.sessionInputTokens,
-            outputTokens: this.sessionOutputTokens,
-            totalTokens: this.sessionInputTokens + this.sessionOutputTokens,
-        });
-        this.footer.forceRender();
-    }
-    showContext() {
-        const contextManager = this.agent.getContextManager();
-        const history = this.agent.getHistory();
-        this.footer.clearForOutput();
-        if (contextManager) {
-            const stats = contextManager.getStats(history.length);
-            overlays.showContextStats({
-                tokens: stats.currentTokens,
-                maxTokens: stats.maxTokens,
-                messages: stats.messageCount,
-                turns: stats.turnCount,
-                utilization: stats.utilization,
-            });
-        }
-        else {
-            // Fallback to session tracking
-            overlays.showContextStats({
-                tokens: this.sessionInputTokens + this.sessionOutputTokens,
-                maxTokens: 200000,
-                messages: history.length,
-                turns: Math.floor(history.filter((m) => m.role === 'user').length),
-                utilization: (this.sessionInputTokens + this.sessionOutputTokens) / 200000,
-            });
-        }
-        this.footer.forceRender();
-    }
-    showStatus() {
-        const contextManager = this.agent.getContextManager();
-        const history = this.agent.getHistory();
-        const mode = this.footer.getMode();
-        const modeInfo = MODE_INFO[mode];
-        this.footer.clearForOutput();
-        terminal.writeLine('');
-        terminal.writeLine(pc.bold('Status'));
-        terminal.writeLine(pc.dim('─'.repeat(40)));
-        terminal.writeLine(`  Version:  ${pc.cyan(this.version)}`);
-        terminal.writeLine(`  Model:    ${pc.cyan(this.model)}`);
-        terminal.writeLine(`  Mode:     ${pc.cyan(modeInfo.label)}`);
-        if (contextManager) {
-            const stats = contextManager.getStats(history.length);
-            const pct = (stats.utilization * 100).toFixed(1);
-            const bar = this.renderProgressBar(stats.utilization, 20);
-            terminal.writeLine(`  Context:  ${bar} ${pct}%`);
-            terminal.writeLine(`  Messages: ${pc.cyan(String(stats.messageCount))}`);
-        }
-        else {
-            const total = this.sessionInputTokens + this.sessionOutputTokens;
-            terminal.writeLine(`  Tokens:   ${pc.cyan(total.toLocaleString())}`);
-            terminal.writeLine(`  Messages: ${pc.cyan(String(history.length))}`);
-        }
-        terminal.writeLine(`  Requests: ${pc.cyan(String(this.sessionRequests))}`);
-        terminal.writeLine('');
-        this.footer.forceRender();
-    }
-    renderProgressBar(ratio, width) {
-        const filled = Math.round(ratio * width);
-        const empty = width - filled;
-        const color = ratio > 0.9 ? pc.red : ratio > 0.7 ? pc.yellow : pc.green;
-        return color('█'.repeat(filled)) + pc.dim('░'.repeat(empty));
-    }
-    showTodos() {
-        const todos = this.state.todos;
-        this.footer.clearForOutput();
-        terminal.writeLine('');
-        if (todos.length === 0) {
-            terminal.writeLine(pc.dim('No todos. The agent will create todos when working on tasks.'));
-            terminal.writeLine('');
-            this.footer.forceRender();
-            return;
-        }
-        terminal.writeLine(pc.bold('Todos'));
-        terminal.writeLine(pc.dim('─'.repeat(40)));
-        for (const todo of todos) {
-            let icon;
-            let style;
-            switch (todo.status) {
-                case 'completed':
-                    icon = pc.green('✓');
-                    style = pc.strikethrough;
-                    break;
-                case 'in_progress':
-                    icon = pc.yellow('●');
-                    style = pc.bold;
-                    break;
-                default:
-                    icon = pc.dim('○');
-                    style = (s) => s;
-            }
-            terminal.writeLine(`  ${icon} ${style(todo.content)}`);
-        }
-        terminal.writeLine('');
-        this.footer.forceRender();
-    }
-    async handleExport(args) {
-        const history = this.agent.getHistory();
-        if (history.length === 0) {
-            this.footer.clearForOutput();
-            conversation.printWarning('No conversation to export');
-            this.footer.forceRender();
-            return;
-        }
-        // Format conversation as markdown
-        const markdown = this.formatConversationAsMarkdown(history);
-        if (args.trim()) {
-            // Export to file
-            const filename = args.trim();
-            const filepath = path.isAbsolute(filename) ? filename : path.join(process.cwd(), filename);
-            try {
-                fs.writeFileSync(filepath, markdown, 'utf-8');
-                this.footer.clearForOutput();
-                conversation.printSuccess(`Exported to ${filepath}`);
-                this.footer.forceRender();
-            }
-            catch (error) {
-                this.footer.clearForOutput();
-                conversation.printError(`Failed to export: ${error.message}`);
-                this.footer.forceRender();
-            }
-        }
-        else {
-            // Export to clipboard
-            try {
-                await this.copyToClipboard(markdown);
-                this.footer.clearForOutput();
-                conversation.printSuccess(`Copied ${String(history.length)} messages to clipboard`);
-                this.footer.forceRender();
-            }
-            catch (error) {
-                this.footer.clearForOutput();
-                conversation.printError(`Failed to copy to clipboard: ${error.message}`);
-                this.footer.forceRender();
-            }
-        }
-    }
-    formatConversationAsMarkdown(history) {
-        const lines = [];
-        const timestamp = new Date().toISOString().split('T')[0];
-        lines.push(`# Conversation Export`);
-        lines.push('');
-        lines.push(`**Model:** ${this.model}`);
-        lines.push(`**Date:** ${timestamp}`);
-        lines.push(`**Messages:** ${String(history.length)}`);
-        lines.push('');
-        lines.push('---');
-        lines.push('');
-        for (const msg of history) {
-            const role = msg.role === 'user' ? '👤 User' : '🤖 Assistant';
-            lines.push(`## ${role}`);
-            lines.push('');
-            if (typeof msg.content === 'string') {
-                lines.push(msg.content);
-            }
-            else if (Array.isArray(msg.content)) {
-                // Handle content blocks (tool calls, etc.)
-                for (const block of msg.content) {
-                    if (typeof block === 'object' && block !== null) {
-                        const b = block;
-                        if (b.type === 'text' && typeof b.text === 'string') {
-                            lines.push(b.text);
-                        }
-                        else if (b.type === 'tool_use') {
-                            const toolName = typeof b.name === 'string' ? b.name : String(b.name);
-                            lines.push(`**Tool:** \`${toolName}\``);
-                            lines.push('```json');
-                            lines.push(JSON.stringify(b.input, null, 2));
-                            lines.push('```');
-                        }
-                        else if (b.type === 'tool_result') {
-                            lines.push(`**Tool Result:**`);
-                            const content = typeof b.content === 'string' ? b.content : JSON.stringify(b.content);
-                            if (content.length > 500) {
-                                lines.push('```');
-                                lines.push(content.slice(0, 500) + '...[truncated]');
-                                lines.push('```');
-                            }
-                            else {
-                                lines.push('```');
-                                lines.push(content);
-                                lines.push('```');
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                lines.push(JSON.stringify(msg.content, null, 2));
-            }
-            lines.push('');
-            lines.push('---');
-            lines.push('');
-        }
-        return lines.join('\n');
-    }
-    async copyToClipboard(text) {
-        const platform = process.platform;
-        let command;
-        if (platform === 'darwin') {
-            command = 'pbcopy';
-        }
-        else if (platform === 'linux') {
-            // Try xclip first, fall back to xsel
-            command = 'xclip -selection clipboard';
-        }
-        else if (platform === 'win32') {
-            command = 'clip';
-        }
-        else {
-            throw new Error(`Unsupported platform: ${platform}`);
-        }
-        const child = exec(command);
-        if (child.stdin) {
-            child.stdin.write(text);
-            child.stdin.end();
-        }
-        await new Promise((resolve, reject) => {
-            child.on('exit', (code) => {
-                if (code === 0) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Clipboard command exited with code ${String(code ?? 'unknown')}`));
-                }
-            });
-            child.on('error', reject);
-        });
-    }
-}