erosolar-cli 2.1.171 → 2.1.172

package/dist/ui/ShellUIAdapter.js

@@ -1,1552 +1,160 @@
-/**
- * ShellUIAdapter - Bridges the UnifiedUIController with the existing shell infrastructure
- * Provides compatibility layer and migration path from old to new UI system
- *
- * Advanced UI Features:
- * - Compact same-line tool displays
- * - In-place progress updates
- * - Grouped operation summaries
- * - Dynamic status badges
- */
-import { UnifiedUIController } from './UnifiedUIController.js';
-import { InterruptPriority } from './interrupts/InterruptManager.js';
-import { getTerminalColumns } from './layout.js';
-import { theme, icons } from './theme.js';
-import { UIUpdateCoordinator } from './orchestration/UIUpdateCoordinator.js';
+import { display as defaultDisplay } from './display.js';
+class MinimalUIController {
+    recordAssistantThought(thought, _meta) {
+        return thought ? Date.now() : null;
+    }
+    recordAssistantResponse(response, _meta) {
+        return response ? Date.now() : null;
+    }
+}
 export class ShellUIAdapter {
-    uiController;
-    display;
-    config;
+    outputDisplay;
+    renderer = null;
+    controller = new MinimalUIController();
     fileChangeCallback;
-    _toolStatusCallback;
-    _activityCallback;
-    profileSwitcherTimeout;
-    updateCoordinator;
-    // Track tool operations for compact rendering
-    pendingOperations = new Map();
-    completedOperations = [];
-    maxCompletedOps = 8;
-    compactDisplayMode = true; // Enable compact same-line displays
-    toolWarnings = new Map();
-    toolProgressSnapshots = new Map();
-    exploreProgressState = new Map();
-    toolUsageCounts = new Map();
-    lastToolUsageSummary = null;
-    lastToolUsageSummaryPlain = null;
-    activeToolStatus = null;
-    activeToolHeartbeatId = null;
-    statusSpinnerIndex = 0;
-    // Store last tool result for expansion with ctrl+o
-    lastToolResult = null;
-    // Scrolling output buffer - shows only the last N lines of tool output in-place
-    maxScrollingLines = 3;
-    scrollingOutputBuffer = new Map();
-    scrollingPanelOwner = null;
-    // Scrolling tool call display - shows only the last N tool calls, scrolling older ones up
-    maxVisibleToolCalls = 3;
-    recentToolCalls = [];
-    toolCallDisplayedCount = 0;
-    constructor(writeStream, display, config = {}, updateCoordinator) {
-        this.display = display;
-        this.config = {
-            enableOverlay: true,
-            enableTelemetry: true,
-            debugMode: false,
-            ...config,
-        };
-        this.updateCoordinator = updateCoordinator ?? new UIUpdateCoordinator();
-        // Initialize unified UI controller
-        this.uiController = new UnifiedUIController(writeStream, {
-            enableOverlay: this.config.enableOverlay,
-            enableAnimations: true,
-            enableTelemetry: this.config.enableTelemetry,
-            adaptivePerformance: true,
-            debugMode: this.config.debugMode,
-        });
-        // Legacy components are optional and should be passed in if needed
-        // They require a readline.Interface which we don't have here
-        this.setupDisplayIntegration();
-    }
-    /**
-     * Setup display integration
-     */
-    setupDisplayIntegration() {
-        // Register output interceptor to coordinate with overlay
-        this.display.registerOutputInterceptor({
-            beforeWrite: () => {
-                this.uiController.beginOutput();
-            },
-            afterWrite: () => {
-                this.uiController.endOutput();
-            },
-        });
+    toolStatusCallback;
+    toolUsage = new Map();
+    constructor(outputDisplay = defaultDisplay, _config = {}) {
+        this.outputDisplay = outputDisplay;
     }
-    /**
-     * Expose the shared update coordinator so other components can align with UI mode.
-     */
-    getUpdateCoordinator() {
-        return this.updateCoordinator;
+    attachRenderer(renderer) {
+        this.renderer = renderer;
     }
-    /**
-     * Expose the underlying unified UI controller for orchestration/telemetry.
-     */
     getController() {
-        return this.uiController;
+        return this.controller;
+    }
+    setFileChangeCallback(callback) {
+        this.fileChangeCallback = callback;
+    }
+    setToolStatusCallback(callback) {
+        this.toolStatusCallback = callback;
+    }
+    updateContextUsage(percentage) {
+        if (!Number.isFinite(percentage))
+            return;
+        const percent = Math.max(0, Math.min(100, Math.round(percentage)));
+        this.renderer?.updateStatusMeta({ contextPercent: percent }, { render: false });
+    }
+    startProcessing(message) {
+        this.resetToolUsage();
+        if (message) {
+            this.renderer?.updateStatusBundle({ main: message }, { render: false });
+        }
+    }
+    endProcessing(message) {
+        this.renderer?.updateStatusBundle({ main: message ?? null, streaming: null }, { render: false });
     }
-    /**
-     * Create a tool observer for the agent
-     * Shows tool results in clean panels (status bar shows active tool execution)
-     * Uses compact rendering for same-line displays when appropriate
-     */
     createToolObserver() {
         return {
             onToolStart: (call) => {
                 this.recordToolUsage(call.name);
-                this.clearToolState(call.id);
-                // Track operation for compact rendering
-                const operation = {
-                    id: call.id,
-                    name: call.name,
-                    status: 'running',
-                    summary: this.getToolSummary(call),
-                    args: call.arguments,
-                    startedAt: Date.now(),
-                };
-                this.pendingOperations.set(call.id, operation);
-                // Erosolar-CLI style: Show tool call start for ALL tools
-                // This provides transparency about which tools are being used
-                this.displayToolCallStart(call);
-                // Update status bar to show active tool
-                if (this._toolStatusCallback) {
-                    const actionDesc = this.getToolActionDescription(call);
-                    this.activeToolStatus = {
-                        id: call.id,
-                        description: actionDesc,
-                        startedAt: Date.now(),
-                    };
-                    this._toolStatusCallback(this.buildRunningStatusLine(actionDesc, this.activeToolStatus.startedAt));
-                    this.startToolStatusHeartbeat(call.id);
-                }
-                this.uiController.onToolStart(call);
+                const summary = this.formatToolCall(call);
+                this.outputDisplay.emit('tool-call', summary);
+                this.toolStatusCallback?.(`Running ${call.name}`);
             },
             onToolProgress: (call, progress) => {
-                // Update pending operation
-                const op = this.pendingOperations.get(call.id);
-                if (op) {
-                    op.detail = progress.message;
-                }
-                this.uiController.onToolProgress(call.id, {
-                    current: progress.current,
-                    total: progress.total ?? progress.current,
-                    message: progress.message,
-                });
-                if (call.name === 'explore') {
-                    this.logExploreProgress(call, progress);
-                }
-                else {
-                    this.logToolProgress(call, progress);
-                }
-                // Update activity line with streaming output from bash commands
-                if (this._activityCallback && progress.message) {
-                    // Show the streaming line as the activity (e.g., npm install progress)
-                    const activityText = progress.message.slice(0, 60);
-                    this._activityCallback(activityText);
-                }
-                // Update status bar with progress - use in-place update for supported terminals
-                if (this._toolStatusCallback) {
-                    const description = this.getToolActionDescription(call, progress);
-                    if (description) {
-                        if (this.activeToolStatus && this.activeToolStatus.id === call.id) {
-                            this.activeToolStatus.description = description;
-                        }
-                        else {
-                            this.activeToolStatus = {
-                                id: call.id,
-                                description: description,
-                                startedAt: Date.now(),
-                            };
-                        }
-                        this._toolStatusCallback(this.buildRunningStatusLine(description, this.activeToolStatus.startedAt));
-                    }
-                }
-            },
-            onToolWarning: (call, warning) => {
-                const warningText = this.formatToolWarning(warning);
-                this.recordToolWarning(call.id, warningText);
-                if (this._toolStatusCallback) {
-                    this._toolStatusCallback(`Warning: ${this.getToolActionDescription(call)}`);
-                }
+                const label = progress.message || `${progress.current}/${progress.total ?? progress.current}`;
+                this.toolStatusCallback?.(`${call.name}: ${label}`);
             },
             onToolResult: (call, output) => {
-                const now = Date.now();
-                // Complete the operation tracking
-                const op = this.pendingOperations.get(call.id);
-                if (op) {
-                    op.status = 'success';
-                    op.completedAt = now;
-                    op.summary = this.extractResultSummary(call, output);
-                    this.pendingOperations.delete(call.id);
-                    this.completedOperations.push(op);
-                    // Keep only recent completed operations
-                    while (this.completedOperations.length > this.maxCompletedOps) {
-                        this.completedOperations.shift();
-                    }
-                }
-                if (call.name === 'explore') {
-                    this.logExploreCompletion(call.id, true);
-                }
-                this.clearToolState(call.id);
-                // Track file changes for Edit/Write/NotebookEdit tools
-                if (this.fileChangeCallback && (call.name === 'Edit' || call.name === 'Write' || call.name === 'NotebookEdit')) {
-                    const fileChange = this.parseFileChange(call, output);
-                    if (fileChange) {
-                        this.fileChangeCallback(fileChange.path, fileChange.type, fileChange.additions, fileChange.removals);
-                    }
-                }
-                // Store result for expansion with ctrl+o
-                this.lastToolResult = {
-                    toolName: call.name,
-                    output,
-                    timestamp: Date.now(),
-                };
-                // Claude Code style: compact display for all tools
-                if (call.name === 'Edit' || call.name === 'edit_file') {
-                    this.displayEditResult(call, output, true);
-                }
-                else if (this.compactDisplayMode && this.isCompactTool(call.name)) {
-                    this.displayCompactResult(call, output, true);
-                }
-                else {
-                    // Display tool result with ⎿ prefix
-                    this.displayToolResultSummary(call, output, true);
-                }
-                // Surface any captured preflight warnings in a structured block
-                this.flushToolWarnings(call.id, call.name);
-                // Clear status bar after showing result
-                this.stopToolStatusHeartbeat();
-                if (this._toolStatusCallback) {
-                    this._toolStatusCallback(null);
-                }
-                this.uiController.onToolComplete(call.id, output);
+                const result = this.formatToolResult(call, output, true);
+                this.outputDisplay.rememberToolResult(result.full, result.summary);
+                this.outputDisplay.emit('tool-result', result.summary, { compact: true });
+                this.toolStatusCallback?.(null);
             },
-            onToolError: (call, message) => {
-                // Complete the operation tracking with error
-                const op = this.pendingOperations.get(call.id);
-                if (op) {
-                    op.status = 'error';
-                    op.completedAt = Date.now();
-                    op.summary = message;
-                    this.pendingOperations.delete(call.id);
-                    this.completedOperations.push(op);
-                }
-                if (call.name === 'explore') {
-                    this.logExploreCompletion(call.id, false);
-                }
-                this.clearToolState(call.id);
-                // Claude Code style: compact display for errors too
-                if (call.name === 'Edit' || call.name === 'edit_file') {
-                    this.displayEditResult(call, message, false);
-                }
-                else if (this.compactDisplayMode && this.isCompactTool(call.name)) {
-                    this.displayCompactResult(call, message, false);
-                }
-                else {
-                    // Display error with ⎿ prefix (error color)
-                    this.displayToolResultSummary(call, message, false);
-                }
-                this.flushToolWarnings(call.id, call.name);
-                // Clear status bar after showing error
-                this.stopToolStatusHeartbeat();
-                if (this._toolStatusCallback) {
-                    this._toolStatusCallback(null);
-                }
-                this.uiController.onToolError(call.id, { message });
+            onToolError: (call, error) => {
+                const result = this.formatToolResult(call, error, false);
+                this.outputDisplay.rememberToolResult(result.full, result.summary);
+                this.outputDisplay.emit('tool-result', result.summary, { compact: true });
+                this.toolStatusCallback?.(null);
             },
             onCacheHit: (call) => {
-                // Track as cached operation
-                const operation = {
-                    id: call.id,
-                    name: call.name,
-                    status: 'cached',
-                    summary: `${this.getToolSummary(call)} (cached)`,
-                    args: call.arguments,
-                    startedAt: Date.now(),
-                    completedAt: Date.now(),
-                };
-                this.completedOperations.push(operation);
-                this.clearToolState(call.id);
-                // Erosolar-CLI style: Show tool call with (cached) indicator
-                this.displayToolCallStart(call, true);
-                this.flushToolWarnings(call.id, call.name);
-                this.stopToolStatusHeartbeat();
-                if (this._toolStatusCallback) {
-                    this._toolStatusCallback(null);
+                this.recordToolUsage(call.name);
+                const summary = `${call.name} (cached)`;
+                this.outputDisplay.emit('tool-call', summary);
+                this.outputDisplay.emit('tool-result', `⎿ ${summary}`, { compact: true });
+            },
+            onToolWarning: (_call, warning) => {
+                const message = typeof warning === 'string'
+                    ? warning
+                    : typeof warning === 'object' && warning !== null && 'message' in warning
+                        ? String(warning.message ?? '')
+                        : '';
+                if (message) {
+                    this.outputDisplay.showWarning(message);
                 }
-                this.uiController.onToolStart(call);
-                this.uiController.onToolComplete(call.id, 'cache-hit');
             },
         };
     }
-    /**
-     * Check if a tool should use compact (single-line) display
-     */
-    isCompactTool(toolName) {
-        const compactTools = new Set([
-            'Read', 'read_file',
-            'Glob', 'glob',
-            'TodoWrite', 'todo_write',
-            'WebFetch', 'web_fetch',
-            'list_files',
-        ]);
-        return compactTools.has(toolName);
-    }
-    /**
-     * Track tool usage for per-request summaries.
-     */
-    recordToolUsage(toolName) {
-        const name = toolName.trim();
-        if (!name)
-            return;
-        const current = this.toolUsageCounts.get(name) ?? 0;
-        this.toolUsageCounts.set(name, current + 1);
-    }
-    resetToolUsageSummary() {
-        this.toolUsageCounts.clear();
-        this.lastToolUsageSummary = null;
-        this.lastToolUsageSummaryPlain = null;
-    }
-    /**
-     * Render a compact "tools used" line mirroring Claude Code.
-     * Shows the top two tools and how many more were used.
-     */
-    showToolUsageSummary() {
-        // Compute summary for metadata but don't display it
-        // The tool calls are already visible in the conversation flow
-        this.lastToolUsageSummary = this.formatToolUsageSummary();
-        this.lastToolUsageSummaryPlain = this.formatToolUsageSummary({ plain: true });
-        // Don't stream the summary - it's redundant after the assistant response
-    }
     getToolUsageSummary(options = {}) {
-        return options.plain ? this.lastToolUsageSummaryPlain : this.lastToolUsageSummary;
-    }
-    /**
-     * Get the last tool result for expansion with ctrl+o
-     */
-    getLastToolResult() {
-        return this.lastToolResult;
-    }
-    /**
-     * Clear the stored tool result (e.g., after expansion)
-     */
-    clearLastToolResult() {
-        this.lastToolResult = null;
-    }
-    formatToolUsageSummary(options = {}) {
-        const plain = options.plain === true;
-        if (this.toolUsageCounts.size === 0) {
+        if (this.toolUsage.size === 0) {
             return null;
         }
-        const entries = Array.from(this.toolUsageCounts.entries()).sort((a, b) => {
+        const entries = Array.from(this.toolUsage.entries()).sort((a, b) => {
             if (b[1] === a[1]) {
                 return a[0].localeCompare(b[0]);
             }
             return b[1] - a[1];
         });
-        const totalCalls = entries.reduce((sum, [, count]) => sum + count, 0);
         const top = entries.slice(0, 2);
-        const remaining = entries.slice(2);
-        const formattedTop = top.map(([name, count]) => {
-            const countLabel = count > 1 ? plain ? `×${count}` : theme.ui.muted(`×${count}`) : '';
-            const formattedName = plain ? name : theme.tool(name);
-            return `${formattedName}${countLabel}`;
-        });
-        const remainderLabel = remaining.length
-            ? plain
-                ? ` +${remaining.length} more`
-                : theme.ui.muted(` +${remaining.length} more`)
-            : '';
-        const totalLabel = plain
-            ? ` · ${totalCalls} call${totalCalls === 1 ? '' : 's'}`
-            : theme.ui.muted(` · ${totalCalls} call${totalCalls === 1 ? '' : 's'}`);
-        const separator = plain ? ', ' : theme.ui.muted(', ');
-        const prefix = plain ? 'tools ' : `${theme.info(icons.action)} tools `;
-        return `${prefix}${formattedTop.join(separator)}${remainderLabel}${totalLabel}`.trim();
-    }
-    /**
-     * Normalize preflight warnings for consistent display.
-     */
-    formatToolWarning(warning) {
-        if (typeof warning === 'string') {
-            return warning;
-        }
-        const code = warning.code ? `[${warning.code}] ` : '';
-        const suggestion = warning.suggestion ? ` — ${warning.suggestion}` : '';
-        return `${code}${warning.message}${suggestion}`;
-    }
-    /**
-     * Track warnings for a tool call so we can show them after the result too.
-     */
-    recordToolWarning(callId, warningText) {
-        const existing = this.toolWarnings.get(callId) ?? [];
-        if (!existing.includes(warningText)) {
-            existing.push(warningText);
-            this.toolWarnings.set(callId, existing);
-        }
-    }
-    /**
-     * Render any captured warnings for the given tool call as a structured block.
-     */
-    flushToolWarnings(callId, toolName) {
-        const warnings = this.toolWarnings.get(callId);
-        if (!warnings?.length) {
-            return;
-        }
-        this.toolWarnings.delete(callId);
-        const header = `${theme.warning(icons.warning)} ${theme.ui.muted('preflight')} warnings for ${theme.tool(toolName)}`;
-        const bullet = theme.ui.muted(icons.bullet);
-        const body = warnings.map(text => `  ${bullet} ${text}`).join('\n');
-        this.display.stream(`\n${header}\n${body}\n`);
-    }
-    /**
-     * Get a short summary for tool operation
-     */
-    getToolSummary(call) {
-        const args = call.arguments;
-        switch (call.name) {
-            case 'Read':
-            case 'read_file': {
-                const path = this.extractPath(args, ['file_path', 'path']);
-                return path ? this.truncatePath(path, 30) : '';
-            }
-            case 'Edit':
-            case 'edit_file': {
-                const path = this.extractPath(args, ['file_path', 'path']);
-                return path ? this.truncatePath(path, 30) : '';
-            }
-            case 'Grep':
-            case 'grep': {
-                const pattern = args?.['pattern'];
-                return pattern ? `"${pattern.slice(0, 20)}"` : '';
-            }
-            case 'Glob':
-            case 'glob': {
-                const pattern = args?.['pattern'];
-                return pattern || '';
-            }
-            case 'Task':
-            case 'task': {
-                const desc = args?.['description'];
-                return desc ? desc.slice(0, 25) : '';
-            }
-            default:
-                return '';
-        }
-    }
-    /**
-     * Extract result summary from tool output
-     * Includes file paths for file operations so users can see which files were accessed
-     */
-    extractResultSummary(call, output) {
-        const args = call.arguments;
-        switch (call.name) {
-            case 'Read':
-            case 'read_file': {
-                const path = this.extractPath(args, ['file_path', 'path']);
-                const lines = this.countLines(output);
-                // Show file path so users see which file was read
-                return path ? `${this.truncatePath(path, 40)} (${lines} lines)` : `${lines} lines`;
-            }
-            case 'Write':
-            case 'write_file': {
-                const path = this.extractPath(args, ['file_path', 'path']);
-                return path ? `${this.truncatePath(path, 40)} written` : 'file written';
-            }
-            case 'Edit':
-            case 'edit_file': {
-                const path = this.extractPath(args, ['file_path', 'path']);
-                // Parse additions/removals from output if available
-                const editMatch = output.match(/\+(\d+).*-(\d+)/);
-                const changes = editMatch ? `+${editMatch[1]}/-${editMatch[2]}` : 'edited';
-                return path ? `${this.truncatePath(path, 35)} ${changes}` : changes;
-            }
-            case 'Grep':
-            case 'grep': {
-                const pattern = args?.['pattern'];
-                const matches = output.trim().split('\n').filter(l => l).length;
-                const matchText = `${matches} match${matches === 1 ? '' : 'es'}`;
-                // Show pattern for context
-                if (pattern && pattern.length <= 20) {
-                    return `"${pattern}" → ${matchText}`;
-                }
-                return matchText;
-            }
-            case 'Glob':
-            case 'glob': {
-                const pattern = args?.['pattern'];
-                const files = output.trim().split('\n').filter(f => f).length;
-                const fileText = `${files} file${files === 1 ? '' : 's'}`;
-                // Show pattern for context
-                if (pattern && pattern.length <= 25) {
-                    return `${pattern} → ${fileText}`;
-                }
-                return fileText;
-            }
-            case 'list_files': {
-                const path = this.extractPath(args, ['path']) || '.';
-                const files = output.trim().split('\n').filter(f => f).length;
-                return `${this.truncatePath(path, 40)} → ${files} item${files === 1 ? '' : 's'}`;
-            }
-            case 'Bash':
-            case 'bash': {
-                const cmd = args?.['command'];
-                if (cmd) {
-                    const shortCmd = cmd.split('\n')[0]?.trim() || cmd;
-                    const truncated = shortCmd.length > 30 ? `${shortCmd.slice(0, 27)}...` : shortCmd;
-                    return `\`${truncated}\` done`;
-                }
-                return 'done';
-            }
-            default:
-                return 'done';
-        }
-    }
-    /**
-     * Display compact single-line result (Erosolar-CLI style)
-     * Shows the tool name with a concise summary (no raw payload dumps)
-     */
-    displayCompactResult(call, output, success) {
-        const args = call.arguments || {};
-        const summary = success
-            ? this.extractResultSummary(call, output) || this.formatClaudeCodeResultSummary(call.name, args, output, success)
-            : this.formatClaudeCodeResultSummary(call.name, args, output, success);
-        if (!summary) {
-            return;
-        }
-        const prefix = success ? theme.success(icons.subaction) : theme.error(icons.subaction);
-        // Just show the result summary - tool name was already shown on the call line
-        this.display.stream(`  ${prefix}  ${summary}\n`);
-    }
-    /**
-     * Display edit results with full colored diff output.
-     * - Summary line with additions/removals
-     * - Diff lines rendered in-place (red for removals, green for additions)
-     */
-    displayEditResult(call, output, success) {
-        const args = call.arguments || {};
-        const summary = this.formatClaudeCodeResultSummary(call.name, args, output, success);
-        if (!summary) {
-            return;
-        }
-        const prefix = success ? theme.success(icons.subaction) : theme.error(icons.subaction);
-        this.display.stream(`  ${prefix}  ${summary}\n`);
-        if (success) {
-            const diffSection = this.extractEditDiffSection(output);
-            if (diffSection) {
-                // Show diff with single trailing newline
-                this.display.stream(`${diffSection}\n`);
-            }
-        }
-    }
-    logToolProgress(call, progress) {
-        const description = this.getToolActionDescription(call, progress);
-        const pct = progress.total
-            ? Math.max(0, Math.min(100, Math.round((progress.current / progress.total) * 100)))
-            : null;
-        const parts = [];
-        if (description) {
-            parts.push(theme.ui.muted(description));
-        }
-        const details = [];
-        if (pct !== null) {
-            details.push(`${pct}%`);
-        }
-        if (progress.message?.trim()) {
-            details.push(progress.message.trim());
-        }
-        if (details.length) {
-            parts.push(theme.ui.muted(details.join(' · ')));
-        }
-        const separator = theme.ui.muted(' — ');
-        const line = parts.filter(Boolean).join(separator);
-        if (!line)
-            return;
-        // Use scrolling output for ALL tools on TTY - show only last N lines, updating in place
-        // This prevents flooding the terminal with hundreds of progress lines
-        if (process.stdout.isTTY) {
-            this.appendScrollingOutput(call.id, line);
-        }
-        else {
-            // Non-TTY: original streaming behavior (for log files, pipes, etc.)
-            const last = this.toolProgressSnapshots.get(call.id);
-            if (line !== last) {
-                this.display.stream(`${line}\n`);
-                this.toolProgressSnapshots.set(call.id, line);
-            }
-        }
-    }
-    /**
-     * Append a line to scrolling output buffer and update display in-place
-     * Shows only the last maxScrollingLines, replacing previous output
-     */
-    appendScrollingOutput(callId, line) {
-        let buffer = this.scrollingOutputBuffer.get(callId);
-        if (!buffer) {
-            buffer = { lines: [], displayedLineCount: 0 };
-            this.scrollingOutputBuffer.set(callId, buffer);
-        }
-        // Add line to buffer
-        buffer.lines.push(line);
-        // Keep only the last maxScrollingLines
-        while (buffer.lines.length > this.maxScrollingLines) {
-            buffer.lines.shift();
-        }
-        // Prefer inline panel (scroll box) when unified renderer is active
-        if (this.shouldUseInlineScrollBox()) {
-            this.scrollingPanelOwner = callId;
-            const panelLines = this.buildScrollingPanelLines(buffer.lines);
-            this.display.showInlinePanel(panelLines);
-            buffer.displayedLineCount = 0;
-            return;
-        }
-        // Move cursor up to overwrite previous lines (if any were displayed)
-        if (buffer.displayedLineCount > 0) {
-            process.stdout.write(`\x1b[${buffer.displayedLineCount}A`);
-        }
-        // Clear and rewrite the scrolling region
-        const linesToShow = buffer.lines;
-        for (let i = 0; i < linesToShow.length; i++) {
-            process.stdout.write(`\r\x1b[K${linesToShow[i]}\n`);
-        }
-        // Track how many lines we displayed for next update
-        buffer.displayedLineCount = linesToShow.length;
-    }
-    /**
-     * Build the pinned scroll-box contents for live tool output.
-     */
-    buildScrollingPanelLines(lines) {
-        if (!lines.length) {
-            return [];
-        }
-        const header = theme.ui.muted(`${icons.action} live output (latest ${Math.min(lines.length, this.maxScrollingLines)})`);
-        const indented = lines.map(text => `  ${text}`);
-        return [header, ...indented];
-    }
-    /**
-     * Use inline scroll box only when an interactive renderer is active.
-     */
-    shouldUseInlineScrollBox() {
-        return this.display.hasRenderer() && process.stdout.isTTY && !process.env['CI'];
-    }
-    /**
-     * Finalize scrolling output - called when tool completes
-     * Clears the scrolling progress lines so only the final result is shown
-     */
-    finalizeScrollingOutput(callId) {
-        if (this.scrollingPanelOwner === callId && this.shouldUseInlineScrollBox()) {
-            this.display.clearInlinePanel();
-            this.scrollingPanelOwner = null;
-            this.scrollingOutputBuffer.delete(callId);
-            return;
-        }
-        const buffer = this.scrollingOutputBuffer.get(callId);
-        if (buffer && buffer.displayedLineCount > 0 && process.stdout.isTTY) {
-            // Move cursor up and clear all the progress lines
-            process.stdout.write(`\x1b[${buffer.displayedLineCount}A`);
-            for (let i = 0; i < buffer.displayedLineCount; i++) {
-                process.stdout.write(`\r\x1b[K\n`);
-            }
-            // Move cursor back up to where progress started
-            process.stdout.write(`\x1b[${buffer.displayedLineCount}A`);
-        }
-        this.scrollingOutputBuffer.delete(callId);
-    }
-    logExploreProgress(call, progress) {
-        const previous = this.exploreProgressState.get(call.id) ?? { lastCurrent: 0 };
-        const total = progress.total ?? previous.total;
-        const current = Math.max(progress.current, previous.lastCurrent);
-        const path = progress.message ? this.truncatePath(String(progress.message), 60) : null;
-        const header = total ? `${current}/${total}` : `${current}`;
-        const parts = [`${theme.info('⇢')} Exploring ${header}`];
-        if (path) {
-            parts.push(theme.ui.muted(path));
-        }
-        const line = parts.join(theme.ui.muted(' • '));
-        if (line && line !== previous.lastLine) {
-            // Use in-place update for TTY - single line that updates without scrolling
-            if (process.stdout.isTTY && previous.lastLine) {
-                // Move cursor up one line and clear it, then write new line
-                process.stdout.write(`\x1b[1A\r\x1b[K${line}\n`);
-            }
-            else {
-                this.display.stream(`${line}\n`);
-            }
-        }
-        this.exploreProgressState.set(call.id, {
-            total,
-            lastCurrent: current,
-            lastLine: line,
-        });
-    }
-    logExploreCompletion(callId, success) {
-        const state = this.exploreProgressState.get(callId);
-        const total = state?.total ?? state?.lastCurrent ?? 0;
-        const summary = success
-            ? `${theme.success('✓')} Indexed ${total} file${total === 1 ? '' : 's'}`
-            : `${theme.error('✗')} Explore interrupted`;
-        // Clear the progress line before showing summary (if TTY and had progress)
-        if (process.stdout.isTTY && state?.lastLine) {
-            process.stdout.write(`\x1b[1A\r\x1b[K`);
-        }
-        this.display.stream(`${summary}\n`);
-    }
-    /**
-     * Centralized cleanup for tool state
-     * Called from onToolResult, onToolError, and onCacheHit
-     */
-    clearToolState(callId) {
-        this.toolProgressSnapshots.delete(callId);
-        this.exploreProgressState.delete(callId);
-        this.finalizeScrollingOutput(callId);
-    }
-    /**
-     * Display tool call start with Erosolar-CLI style prefix
-     * - ✢ for Task/agent tools (active task indicator)
-     * - ⏺ for other tools
-     * Uses scrolling display to show only the last N tool calls
-     */
-    displayToolCallStart(call, isCacheHit = false) {
-        const args = call.arguments || {};
-        const toolName = theme.tool(call.name);
-        // Format args inline (compact)
-        const argsStr = this.formatToolArgsInline(call.name, args);
-        const cacheHint = isCacheHit ? theme.ui.muted(' (cached)') : '';
-        // Use ✢ for Task tools (shows active task), ⏺ for others
-        const isTaskTool = call.name === 'Task' || call.name === 'task';
-        const bullet = theme.info(icons.action);
-        const taskMarker = isTaskTool ? ` ${theme.info('✢')}` : '';
-        // For Task tools, show the subagent type if available
-        let displayName = toolName;
-        if (isTaskTool) {
-            const subagentType = args['subagent_type'];
-            if (subagentType) {
-                // Capitalize first letter
-                displayName = theme.tool(subagentType.charAt(0).toUpperCase() + subagentType.slice(1));
-            }
-        }
-        // Erosolar-CLI style: bullet + optional task marker + ToolName(args)
-        const line = `${bullet}${taskMarker ? taskMarker : ''} ${displayName}${argsStr}${cacheHint}`;
-        // Use scrolling display for tool calls - shows only recent calls
-        this.appendToolCallDisplay(call.id, line);
-    }
-    /**
-     * Append a tool call to the scrolling display, keeping only the last N visible.
-     * Older tool calls scroll up and disappear, showing only recent activity.
-     */
-    appendToolCallDisplay(callId, line) {
-        // Add to recent tool calls
-        this.recentToolCalls.push({ line, id: callId });
-        // Keep only the last maxVisibleToolCalls
-        while (this.recentToolCalls.length > this.maxVisibleToolCalls) {
-            this.recentToolCalls.shift();
-        }
-        // On TTY, use in-place updating to show only recent tool calls
-        if (process.stdout.isTTY && this.toolCallDisplayedCount > 0) {
-            // Move cursor up to overwrite previous tool call lines
-            const moveUp = `\x1b[${this.toolCallDisplayedCount}A`;
-            // Clear from cursor to end of screen
-            const clearDown = '\x1b[J';
-            process.stdout.write(moveUp + clearDown);
-        }
-        // Display all recent tool calls
-        for (const toolCall of this.recentToolCalls) {
-            this.display.stream(`${toolCall.line}\n`);
-        }
-        // Track how many lines we displayed
-        this.toolCallDisplayedCount = this.recentToolCalls.length;
-    }
-    /**
-     * Clear tool call display state when processing completes
-     */
-    clearToolCallDisplay() {
-        this.recentToolCalls = [];
-        this.toolCallDisplayedCount = 0;
-    }
-    /**
-     * Format tool arguments inline for display (Erosolar-CLI style)
-     * Format: ToolName(arg1: "value1", arg2: "value2")
-     */
-    formatToolArgsInline(toolName, args) {
-        const parts = [];
-        // Priority order for different argument types
-        const priorityArgs = [
-            'file_path', 'path', 'pattern', 'command', 'query', 'url',
-            'output_mode', 'glob', 'type', 'head_limit',
-        ];
-        // Skip these arguments in display
-        const skipArgs = new Set([
-            'dangerouslyDisableSandbox', 'run_in_background', 'description',
-            'timeout', 'encoding', '-n', // defaults that don't add info
-        ]);
-        // Build args display based on tool type
-        switch (toolName) {
-            case 'Read':
-            case 'read_file': {
-                const filePath = args['file_path'] || args['path'];
-                if (filePath)
-                    parts.push(this.truncatePath(String(filePath), 50));
-                break;
-            }
-            case 'Write':
-            case 'write_file':
-            case 'Edit':
-            case 'edit_file': {
-                const filePath = args['file_path'] || args['path'];
-                if (filePath)
-                    parts.push(this.truncatePath(String(filePath), 50));
-                break;
-            }
-            case 'Bash':
-            case 'bash': {
-                const cmd = args['command'];
-                if (cmd) {
-                    const shortCmd = String(cmd).split('\n')[0]?.trim() || String(cmd);
-                    parts.push(shortCmd.length > 50 ? `${shortCmd.slice(0, 47)}...` : shortCmd);
-                }
-                break;
-            }
-            case 'Grep':
-            case 'grep': {
-                const pattern = args['pattern'];
-                if (pattern) {
-                    const truncPattern = String(pattern).length > 35
-                        ? `${String(pattern).slice(0, 32)}...`
-                        : String(pattern);
-                    parts.push(`pattern: "${truncPattern}"`);
-                }
-                const path = args['path'];
-                if (path && path !== '.') {
-                    parts.push(`path: "${this.truncatePath(String(path), 30)}"`);
-                }
-                const outputMode = args['output_mode'];
-                if (outputMode && outputMode !== 'files_with_matches') {
-                    parts.push(`output_mode: "${outputMode}"`);
-                }
-                break;
-            }
-            case 'Glob':
-            case 'glob': {
-                const pattern = args['pattern'];
-                if (pattern)
-                    parts.push(`pattern: "${pattern}"`);
-                const path = args['path'];
-                if (path && path !== '.') {
-                    parts.push(`path: "${this.truncatePath(String(path), 30)}"`);
-                }
-                break;
-            }
-            case 'list_files': {
-                const path = args['path'];
-                if (path && path !== '.') {
-                    parts.push(this.truncatePath(String(path), 50));
-                }
-                break;
-            }
-            case 'WebFetch':
-            case 'web_fetch': {
-                const url = args['url'];
-                if (url) {
-                    try {
-                        parts.push(new URL(String(url)).hostname);
-                    }
-                    catch {
-                        parts.push(String(url).slice(0, 40));
-                    }
-                }
-                break;
-            }
-            case 'WebSearch':
-            case 'web_search': {
-                const query = args['query'];
-                if (query) {
-                    const truncQuery = String(query).length > 40
-                        ? `${String(query).slice(0, 37)}...`
-                        : String(query);
-                    parts.push(`"${truncQuery}"`);
-                }
-                break;
-            }
-            case 'Task':
-            case 'task': {
-                const desc = args['description'];
-                if (desc) {
-                    const truncDesc = String(desc).length > 40
-                        ? `${String(desc).slice(0, 37)}...`
-                        : String(desc);
-                    parts.push(`"${truncDesc}"`);
-                }
-                break;
-            }
-            case 'TodoWrite':
-            case 'todo_write': {
-                // Erosolar-CLI shows parameter names for complex types
-                parts.push('todos');
-                break;
-            }
-            default: {
-                // For unknown tools, show key: value pairs for priority args
-                for (const key of priorityArgs) {
-                    if (skipArgs.has(key))
-                        continue;
-                    const value = args[key];
-                    if (value === undefined || value === null || value === '')
-                        continue;
-                    if (typeof value === 'string') {
-                        const truncVal = value.length > 30 ? `${value.slice(0, 27)}...` : value;
-                        parts.push(`${key}: "${truncVal}"`);
-                    }
-                    else if (typeof value === 'number' || typeof value === 'boolean') {
-                        parts.push(`${key}: ${value}`);
-                    }
-                    if (parts.length >= 3)
-                        break; // Max 3 args for display
-                }
-            }
-        }
-        return parts.length > 0 ? `(${parts.join(', ')})` : '';
-    }
-    /**
-     * Start processing a request
-     */
-    startProcessing(message = 'Working on your request') {
-        this.resetToolUsageSummary();
-        this.clearToolCallDisplay(); // Clear previous tool call display
-        this.uiController.startProcessing();
-        this.uiController.setBaseStatus(message, 'info');
-    }
-    /**
-     * End processing
-     */
-    endProcessing(message = 'Ready for prompts') {
-        this.uiController.endProcessing();
-        this.showToolUsageSummary();
-        this.uiController.setBaseStatus(message, 'success');
-        // Clear tool call scrolling state for next request
-        this.clearToolCallDisplay();
-    }
-    /**
-     * Update context usage (no-op - status handled by display.showStatusLine)
-     */
-    updateContextUsage(_percentage) {
-        // No-op - context display is handled by display.showStatusLine()
-    }
-    /**
-     * Show a user interrupt
-     */
-    showInterrupt(message, type = 'alert', handler) {
-        const priority = type === 'alert'
-            ? InterruptPriority.HIGH
-            : InterruptPriority.NORMAL;
-        return this.uiController.queueInterrupt(type, message, priority, handler ? async () => handler() : undefined);
-    }
-    /**
-     * Complete an interrupt
-     */
-    completeInterrupt(id) {
-        this.uiController.completeInterrupt(id);
-    }
-    /**
-     * Show profile switcher (Shift+Tab)
-     */
-    showProfileSwitcher(profiles, _currentProfile) {
-        this.updateCoordinator.enqueue({
-            lane: 'overlay',
-            description: 'profile-switcher',
-            coalesceKey: 'overlay:profile-switcher',
-            priority: 'normal',
-            mode: ['idle', 'processing'],
-            run: () => {
-                const terminalWidth = getTerminalColumns();
-                const separator = '─'.repeat(terminalWidth - 1);
-                const profileLines = profiles.map(profile => {
-                    return `  ${profile.command}\n      ${profile.description}`;
-                }).join('\n');
-                const header = `Switch Profile (Shift+Tab)`;
-                const content = `${separator}\n${header}\n${separator}\n${profileLines}\n\nPress number to switch or Esc to cancel`;
-                this.uiController.updateCommandsOverlay(content);
-                if (this.profileSwitcherTimeout) {
-                    clearTimeout(this.profileSwitcherTimeout);
-                }
-                this.profileSwitcherTimeout = setTimeout(() => {
-                    this.uiController.hideCommandsOverlay();
-                    this.profileSwitcherTimeout = undefined;
-                }, 5000);
-            },
-        });
-    }
-    /**
-     * Enable or disable overlay
-     */
-    setOverlayEnabled(enabled) {
-        this.config.enableOverlay = enabled;
-        this.uiController.updateConfig({ enableOverlay: enabled });
-    }
-    /**
-     * Get telemetry data (only available in unified mode)
-     */
-    getTelemetry() {
-        return {
-            snapshot: this.uiController.getTelemetrySnapshot(),
-            performance: this.uiController.getPerformanceSummary(),
-        };
-    }
-    /**
-     * Get action description for tool execution (Erosolar-CLI style)
-     * Returns a human-readable description of what the tool is doing
-     * Includes the actual file path, command, or search target when available
-     */
-    getToolActionDescription(call, progress) {
-        const args = call.arguments;
-        let description;
-        switch (call.name) {
-            case 'Read':
-            case 'read_file': {
-                const filePath = this.extractPath(args, ['file_path', 'path']);
-                description = filePath ? `Reading ${this.truncatePath(filePath)}` : 'Reading file...';
-                break;
-            }
-            case 'Write':
-            case 'write_file': {
-                const filePath = this.extractPath(args, ['file_path', 'path']);
-                description = filePath ? `Writing ${this.truncatePath(filePath)}` : 'Writing file...';
-                break;
-            }
-            case 'Edit':
-            case 'edit_file': {
-                const filePath = this.extractPath(args, ['file_path', 'path']);
-                description = filePath ? `Editing ${this.truncatePath(filePath)}` : 'Editing file...';
-                break;
-            }
-            case 'Bash':
-            case 'bash': {
-                const command = args?.['command'];
-                if (command) {
-                    // Show first meaningful part of command (truncated)
-                    const shortCmd = command.split('\n')[0]?.trim() || command;
-                    const truncated = shortCmd.length > 40 ? `${shortCmd.slice(0, 37)}...` : shortCmd;
-                    description = `Running: ${truncated}`;
-                }
-                else {
-                    description = 'Executing command...';
-                }
-                break;
-            }
-            case 'Grep':
-            case 'grep': {
-                const pattern = args?.['pattern'];
-                const path = this.extractPath(args, ['path', 'directory']);
-                if (pattern) {
-                    const truncPattern = pattern.length > 20 ? `${pattern.slice(0, 17)}...` : pattern;
-                    description = path
-                        ? `Searching "${truncPattern}" in ${this.truncatePath(path)}`
-                        : `Searching for "${truncPattern}"`;
-                }
-                else {
-                    description = 'Searching code...';
-                }
-                break;
-            }
-            case 'Glob':
-            case 'glob': {
-                const pattern = args?.['pattern'];
-                description = pattern ? `Finding files: ${pattern}` : 'Finding files...';
-                break;
-            }
-            case 'list_files': {
-                const path = this.extractPath(args, ['path']);
-                description = path ? `Listing ${this.truncatePath(path)}` : 'Listing files...';
-                break;
-            }
-            case 'WebFetch':
-            case 'web_fetch': {
-                const url = args?.['url'];
-                if (url) {
-                    try {
-                        const hostname = new URL(url).hostname;
-                        description = `Fetching ${hostname}`;
-                    }
-                    catch {
-                        description = 'Fetching web content...';
-                    }
-                }
-                else {
-                    description = 'Fetching web content...';
-                }
-                break;
-            }
-            case 'WebSearch':
-            case 'web_search': {
-                const query = args?.['query'];
-                if (query) {
-                    const truncQuery = query.length > 30 ? `${query.slice(0, 27)}...` : query;
-                    description = `Searching: "${truncQuery}"`;
-                }
-                else {
-                    description = 'Searching web...';
-                }
-                break;
-            }
-            case 'Task':
-            case 'task': {
-                const taskDesc = args?.['description'];
-                description = taskDesc ? `Task: ${taskDesc}` : 'Running task...';
-                break;
-            }
-            default:
-                description = `Executing ${call.name}...`;
-        }
-        if (progress) {
-            const details = [];
-            if (progress.message?.trim()) {
-                details.push(progress.message.trim());
-            }
-            if (typeof progress.total === 'number' && progress.total > 0) {
-                const pct = Math.max(0, Math.min(100, Math.round((progress.current / progress.total) * 100)));
-                details.push(`${pct}%`);
-            }
-            if (details.length) {
-                return `${description} (${details.join(' ')})`;
-            }
-        }
-        return description;
-    }
-    /**
-     * Extract a path from tool arguments, checking multiple possible keys
-     */
-    extractPath(args, keys) {
-        if (!args)
-            return undefined;
-        for (const key of keys) {
-            const value = args[key];
-            if (typeof value === 'string' && value.trim()) {
-                return value.trim();
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Truncate a file path to show just the filename or last path segments
-     * e.g., "/Users/bo/GitHub/project/src/ui/display.ts" -> "src/ui/display.ts"
-     */
-    truncatePath(fullPath, maxLen = 50) {
-        if (fullPath.length <= maxLen)
-            return fullPath;
-        const parts = fullPath.split('/').filter(Boolean);
-        if (parts.length <= 2)
-            return fullPath;
-        // Start from the end and build up until we exceed maxLen
-        let result = parts[parts.length - 1] || '';
-        for (let i = parts.length - 2; i >= 0; i--) {
-            const candidate = `${parts[i]}/${result}`;
-            if (candidate.length > maxLen - 3) {
-                return `.../${result}`;
-            }
-            result = candidate;
-        }
-        return result;
-    }
-    /**
-     * Set file change tracking callback
-     */
-    setFileChangeCallback(callback) {
-        this.fileChangeCallback = callback;
-    }
-    /**
-     * Set tool status callback - called when tools start/complete to update dynamic status
-     */
-    setToolStatusCallback(callback) {
-        this._toolStatusCallback = callback;
-        if (callback && this.activeToolStatus) {
-            callback(this.buildRunningStatusLine(this.activeToolStatus.description, this.activeToolStatus.startedAt));
-        }
-    }
-    /**
-     * Set activity callback - called during tool progress to update activity line with streaming output
-     */
-    setActivityCallback(callback) {
-        this._activityCallback = callback;
-    }
-    /**
-     * Keep a live status line ticking while an SSE tool or long-running tool is active.
-     * Uses a heartbeat to animate the spinner and update elapsed time without spamming writes.
-     */
-    startToolStatusHeartbeat(callId) {
-        if (!this._toolStatusCallback || !this.activeToolStatus) {
-            return;
-        }
-        // Stop any previous heartbeat to avoid overlapping timers
-        this.stopToolStatusHeartbeat();
-        const heartbeatId = `tool-status:${callId}`;
-        this.activeToolHeartbeatId = heartbeatId;
-        this.updateCoordinator.startHeartbeat(heartbeatId, {
-            intervalMs: 1000,
-            description: 'live tool status ticker',
-            lane: 'status',
-            priority: 'low',
-            mode: ['processing', 'tooling', 'streaming', 'mcp'],
-            run: () => {
-                if (!this._toolStatusCallback || !this.activeToolStatus) {
-                    this.stopToolStatusHeartbeat();
-                    return;
-                }
-                const statusLine = this.buildRunningStatusLine(this.activeToolStatus.description, this.activeToolStatus.startedAt);
-                this._toolStatusCallback(statusLine);
-            },
+        const remaining = entries.length - top.length;
+        const joiner = options.plain ? ' · ' : '  ';
+        const formatted = top.map(([name, count]) => {
+            const label = options.plain ? name : name;
+            return `${label} x${count}`;
         });
-    }
-    stopToolStatusHeartbeat() {
-        if (this.activeToolHeartbeatId) {
-            this.updateCoordinator.stopHeartbeat(this.activeToolHeartbeatId);
-        }
-        this.activeToolHeartbeatId = null;
-        this.activeToolStatus = null;
-        this.statusSpinnerIndex = 0;
-    }
-    buildRunningStatusLine(description, startedAt) {
-        const frames = Array.isArray(icons.spinner) ? icons.spinner : [icons.loading];
-        const frame = frames[this.statusSpinnerIndex % frames.length] ?? frames[0] ?? icons.bullet;
-        this.statusSpinnerIndex += 1;
-        const elapsed = this.formatElapsedMs(Date.now() - startedAt);
-        const metaParts = [];
-        if (elapsed) {
-            metaParts.push(`${theme.metrics.elapsedLabel('elapsed')} ${theme.metrics.elapsedValue(elapsed)}`);
-        }
-        if (process.stdout.isTTY) {
-            metaParts.push(theme.ui.muted('esc to interrupt'));
-        }
-        const meta = metaParts.length ? ` (${metaParts.join(theme.ui.muted(' • '))})` : '';
-        return `${theme.info(frame)} ${description}${meta}`;
-    }
-    formatElapsedMs(elapsedMs) {
-        if (typeof elapsedMs !== 'number' || !Number.isFinite(elapsedMs) || elapsedMs < 0) {
-            return null;
-        }
-        const totalSeconds = Math.max(0, Math.round(elapsedMs / 1000));
-        const minutes = Math.floor(totalSeconds / 60);
-        const seconds = totalSeconds % 60;
-        if (minutes > 0) {
-            return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
-        }
-        return `${seconds}s`;
-    }
-    /**
-     * Parse file changes from Edit/Write/NotebookEdit tool output
-     */
-    parseFileChange(call, output) {
-        const args = call.arguments;
-        // Handle different path parameter names: file_path (Edit/Write), notebook_path (NotebookEdit)
-        const path = args.file_path || args.notebook_path || args.path;
-        if (!path)
-            return null;
-        // Parse additions and removals from output
-        let additions = 0;
-        let removals = 0;
-        // For Edit tool: parse "Lines changed: +X / -Y" or "+X addition -Y removal"
-        const editMatch = output.match(/\+(\d+).*-(\d+)/);
-        if (editMatch) {
-            additions = parseInt(editMatch[1] || '0', 10);
-            removals = parseInt(editMatch[2] || '0', 10);
-        }
-        // Alternative format: "X addition" and "Y removal"
-        const addMatch = output.match(/(\d+)\s+addition/);
-        const remMatch = output.match(/(\d+)\s+removal/);
-        if (addMatch)
-            additions = parseInt(addMatch[1] || '0', 10);
-        if (remMatch)
-            removals = parseInt(remMatch[1] || '0', 10);
-        // For Write tool: estimate as all additions (new file or full rewrite)
-        if (call.name === 'Write' && additions === 0 && removals === 0) {
-            const lines = (args.content || '').split('\n').length;
-            additions = lines;
-        }
-        // For NotebookEdit: estimate based on new_source content
-        if (call.name === 'NotebookEdit' && additions === 0 && removals === 0) {
-            const lines = (args.new_source || '').split('\n').length;
-            additions = lines;
-            removals = lines; // Assume cell replacement
-        }
-        return {
-            path,
-            type: call.name === 'Edit' || call.name === 'NotebookEdit' ? 'edit' : 'write',
-            additions,
-            removals
-        };
-    }
-    /**
-     * Display tool result summary using Erosolar-CLI style.
-     * Format: ⎿  Summary text
-     * Routes through display module to work with scroll regions
-     */
-    displayToolResultSummary(call, output, success) {
-        const args = call.arguments || {};
-        // Get compact summary for the result
-        const summary = this.formatClaudeCodeResultSummary(call.name, args, output, success);
-        if (summary) {
-            // Erosolar-CLI style: ⎿  Summary (indented under tool call)
-            const prefix = success
-                ? theme.success(icons.subaction)
-                : theme.error(icons.subaction);
-            // Single newline - next tool call adds its own spacing
-            this.display.stream(`  ${prefix}  ${summary}\n`);
-        }
-    }
-    /**
-     * Format tool result summary in Erosolar-CLI style
-     * Returns compact summary like "Found 4 files" or "Read 50 lines"
-     */
-    formatClaudeCodeResultSummary(toolName, args, output, success) {
-        if (!success) {
-            // Error case - show error message
-            const errorMsg = output.length > 60 ? `${output.slice(0, 57)}...` : output;
-            return theme.error(errorMsg);
-        }
-        switch (toolName) {
-            case 'Read':
-            case 'read_file': {
-                const lines = this.countLines(output);
-                const path = args['file_path'] || args['path'];
-                if (path) {
-                    return `${this.truncatePath(String(path), 40)} · ${theme.info(String(lines))} lines`;
-                }
-                return `Read ${theme.info(String(lines))} lines`;
-            }
-            case 'Write':
-            case 'write_file': {
-                const path = args['file_path'] || args['path'];
-                const lines = (args['content'] || '').split('\n').length;
-                if (path) {
-                    return `Wrote ${theme.info(String(lines))} lines to ${this.truncatePath(String(path), 40)}`;
-                }
-                return `Wrote ${theme.info(String(lines))} lines`;
-            }
-            case 'Edit':
-            case 'edit_file': {
-                // Parse additions/removals from output
-                const editMatch = output.match(/\+(\d+).*-(\d+)/);
-                if (editMatch) {
-                    const adds = editMatch[1];
-                    const removes = editMatch[2];
-                    return `${theme.success(`+${adds}`)} ${theme.error(`-${removes}`)} lines`;
-                }
-                return 'Updated file';
-            }
-            case 'Grep':
-            case 'grep':
-            case 'Search': {
-                const outputLines = output.trim().split('\n').filter(l => l.trim());
-                const count = outputLines.length;
-                const outputMode = args['output_mode'];
-                if (count === 0) {
-                    return theme.ui.muted('No matches found');
-                }
-                if (outputMode === 'content') {
-                    return `Found ${theme.info(String(count))} lines`;
-                }
-                return `Found ${theme.info(String(count))} files`;
-            }
-            case 'Glob':
-            case 'glob': {
-                const files = output.trim().split('\n').filter(f => f.trim());
-                const count = files.length;
-                if (count === 0) {
-                    return theme.ui.muted('No files found');
-                }
-                return `Found ${theme.info(String(count))} file${count === 1 ? '' : 's'}`;
-            }
-            case 'list_files': {
-                const files = output.trim().split('\n').filter(f => f.trim());
-                const count = files.length;
-                const path = args['path'] || '.';
-                return `${this.truncatePath(String(path), 40)} · ${theme.info(String(count))} item${count === 1 ? '' : 's'}`;
-            }
-            case 'Bash':
-            case 'bash': {
-                const lines = output.trim().split('\n').filter(l => l).length;
-                if (lines === 0) {
-                    return theme.ui.muted('Completed (no output)');
-                }
-                return `Output: ${theme.info(String(lines))} lines`;
-            }
-            case 'WebFetch':
-            case 'web_fetch': {
-                const size = output.length;
-                const sizeStr = size > 1024 ? `${(size / 1024).toFixed(1)}KB` : `${size}B`;
-                return `Fetched ${theme.info(sizeStr)}`;
-            }
-            case 'WebSearch':
-            case 'web_search': {
-                const resultMatches = output.match(/^\d+\./gm);
-                const count = resultMatches ? resultMatches.length : 'multiple';
-                return `Found ${theme.info(String(count))} results`;
-            }
-            case 'Task':
-            case 'task': {
-                // Parse agent output to show nested tool summaries
-                return this.formatAgentResultSummary(output);
-            }
-            case 'TodoWrite':
-            case 'todo_write': {
-                const todos = args['todos'];
-                if (todos && Array.isArray(todos)) {
-                    const completed = todos.filter(t => t.status === 'completed').length;
-                    const inProgress = todos.filter(t => t.status === 'in_progress').length;
-                    const pending = todos.length - completed - inProgress;
-                    const parts = [];
-                    if (completed > 0)
-                        parts.push(theme.success(`${completed} done`));
-                    if (inProgress > 0)
-                        parts.push(theme.warning(`${inProgress} active`));
-                    if (pending > 0)
-                        parts.push(theme.ui.muted(`${pending} pending`));
-                    return `Todos: ${parts.join(', ')}`;
-                }
-                return 'Todos updated';
-            }
-            case 'grep_search':
-            case 'search_files':
-            case 'Grep': {
-                // Count matches in output - look for file paths or line numbers
-                const lines = output.trim().split('\n').filter(l => l.trim());
-                if (lines.length === 0 || output.includes('No matches found') || output.includes('no matches')) {
-                    return theme.ui.muted('No matches');
-                }
-                // Count unique files or match lines
-                const fileMatches = output.match(/^[^\n:]+:\d+:/gm);
-                if (fileMatches) {
-                    const uniqueFiles = new Set(fileMatches.map(m => m.split(':')[0])).size;
-                    return `${theme.info(String(fileMatches.length))} matches in ${uniqueFiles} file${uniqueFiles === 1 ? '' : 's'}`;
-                }
-                return `${theme.info(String(lines.length))} matches`;
-            }
-            default: {
-                // Generic result - show more info for better context
-                const lines = output.trim().split('\n').filter(l => l).length;
-                if (lines === 0) {
-                    return theme.ui.muted('No output');
-                }
-                if (lines <= 3) {
-                    // Show the actual output if short
-                    const shortOutput = output.trim().substring(0, 60);
-                    return shortOutput.length < output.trim().length ? `${shortOutput}…` : shortOutput;
-                }
-                return `${theme.info(String(lines))} lines`;
-            }
-        }
-    }
-    /**
-     * Format agent/task result summary showing nested tool uses
-     * Example output:
-     *   Read 100 lines
-     *   Found 4 lines
-     *   +31 more tool uses
-     */
-    formatAgentResultSummary(output) {
-        const lines = [];
-        // Parse output for tool use summaries
-        // Look for patterns like "Read X lines", "Found X files", "Output: X lines", etc.
-        const toolPatterns = [
-            /Read\s+(\d+)\s+lines?/gi,
-            /Found\s+(\d+)\s+(?:files?|lines?|results?|matches?)/gi,
-            /Output:\s+(\d+)\s+lines?/gi,
-            /Wrote\s+(\d+)\s+lines?/gi,
-            /Fetched\s+[\d.]+[KMB]?B?/gi,
-            /Completed/gi,
-            /Updated\s+file/gi,
-            /\+\d+\s+-\d+\s+lines?/gi,
-        ];
-        const toolUses = [];
-        const seenPatterns = new Set();
-        for (const pattern of toolPatterns) {
-            const matches = output.matchAll(pattern);
-            for (const match of matches) {
-                const text = match[0];
-                if (!seenPatterns.has(text.toLowerCase())) {
-                    seenPatterns.add(text.toLowerCase());
-                    toolUses.push(text);
-                }
-            }
-        }
-        // Show first 2 tool uses, then "+N more"
-        const maxShown = 2;
-        const shown = toolUses.slice(0, maxShown);
-        const remaining = toolUses.length - maxShown;
-        for (const use of shown) {
-            lines.push(use);
-        }
         if (remaining > 0) {
-            lines.push(`+${remaining} more tool uses`);
-        }
-        else if (lines.length === 0) {
-            // Fallback if no tool uses found
-            const outputLines = output.trim().split('\n').filter(l => l.trim()).length;
-            if (outputLines > 0) {
-                return `${theme.info(String(outputLines))} lines`;
-            }
-            return 'Completed';
+            formatted.push(`+${remaining} more`);
         }
-        return lines.join('\n     ');
+        return formatted.join(joiner);
     }
-    /**
-     * Extract the diff section from Edit tool output, removing repeated headers.
-     */
-    extractEditDiffSection(output) {
-        if (!output.trim()) {
-            return null;
-        }
-        const lines = output.split('\n');
-        let startIndex = 0;
-        if (lines[startIndex]?.trim().startsWith('⏺')) {
-            startIndex += 1;
-        }
-        if (lines[startIndex]?.trim().startsWith('⎿')) {
-            startIndex += 1;
-        }
-        const remaining = lines
-            .slice(startIndex)
-            .filter(line => line.trim().length > 0);
-        if (!remaining.length) {
-            return null;
-        }
-        return remaining.join('\n');
-    }
-    /**
-     * Count lines in output while ignoring trailing blank lines.
-     */
-    countLines(output) {
-        if (!output) {
-            return 0;
-        }
-        const normalized = output.replace(/\r\n/g, '\n').replace(/\n+$/g, '');
-        if (!normalized) {
-            return 0;
-        }
-        return normalized.split('\n').length;
+    dispose() {
+        this.toolUsage.clear();
+        this.toolStatusCallback = undefined;
+        this.fileChangeCallback = undefined;
+        this.renderer = null;
     }
-    /**
-     * Get UI state
-     */
-    getState() {
-        return this.uiController.getState();
+    resetToolUsage() {
+        this.toolUsage.clear();
     }
-    /**
-     * Dispose of resources
-     */
-    dispose() {
-        // Clear any pending timeouts to prevent process hang
-        if (this.profileSwitcherTimeout) {
-            clearTimeout(this.profileSwitcherTimeout);
-            this.profileSwitcherTimeout = undefined;
-        }
-        this.uiController.dispose();
+    recordToolUsage(toolName) {
+        if (!toolName)
+            return;
+        const current = this.toolUsage.get(toolName) ?? 0;
+        this.toolUsage.set(toolName, current + 1);
+    }
+    formatToolCall(call) {
+        const args = this.summarizeArgs(call.arguments ?? {});
+        return args ? `${call.name}(${args})` : call.name;
+    }
+    summarizeArgs(args) {
+        if (!args || typeof args !== 'object') {
+            return '';
+        }
+        const entries = Object.entries(args);
+        if (entries.length === 0)
+            return '';
+        const summary = entries.slice(0, 3).map(([key, value]) => `${key}: ${this.limitValue(value)}`).join(', ');
+        const suffix = entries.length > 3 ? ' …' : '';
+        return `${summary}${suffix}`;
+    }
+    limitValue(value) {
+        const text = typeof value === 'string'
+            ? value
+            : value === null || value === undefined
+                ? ''
+                : JSON.stringify(value);
+        if (!text)
+            return '';
+        const normalized = text.replace(/\s+/g, ' ').trim();
+        return normalized.length > 48 ? `${normalized.slice(0, 45)}…` : normalized;
+    }
+    formatToolResult(call, output, ok) {
+        const full = (output ?? '').toString().trim();
+        const firstLine = full.split('\n').find(line => line.trim().length > 0) ?? (ok ? 'Completed' : 'Error');
+        const needsHint = full.includes('\n') || full.length > 120;
+        const summary = `⎿ ${call.name}: ${firstLine}${needsHint ? ' (ctrl+o to expand)' : ''}`;
+        return { summary, full: full || firstLine };
     }
 }
 //# sourceMappingURL=ShellUIAdapter.js.map