@compass-ai/nova 1.0.72 → 1.0.74

package/dist/ui/components/InterleavedStream.js

@@ -0,0 +1,1500 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * React/ink component for rendering interleaved text and tool calls
+ * in Claude Code CLI style format.
+ *
+ * Example output:
+ * ```
+ * ● I'll first look at an existing ADR to understand the format...
+ *
+ * ● Read(file_path: "docs/adr/adr007.md")
+ *   ⎿  Read 473 lines
+ *
+ * ● Search(pattern: "**\/*.ts")
+ *   ⎿  Found 8 files
+ * ```
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { marked } from 'marked';
+import cliTruncate from 'cli-truncate';
+import { createMarkdownRenderer } from '../themes/markdown-theme.js';
+import { truncate, formatCompactNumber } from '../../utils/format.js';
+import { getToolRegistry } from '../../services/tool-registry.js';
+import { getSessionManager } from '../../services/session-manager.js';
+import { getRelativePath, isPathWithin } from '../../utils/path.js';
+/**
+ * Static activity indicator using empty circle.
+ * No animation to prevent layout bouncing from re-renders.
+ */
+const ActivityDot = ({ color = 'cyan' }) => {
+    return _jsx(Text, { color: color, children: "\u25CB" });
+};
+/**
+ * Word-wraps text to fit within a given width, breaking at word boundaries.
+ * Returns an array of lines. Sentences that start after a period get their own line
+ * when possible for improved readability.
+ */
+function wordWrap(text, maxWidth) {
+    if (maxWidth <= 0 || !text)
+        return [text];
+    // Split into sentences (at ". " boundaries) for intelligent breaking
+    const sentences = text.split(/(?<=\.)\s+/);
+    const lines = [];
+    let currentLine = '';
+    for (const sentence of sentences) {
+        // If adding this sentence would exceed width, start a new line
+        if (currentLine && (currentLine.length + 1 + sentence.length > maxWidth)) {
+            // If the current line is non-empty, push it
+            if (currentLine) {
+                lines.push(currentLine);
+                currentLine = '';
+            }
+        }
+        // If the sentence itself is longer than maxWidth, do word-level wrapping
+        if (sentence.length > maxWidth) {
+            const words = sentence.split(' ');
+            for (const word of words) {
+                if (!currentLine) {
+                    currentLine = word;
+                }
+                else if (currentLine.length + 1 + word.length <= maxWidth) {
+                    currentLine += ' ' + word;
+                }
+                else {
+                    lines.push(currentLine);
+                    currentLine = word;
+                }
+            }
+        }
+        else {
+            if (!currentLine) {
+                currentLine = sentence;
+            }
+            else {
+                currentLine += ' ' + sentence;
+            }
+        }
+    }
+    if (currentLine) {
+        lines.push(currentLine);
+    }
+    return lines.length > 0 ? lines : [text];
+}
+/**
+ * Converts an absolute file path to a relative path for display.
+ * Returns the original path if it's not within the project root or already relative.
+ */
+function makePathRelative(filePath) {
+    // Skip if already relative
+    if (!filePath || (!filePath.startsWith('/') && !filePath.match(/^[A-Za-z]:\\/))) {
+        return filePath;
+    }
+    try {
+        const projectRoot = getSessionManager().getProjectRoot();
+        if (projectRoot && isPathWithin(filePath, projectRoot)) {
+            const relativePath = getRelativePath(filePath, projectRoot);
+            // Return relative path, or '.' if it's the root itself
+            return relativePath || '.';
+        }
+    }
+    catch {
+        // If session manager not available, return original path
+    }
+    return filePath;
+}
+/**
+ * Map of tool names to their essential display parameters.
+ * Tools listed here will only show the specified parameters in the UI.
+ * Tools not in this map will show all parameters.
+ */
+const TOOL_DISPLAY_PARAMS = {
+    // File tools - only show path
+    read: ['file_path', 'path'],
+    read_file: ['file_path', 'path'],
+    write: ['file_path', 'path'],
+    write_file: ['file_path', 'path'],
+    edit: ['file_path', 'path'],
+    edit_file: ['file_path', 'path'],
+    delete: ['description'],
+    delete_file: ['description'],
+    create_directory: ['path'],
+    get_file_info: ['path'],
+    // Read multiple - handled specially, but define to filter params
+    read_multiple_files: ['paths'],
+    // Search tools - show pattern and path
+    glob: ['pattern', 'path'],
+    grep: ['pattern', 'path'],
+    search: ['pattern', 'path'],
+    // List tool - show pattern if present, otherwise path
+    list: ['pattern', 'path'],
+    list_directory: ['pattern', 'path'],
+    // Shell tools - show description in header, command shown separately
+    bash: ['description'],
+    shell: ['description'],
+    execute: ['description'],
+    execute_command: ['description'],
+    // Plan tools - only show task summary / modification request
+    plan: ['task_summary'],
+    update_plan: ['modification_request'],
+    complete_plan_task: ['task_id', 'summary'],
+    // Agent tools - only show task (agent type shown in display name)
+    spawn_task: ['task'],
+    task: ['prompt'],
+    // Poll task - only show process_id
+    poll_task: ['process_id'],
+};
+/**
+ * Map of tool names to their expected parameters (in generation order).
+ * Used to show progress during the 'generating' phase.
+ */
+const TOOL_EXPECTED_PARAMS = {
+    // Edit tools - typically generate path, then old content, then new content
+    edit: ['file_path', 'old_string', 'new_string'],
+    edit_file: ['file_path', 'old_string', 'new_string'],
+    // Write tools - path then content
+    write: ['file_path', 'content'],
+    write_file: ['file_path', 'content'],
+    // Read tools - just path
+    read: ['file_path'],
+    read_file: ['file_path'],
+    // Search tools
+    glob: ['pattern', 'path'],
+    grep: ['pattern', 'path'],
+    search: ['pattern', 'path'],
+    // Shell tools
+    bash: ['command', 'timeout'],
+    shell: ['command'],
+    execute: ['command'],
+    execute_command: ['command'],
+    // Task/Agent tools
+    delegate_task: ['task_description', 'context'],
+    task: ['prompt'],
+    spawn_task: ['task', 'agent_type'],
+};
+/**
+ * Human-readable labels for parameter names
+ */
+const PARAM_LABELS = {
+    file_path: 'file path',
+    old_string: 'content to replace',
+    new_string: 'new content',
+    content: 'content',
+    pattern: 'pattern',
+    path: 'path',
+    command: 'command',
+    timeout: 'timeout',
+    task_description: 'task',
+    context: 'context',
+    prompt: 'prompt',
+    subagent_type: 'agent type',
+    agent_type: 'agent type',
+    task: 'task',
+};
+/**
+ * Finds the common directory prefix from an array of file paths.
+ * Returns './' if no common prefix is found.
+ */
+function findCommonDirectory(paths) {
+    if (!paths || paths.length === 0)
+        return './';
+    // First make all paths relative to project root
+    const relativePaths = paths.map((p) => makePathRelative(p));
+    if (relativePaths.length === 1) {
+        const dir = relativePaths[0].replace(/\\/g, '/').split('/').slice(0, -1).join('/');
+        return dir || './';
+    }
+    // Normalize paths and split into parts
+    const normalizedPaths = relativePaths.map((p) => p.replace(/\\/g, '/'));
+    const splitPaths = normalizedPaths.map((p) => p.split('/'));
+    // Find common prefix
+    const minLength = Math.min(...splitPaths.map((p) => p.length));
+    const commonParts = [];
+    for (let i = 0; i < minLength - 1; i++) { // -1 to exclude filename
+        const part = splitPaths[0][i];
+        if (splitPaths.every((p) => p[i] === part)) {
+            commonParts.push(part);
+        }
+        else {
+            break;
+        }
+    }
+    if (commonParts.length === 0)
+        return './';
+    return commonParts.join('/');
+}
+/**
+ * Extracts a clean display name from an MCP tool registry name.
+ * Strips the server name prefix and shows just the tool name.
+ * Example: mcp_fetch_fetch -> "Fetch", mcp_compass_web_search -> "Web Search"
+ */
+function getMCPDisplayName(registryName) {
+    const lowerName = registryName.toLowerCase();
+    if (!lowerName.startsWith('mcp_')) {
+        return null;
+    }
+    const parts = registryName.substring(4).split('_'); // Remove 'mcp_' prefix
+    if (parts.length < 2) {
+        return null;
+    }
+    // First part is server name, rest is tool name
+    const serverName = parts[0];
+    const toolParts = parts.slice(1);
+    // Capitalize each part
+    const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+    // If server name equals tool name (e.g., mcp_fetch_fetch), just show the tool name
+    if (toolParts.length === 1 && toolParts[0].toLowerCase() === serverName.toLowerCase()) {
+        return capitalize(serverName);
+    }
+    // Otherwise show just the tool name without server prefix
+    const formattedTool = toolParts.map(capitalize).join(' ');
+    return formattedTool;
+}
+/**
+ * Computes the generating progress message for a tool.
+ * Shows which parameter is currently being generated and overall progress.
+ */
+function getGeneratingProgress(toolName, params) {
+    const toolLower = toolName.toLowerCase();
+    const expectedParams = TOOL_EXPECTED_PARAMS[toolLower];
+    if (!expectedParams) {
+        // Unknown tool - show generic message with count of received params
+        const receivedCount = Object.keys(params).length;
+        if (receivedCount === 0) {
+            return 'Preparing parameters...';
+        }
+        return `Preparing parameters (${receivedCount} received)...`;
+    }
+    const receivedParams = Object.keys(params);
+    const receivedCount = receivedParams.length;
+    const totalCount = expectedParams.length;
+    if (receivedCount === 0) {
+        // No params yet - show first expected param
+        const firstParam = expectedParams[0];
+        const label = PARAM_LABELS[firstParam] || firstParam;
+        return `Preparing ${label}...`;
+    }
+    // Find the next parameter being prepared (first expected param not yet received)
+    const nextParam = expectedParams.find((p) => !(p in params));
+    if (nextParam) {
+        const label = PARAM_LABELS[nextParam] || nextParam;
+        return `Preparing ${label} (${receivedCount}/${totalCount})...`;
+    }
+    // All expected params received, but still finalizing (maybe optional params)
+    return `Finalizing (${receivedCount}/${totalCount})...`;
+}
+/**
+ * Tools that should show only the value (no parameter name or quotes)
+ * These are typically file tools where showing just the path is cleaner
+ */
+const TOOLS_VALUE_ONLY = new Set([
+    'read', 'read_file', 'write', 'write_file', 'edit', 'edit_file', 'create_directory', 'plan',
+    'bash', 'shell', 'execute', 'execute_command', 'task', 'spawn_task', 'get_file_info',
+    'list', 'list_directory', 'update_plan', 'complete_plan_task', 'poll_task',
+]);
+/**
+ * Tools that should hide the result line (⎿  Done)
+ * These are simple operations where showing "Done" adds no value
+ */
+const TOOLS_HIDE_RESULT = new Set([
+    'create_directory',
+    'list_directory_with_sizes',
+    'git_status',
+    'git_diff',
+    'git_log',
+    'git_stage',
+    'git_commit',
+    'git_push',
+]);
+/**
+ * Tools that should collapse (hide) results by default
+ * Results are shown only when expanded with Ctrl+O
+ */
+const TOOLS_COLLAPSE_RESULT = new Set([
+    'read',
+    'read_file',
+    'read_multiple_files',
+    'grep',
+    'glob',
+    'search',
+    'task',
+    'spawn_task',
+    'delegate_task',
+]);
+/**
+ * Tools that should show only the quoted value (no parameter name, but with quotes)
+ * Example: SomeTool("value here") instead of SomeTool(param: "value here")
+ */
+const TOOLS_QUOTED_VALUE_ONLY = new Set([
+// Currently empty - add tools here if you want quoted values without param names
+]);
+/**
+ * Extracts line count from a read tool result.
+ * Accepts optional pre-parsed data to avoid JSON.parse in the render path.
+ */
+function extractLineCount(result, parsedResult) {
+    if (!result && !parsedResult)
+        return null;
+    const data = parsedResult ?? (() => { try {
+        return JSON.parse(result);
+    }
+    catch {
+        return null;
+    } })();
+    if (typeof data === 'object' && data !== null && 'content' in data && typeof data.content === 'string') {
+        return data.content.split('\n').length;
+    }
+    return null;
+}
+/**
+ * Gets the file path from a read tool block
+ */
+function getReadFilePath(tool) {
+    const path = tool.params.file_path || tool.params.path;
+    return typeof path === 'string' ? path : null;
+}
+/**
+ * Checks if a tool is a read tool
+ */
+function isReadTool(name) {
+    const lower = name.toLowerCase();
+    return lower === 'read' || lower === 'read_file';
+}
+/**
+ * Checks if a tool is an edit tool
+ */
+function isEditTool(name) {
+    const lower = name.toLowerCase();
+    return lower === 'edit' || lower === 'edit_file';
+}
+/**
+ * Gets the file path from an edit tool block
+ */
+function getEditFilePath(tool) {
+    const path = tool.params.file_path || tool.params.path;
+    return typeof path === 'string' ? path : null;
+}
+/**
+ * Extracts additions, deletions, and changes from an edit tool result
+ */
+function extractEditChanges(result, parsedResult) {
+    if (!result && !parsedResult)
+        return null;
+    const data = parsedResult ?? (() => { try {
+        return JSON.parse(result);
+    }
+    catch {
+        return null;
+    } })();
+    if (typeof data === 'object' && data !== null && 'success' in data && data.success === true) {
+        const obj = data;
+        const additions = typeof obj.additions === 'number' ? obj.additions : 0;
+        const deletions = typeof obj.deletions === 'number' ? obj.deletions : 0;
+        const changes = Array.isArray(obj.changes) ? obj.changes : [];
+        return { additions, deletions, changes };
+    }
+    return null;
+}
+/**
+ * Consolidates consecutive read operations on the same file into a single display block.
+ * This reduces visual clutter when the LLM reads the same file multiple times in succession.
+ */
+function consolidateReadBlocks(blocks) {
+    const result = [];
+    let i = 0;
+    while (i < blocks.length) {
+        const block = blocks[i];
+        // Check if this is a completed read tool
+        if (block.type === 'tool' && isReadTool(block.name) &&
+            (block.status === 'success' || block.status === 'error')) {
+            const filePath = getReadFilePath(block);
+            if (filePath) {
+                // Look ahead for consecutive reads of the same file
+                const consecutiveReads = [block];
+                let j = i + 1;
+                while (j < blocks.length) {
+                    const nextBlock = blocks[j];
+                    if (nextBlock.type === 'tool' && isReadTool(nextBlock.name) &&
+                        (nextBlock.status === 'success' || nextBlock.status === 'error') &&
+                        getReadFilePath(nextBlock) === filePath) {
+                        consecutiveReads.push(nextBlock);
+                        j++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                // If we found multiple consecutive reads, consolidate them
+                if (consecutiveReads.length > 1) {
+                    const durations = [];
+                    const lineCounts = [];
+                    let hasError = false;
+                    let errorMsg;
+                    for (const read of consecutiveReads) {
+                        if (read.duration_ms !== undefined) {
+                            durations.push(read.duration_ms);
+                        }
+                        const lineCount = extractLineCount(read.result, read.parsedResult);
+                        if (lineCount !== null) {
+                            lineCounts.push(lineCount);
+                        }
+                        if (read.status === 'error') {
+                            hasError = true;
+                            errorMsg = read.error;
+                        }
+                    }
+                    result.push({
+                        type: 'consolidated_read',
+                        filePath,
+                        durations,
+                        lineCounts,
+                        status: hasError ? 'error' : 'success',
+                        error: errorMsg,
+                        originalBlocks: consecutiveReads,
+                    });
+                    i = j;
+                    continue;
+                }
+            }
+        }
+        // Not a read tool or single read - add as-is
+        result.push(block);
+        i++;
+    }
+    return result;
+}
+/**
+ * Consolidates consecutive edit operations on the same file into a single display block.
+ * This reduces visual clutter when the LLM edits the same file multiple times in succession.
+ */
+function consolidateEditBlocks(blocks) {
+    const result = [];
+    let i = 0;
+    while (i < blocks.length) {
+        const block = blocks[i];
+        // Check if this is a completed edit tool
+        if (block.type === 'tool' && isEditTool(block.name) &&
+            (block.status === 'success' || block.status === 'error')) {
+            const filePath = getEditFilePath(block);
+            if (filePath) {
+                // Look ahead for consecutive edits of the same file
+                const consecutiveEdits = [block];
+                let j = i + 1;
+                while (j < blocks.length) {
+                    const nextBlock = blocks[j];
+                    if (nextBlock.type === 'tool' && isEditTool(nextBlock.name) &&
+                        (nextBlock.status === 'success' || nextBlock.status === 'error') &&
+                        getEditFilePath(nextBlock) === filePath) {
+                        consecutiveEdits.push(nextBlock);
+                        j++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                // If we found multiple consecutive edits, consolidate them
+                if (consecutiveEdits.length > 1) {
+                    const durations = [];
+                    const additions = [];
+                    const deletions = [];
+                    const allChanges = [];
+                    let hasError = false;
+                    let errorMsg;
+                    for (const edit of consecutiveEdits) {
+                        if (edit.duration_ms !== undefined) {
+                            durations.push(edit.duration_ms);
+                        }
+                        const extracted = extractEditChanges(edit.result, edit.parsedResult);
+                        if (extracted !== null) {
+                            additions.push(extracted.additions);
+                            deletions.push(extracted.deletions);
+                            allChanges.push(...extracted.changes);
+                        }
+                        if (edit.status === 'error') {
+                            hasError = true;
+                            errorMsg = edit.error;
+                        }
+                    }
+                    result.push({
+                        type: 'consolidated_edit',
+                        filePath,
+                        durations,
+                        additions,
+                        deletions,
+                        allChanges,
+                        status: hasError ? 'error' : 'success',
+                        error: errorMsg,
+                        originalBlocks: consecutiveEdits,
+                    });
+                    i = j;
+                    continue;
+                }
+            }
+        }
+        // Not an edit tool or single edit - add as-is
+        result.push(block);
+        i++;
+    }
+    return result;
+}
+/**
+ * Extracts an AgentEntry from a ToolStreamBlock for agent/task tools.
+ */
+function extractAgentEntry(block) {
+    const params = block.params;
+    const rawDescription = (params.task || params.prompt || params.description || '');
+    const taskDescription = rawDescription.length > 120
+        ? rawDescription.slice(0, 117) + '...'
+        : rawDescription;
+    const agentType = (params.agent_type || params.subagent_type || '');
+    const agentTypeLabel = agentType
+        ? agentType
+            .split(/[-_]/)
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ')
+        : 'Task';
+    let toolCallCount;
+    let tokensUsed;
+    let resultSummary;
+    let rawResult;
+    const error = block.error;
+    if (block.result) {
+        rawResult = block.result;
+        try {
+            const resultData = block.parsedResult ?? JSON.parse(block.result);
+            if (typeof resultData === 'object' && resultData !== null) {
+                if (typeof resultData.toolCallCount === 'number') {
+                    toolCallCount = resultData.toolCallCount;
+                }
+                if (resultData.usage && typeof resultData.usage === 'object') {
+                    if (typeof resultData.usage.tokensUsed === 'number') {
+                        tokensUsed = resultData.usage.tokensUsed;
+                    }
+                }
+                // Extract a short result summary
+                const content = (resultData.content || resultData.response || '');
+                if (typeof content === 'string' && content.length > 0) {
+                    // Take the last non-empty line as summary
+                    const lines = content.split('\n').filter((l) => l.trim().length > 0);
+                    const lastLine = lines[lines.length - 1] || '';
+                    resultSummary = lastLine.length > 80 ? lastLine.slice(0, 77) + '...' : lastLine;
+                }
+            }
+        }
+        catch {
+            // Not JSON, use raw result
+        }
+    }
+    if (block.status === 'error') {
+        resultSummary = error || 'Error';
+    }
+    else if (block.status === 'success' && !resultSummary) {
+        resultSummary = 'Done';
+    }
+    return {
+        taskDescription,
+        agentTypeLabel,
+        toolCallCount,
+        tokensUsed,
+        resultSummary,
+        status: block.status,
+        error,
+        rawResult,
+    };
+}
+/**
+ * Consolidates consecutive agent/task tool calls into a single display block.
+ * Groups 2+ consecutive agent blocks into a ConsolidatedAgentBlock.
+ */
+function consolidateAgentBlocks(blocks) {
+    const result = [];
+    let i = 0;
+    while (i < blocks.length) {
+        const block = blocks[i];
+        // Check if this is an agent tool (any status)
+        if (block.type === 'tool' && isAgentTool(block.name)) {
+            // Look ahead for consecutive agent blocks
+            const consecutiveAgents = [block];
+            let j = i + 1;
+            while (j < blocks.length) {
+                const nextBlock = blocks[j];
+                if (nextBlock.type === 'tool' && isAgentTool(nextBlock.name)) {
+                    consecutiveAgents.push(nextBlock);
+                    j++;
+                }
+                else {
+                    break;
+                }
+            }
+            // If we found multiple consecutive agents, consolidate them
+            if (consecutiveAgents.length > 1) {
+                const agents = consecutiveAgents.map(extractAgentEntry);
+                // Compute combined status: generating > running > error/success
+                let combinedStatus = 'success';
+                for (const agent of agents) {
+                    if (agent.status === 'generating') {
+                        combinedStatus = 'generating';
+                        break;
+                    }
+                    if (agent.status === 'running' || agent.status === 'pending') {
+                        combinedStatus = 'running';
+                    }
+                    if (agent.status === 'error' && combinedStatus !== 'running') {
+                        combinedStatus = 'error';
+                    }
+                }
+                result.push({
+                    type: 'consolidated_agent',
+                    agents,
+                    status: combinedStatus,
+                    originalBlocks: consecutiveAgents,
+                });
+                i = j;
+                continue;
+            }
+        }
+        // Not an agent tool or single agent - add as-is
+        result.push(block);
+        i++;
+    }
+    return result;
+}
+/**
+ * Formats tool parameters for display
+ * Example for file tools: src/index.ts
+ * Example for other tools: pattern: "*.tsx", path: "src"
+ */
+function formatParams(params, maxLength = 100, toolName) {
+    let entries = Object.entries(params);
+    if (entries.length === 0)
+        return '';
+    // Filter to essential params if tool has a display config
+    if (toolName) {
+        const toolLower = toolName.toLowerCase();
+        const essentialParams = TOOL_DISPLAY_PARAMS[toolLower];
+        if (essentialParams) {
+            entries = entries.filter(([key]) => essentialParams.includes(key));
+        }
+        // Special handling for read_multiple_files: show common directory
+        if (toolLower === 'read_multiple_files' && 'paths' in params && Array.isArray(params.paths)) {
+            const paths = params.paths;
+            const commonDir = findCommonDirectory(paths);
+            return commonDir;
+        }
+        // Special handling for List tool: show pattern if present, otherwise path
+        if ((toolLower === 'list' || toolLower === 'list_directory') && ('pattern' in params || 'path' in params)) {
+            const pattern = params.pattern;
+            const path = params.path;
+            // Prefer pattern over path for display
+            if (pattern && pattern !== '*') {
+                return pattern;
+            }
+            if (path) {
+                return makePathRelative(path);
+            }
+            return '.';
+        }
+        // Special handling for MCP fetch-like tools: only show URL
+        if (toolLower.startsWith('mcp_') && (toolLower.includes('fetch') || toolLower.includes('browse'))) {
+            if ('url' in params && typeof params.url === 'string') {
+                const url = params.url;
+                // Show just the URL, truncated if needed
+                return url.length > 70 ? truncate(url, 70) : url;
+            }
+        }
+        // Special handling for MCP search-like tools: only show query
+        if (toolLower.startsWith('mcp_') && toolLower.includes('search')) {
+            entries = entries.filter(([key]) => key === 'query');
+        }
+    }
+    if (entries.length === 0)
+        return '';
+    // For file tools (Read, Write, Edit), show just the value without key/quotes
+    const toolLower = toolName?.toLowerCase() ?? '';
+    const valueOnly = TOOLS_VALUE_ONLY.has(toolLower);
+    const quotedValueOnly = TOOLS_QUOTED_VALUE_ONLY.has(toolLower);
+    // Parameters that contain file paths and should be made relative
+    const FILE_PATH_PARAMS = new Set(['file_path', 'path', 'paths']);
+    const formatted = entries
+        .map(([key, value]) => {
+        if (typeof value === 'string') {
+            // Convert file paths to relative paths for display
+            let processedValue = value;
+            if (FILE_PATH_PARAMS.has(key)) {
+                processedValue = makePathRelative(value);
+            }
+            const valueMaxLen = valueOnly ? maxLength : 70;
+            const displayValue = processedValue.length > valueMaxLen ? truncate(processedValue, valueMaxLen) : processedValue;
+            // For value-only tools, just show the value without key or quotes
+            if (valueOnly) {
+                return displayValue;
+            }
+            // For quoted-value-only tools, show the value with quotes but no key
+            if (quotedValueOnly) {
+                return `"${displayValue}"`;
+            }
+            return `${key}: "${displayValue}"`;
+        }
+        if (typeof value === 'boolean' || typeof value === 'number') {
+            return `${key}: ${value}`;
+        }
+        if (Array.isArray(value)) {
+            return `${key}: [${value.length} items]`;
+        }
+        if (value && typeof value === 'object') {
+            return `${key}: {...}`;
+        }
+        return `${key}: ${String(value)}`;
+    })
+        .join(', ');
+    return formatted.length > maxLength ? truncate(formatted, maxLength) : formatted;
+}
+/**
+ * Formats tool result for display based on tool name and result data
+ */
+function formatToolResult(name, result, error, parsedResult) {
+    if (error) {
+        // Simplify common error messages for cleaner UI display
+        if (error.startsWith('Text not found in file:')) {
+            return 'Text not found';
+        }
+        if (error.startsWith('Text is not unique:')) {
+            return 'Text is not unique';
+        }
+        if (error.startsWith('No change needed:')) {
+            return 'No change needed';
+        }
+        return error.length > 100 ? truncate(error, 100) : error;
+    }
+    if (!result)
+        return null;
+    // Use pre-parsed data if available, otherwise parse
+    let data = parsedResult;
+    if (data === undefined) {
+        try {
+            data = JSON.parse(result);
+        }
+        catch {
+            // Not JSON, use raw result
+            return result.length > 100 ? truncate(result, 100) : result;
+        }
+    }
+    // Format based on tool name and result structure
+    const toolLower = name.toLowerCase();
+    if (typeof data === 'object' && data !== null) {
+        const obj = data;
+        // Read tool - show line count
+        if (toolLower === 'read' || toolLower === 'read_file') {
+            if ('content' in obj && typeof obj.content === 'string') {
+                const lines = obj.content.split('\n').length;
+                return `Read ${lines} lines`;
+            }
+        }
+        // Read multiple files - handled specially in ToolBlock for list output
+        if (toolLower === 'read_multiple_files') {
+            return null;
+        }
+        // File info - show human-readable size
+        if (toolLower === 'get_file_info') {
+            if ('size' in obj && typeof obj.size === 'number') {
+                const size = obj.size;
+                if (size < 1024)
+                    return `${size} bytes`;
+                if (size < 1024 * 1024)
+                    return `${(size / 1024).toFixed(1)} KB`;
+                return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+            }
+        }
+        // Glob/Find files - show file count
+        if (toolLower === 'glob' || toolLower === 'list_files' || toolLower === 'find_files') {
+            if ('files' in obj && Array.isArray(obj.files)) {
+                const count = typeof obj.totalFound === 'number' ? obj.totalFound : obj.files.length;
+                const truncatedSuffix = obj.truncated ? '+' : '';
+                return count === 0 ? 'No files found' : `Found ${count}${truncatedSuffix} file${count === 1 ? '' : 's'}`;
+            }
+        }
+        // List/list_directory - show total count
+        if (toolLower === 'list' || toolLower === 'list_directory') {
+            // Use 'total' field if available, otherwise count entries
+            const total = typeof obj.total === 'number' ? obj.total : (Array.isArray(obj.entries) ? obj.entries.length : 0);
+            return `found ${total} total`;
+        }
+        // Grep/Search - show match count
+        if (toolLower === 'grep' || toolLower === 'search' || toolLower === 'search_code') {
+            // Use matchCount for total count (before truncation), fall back to matches.length
+            if ('matchCount' in obj && typeof obj.matchCount === 'number') {
+                const count = obj.matchCount;
+                const truncatedSuffix = obj.truncated ? '+' : '';
+                return count === 0 ? 'No matches found' : `Found ${count}${truncatedSuffix} match${count === 1 ? '' : 'es'}`;
+            }
+            if ('matches' in obj && Array.isArray(obj.matches)) {
+                const count = obj.matches.length;
+                return count === 0 ? 'No matches found' : `Found ${count} match${count === 1 ? '' : 'es'}`;
+            }
+            if ('count' in obj && typeof obj.count === 'number') {
+                const count = obj.count;
+                return count === 0 ? 'No matches found' : `Found ${count} match${count === 1 ? '' : 'es'}`;
+            }
+            if ('files' in obj && Array.isArray(obj.files)) {
+                const count = obj.files.length;
+                return count === 0 ? 'No files found' : `Found ${count} file${count === 1 ? '' : 's'}`;
+            }
+        }
+        // Bash/Shell - show exit code and output lines
+        if (toolLower === 'bash' || toolLower === 'shell' || toolLower === 'execute' || toolLower === 'execute_command') {
+            // Check for timeout first
+            if (obj.timedOut === true || obj.timed_out === true) {
+                return '(timeout)';
+            }
+            if ('exitCode' in obj || 'exit_code' in obj) {
+                const code = obj.exitCode ?? obj.exit_code ?? 0;
+                const stdout = obj.stdout ?? obj.output ?? '';
+                if (typeof stdout === 'string' && stdout.length > 0) {
+                    const lines = stdout.split('\n').filter(Boolean).length;
+                    return code === 0 ? `Ran successfully (${lines} lines)` : `Exit code ${code}`;
+                }
+                return code === 0 ? 'Ran successfully' : `Exit code ${code}`;
+            }
+        }
+        // Edit - handled specially in ToolBlock for colored output
+        if (toolLower === 'edit' || toolLower === 'edit_file') {
+            // Return null to let ToolBlock render the colored version
+            return null;
+        }
+        // Write - show success with line count and size
+        if (toolLower === 'write' || toolLower === 'write_file') {
+            if ('success' in obj && obj.success === true) {
+                const lines = typeof obj.lineCount === 'number' ? obj.lineCount : null;
+                const size = typeof obj.byteSize === 'number' ? obj.byteSize : null;
+                if (lines !== null && size !== null) {
+                    const sizeStr = size < 1024 ? `${size} B` : `${(size / 1024).toFixed(1)} KB`;
+                    return `Wrote ${lines} lines (${sizeStr})`;
+                }
+                if ('path' in obj && typeof obj.path === 'string') {
+                    const filename = obj.path.split(/[/\\]/).pop() || obj.path;
+                    return `Wrote ${filename}`;
+                }
+                return 'Done';
+            }
+        }
+        // Delete - show path in result instead of "Done"
+        if (toolLower === 'delete' || toolLower === 'delete_file') {
+            if ('success' in obj && obj.success === true && 'path' in obj && typeof obj.path === 'string') {
+                return makePathRelative(obj.path);
+            }
+        }
+        // Agent/Task tools - show model, tokens, and turns (handle both flat and nested fields)
+        if (toolLower === 'task' || toolLower === 'spawn_task' || toolLower === 'delegate_task') {
+            // Check for failure first
+            if (obj.success === false) {
+                const errorMsg = typeof obj.error === 'string' ? obj.error : 'Unknown error';
+                return `Failed: ${truncate(errorMsg, 80)}`;
+            }
+            // Background spawn — agent hasn't finished yet, just spawned
+            const processStatus = typeof obj.status === 'string' ? obj.status : '';
+            if (processStatus === 'running' || processStatus === 'pending') {
+                return 'Spawned in background';
+            }
+            const usage = (typeof obj.usage === 'object' && obj.usage !== null) ? obj.usage : null;
+            // Read agentModel with fallback to agentType
+            const agentModel = typeof obj.agentModel === 'string' ? obj.agentModel
+                : typeof obj.agentType === 'string' ? obj.agentType
+                    : 'unknown';
+            // Read tokensUsed from flat fields or nested usage object
+            const tokensUsed = typeof obj.tokensUsed === 'number' ? obj.tokensUsed
+                : (usage && typeof usage.tokensUsed === 'number') ? usage.tokensUsed
+                    : 0;
+            // Build concise completion message
+            const parts = [`using ${agentModel}`];
+            if (tokensUsed > 0) {
+                parts.push(`${formatCompactNumber(tokensUsed)} tokens`);
+            }
+            return `Done (${parts.join(', ')})`;
+        }
+        // Check for specific error codes first (before generic success/error)
+        if ('error' in obj && typeof obj.error === 'string') {
+            if (obj.error === 'FILE_MODIFIED_EXTERNALLY') {
+                return 'File was modified externally. Please re-read before editing.';
+            }
+            // Prefer the human-readable 'message' field if available
+            if ('message' in obj && typeof obj.message === 'string') {
+                return truncate(obj.message, 100);
+            }
+            return truncate(obj.error, 100);
+        }
+        // Generic success/error handling
+        if ('success' in obj) {
+            return obj.success ? 'Done' : 'Failed';
+        }
+    }
+    // Fallback: truncate raw result
+    if (typeof result === 'string' && result.length > 0) {
+        return truncate(result, 100);
+    }
+    return 'Done';
+}
+/**
+ * Renders markdown text with terminal formatting
+ */
+const MarkdownText = ({ children, indent = 2 }) => {
+    const rendered = React.useMemo(() => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        marked.setOptions({ renderer: createMarkdownRenderer() });
+        const raw = String(marked.parse(children)).trim();
+        // Truncate lines that exceed terminal width (e.g. table borders)
+        const maxWidth = Math.max(20, (process.stdout.columns || 80) - indent - 2);
+        return raw
+            .split('\n')
+            .map(line => cliTruncate(line, maxWidth, { preferTruncationOnSpace: false }))
+            .join('\n');
+    }, [children, indent]);
+    return _jsx(Text, { children: rendered });
+};
+/**
+ * Renders a text block with bullet point
+ * Uses orange bullet for task-progress variant (plan execution transitions)
+ */
+const TextBlock = ({ content, variant = 'default', }) => {
+    if (!content.trim())
+        return null;
+    // Green for task progress, white for default
+    const bulletColor = variant === 'task-progress' ? 'green' : 'white';
+    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsxs(Box, { children: [_jsx(Text, { color: bulletColor, bold: true, children: "\u25CF " }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: _jsx(MarkdownText, { children: content }) })] }) }));
+};
+/**
+ * Extracts file names and line counts from read_multiple_files result
+ * Returns an array of file info (name + line count) and error info
+ */
+function getReadMultipleFiles(result, parsedResult) {
+    if (!result && !parsedResult)
+        return null;
+    try {
+        const data = parsedResult ?? JSON.parse(result);
+        if (typeof data === 'object' && data !== null && 'files' in data && Array.isArray(data.files)) {
+            const files = [];
+            const errors = [];
+            for (const file of data.files) {
+                if (typeof file === 'object' && file !== null && 'path' in file) {
+                    const path = String(file.path);
+                    // Extract just the filename from the path
+                    const fileName = path.replace(/\\/g, '/').split('/').pop() || path;
+                    if (file.error) {
+                        errors.push(`${fileName}: ${file.error}`);
+                    }
+                    else {
+                        const lineCount = typeof file.content === 'string'
+                            ? file.content.split('\n').length
+                            : 0;
+                        files.push({ name: fileName, lineCount });
+                    }
+                }
+            }
+            return { files, errors };
+        }
+    }
+    catch {
+        // Not valid JSON
+    }
+    return null;
+}
+/**
+ * Extracts edit statistics from a tool result
+ */
+function getEditStats(result, parsedResult) {
+    if (!result && !parsedResult)
+        return null;
+    try {
+        const data = parsedResult ?? JSON.parse(result);
+        if (typeof data === 'object' && data !== null) {
+            const obj = data;
+            if ('success' in obj && obj.success === true) {
+                const additions = typeof obj.additions === 'number' ? obj.additions : null;
+                const deletions = typeof obj.deletions === 'number' ? obj.deletions : null;
+                const changes = Array.isArray(obj.changes) ? obj.changes : [];
+                return { additions, deletions, changes };
+            }
+            if ('error' in obj && typeof obj.error === 'string') {
+                const friendlyError = obj.error === 'FILE_MODIFIED_EXTERNALLY'
+                    ? 'File was modified externally. Please re-read before editing.'
+                    : obj.error;
+                return { additions: null, deletions: null, changes: [], error: friendlyError };
+            }
+        }
+    }
+    catch {
+        // Not JSON
+    }
+    return null;
+}
+/**
+ * Renders edit result with colored additions/deletions
+ */
+const EditResultDisplay = ({ additions, deletions }) => {
+    const hasAdditions = additions !== null && additions > 0;
+    const hasDeletions = deletions !== null && deletions > 0;
+    if (!hasAdditions && !hasDeletions) {
+        return _jsx(Text, { dimColor: true, children: "No changes" });
+    }
+    return (_jsxs(_Fragment, { children: [hasAdditions && (_jsxs(Text, { color: "green", children: ["+", additions, " ", additions === 1 ? 'line' : 'lines'] })), hasAdditions && hasDeletions && (_jsx(Text, { dimColor: true, children: ", " })), hasDeletions && (_jsxs(Text, { color: "red", children: ["-", deletions, " ", deletions === 1 ? 'line' : 'lines'] }))] }));
+};
+/**
+ * Renders a consolidated read block that combines multiple consecutive reads of the same file.
+ * Shows combined timing like (43+62)ms and combined lines like Read (20+40) lines
+ */
+const ConsolidatedReadBlockComponent = ({ block }) => {
+    const { filePath, durations, lineCounts, status, error } = block;
+    // Format the relative file path for display
+    const displayPath = makePathRelative(filePath);
+    // Format combined duration: sum all durations and display total
+    const formatCombinedDuration = () => {
+        if (durations.length === 0)
+            return '';
+        const totalMs = durations.reduce((sum, d) => sum + d, 0);
+        return formatDuration(totalMs);
+    };
+    // Format combined line counts: sum all lines and display total
+    const formatCombinedLines = () => {
+        if (lineCounts.length === 0)
+            return 'Read file';
+        const totalLines = lineCounts.reduce((sum, l) => sum + l, 0);
+        return `Read ${totalLines} lines`;
+    };
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: status === 'error' ? 'red' : 'cyan', children: "\u25CF" }), _jsx(Text, { children: " " }), _jsx(Text, { color: status === 'error' ? 'red' : 'cyan', children: "Read" }), _jsxs(Text, { dimColor: true, children: ["(", displayPath, ")"] }), _jsxs(Text, { dimColor: true, children: [" ", formatCombinedDuration()] })] }), _jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), error ? (_jsx(Text, { color: "red", children: truncate(error, 100) })) : (_jsx(Text, { children: formatCombinedLines() }))] })] }));
+};
+/**
+ * Constants for edit diff display
+ */
+const EDIT_DIFF_MAX_LINES = 20;
+const EDIT_DIFF_LINE_MAX_CHARS = 120;
+/**
+ * Renders a consolidated edit block that combines multiple consecutive edits of the same file.
+ * Shows combined timing and combined additions/deletions.
+ * Supports Ctrl+O to expand and show the actual diff.
+ */
+const ConsolidatedEditBlockComponent = ({ block, expanded = false, isStatic = false }) => {
+    const { filePath, durations, additions, deletions, allChanges, status, error } = block;
+    // Format the relative file path for display
+    const displayPath = makePathRelative(filePath);
+    // Format combined duration: sum all durations and display total
+    const formatCombinedDuration = () => {
+        if (durations.length === 0)
+            return '';
+        const totalMs = durations.reduce((sum, d) => sum + d, 0);
+        return formatDuration(totalMs);
+    };
+    // Calculate total additions and deletions
+    const totalAdditions = additions.reduce((sum, a) => sum + a, 0);
+    const totalDeletions = deletions.reduce((sum, d) => sum + d, 0);
+    // Collect all diff lines for expanded view
+    const diffLines = [];
+    if (expanded && allChanges.length > 0) {
+        for (const change of allChanges) {
+            // Add line range info
+            diffLines.push({ type: 'info', content: `@@ Lines ${change.lineStart}-${change.lineEnd} @@` });
+            // Add removed lines (before)
+            for (const line of change.before) {
+                diffLines.push({ type: 'removed', content: line });
+            }
+            // Add added lines (after)
+            for (const line of change.after) {
+                diffLines.push({ type: 'added', content: line });
+            }
+        }
+    }
+    // Trim diff if too long
+    const isTruncated = diffLines.length > EDIT_DIFF_MAX_LINES;
+    const displayDiffLines = diffLines.slice(0, EDIT_DIFF_MAX_LINES);
+    const hiddenLinesCount = diffLines.length - EDIT_DIFF_MAX_LINES;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: status === 'error' ? 'red' : 'cyan', children: "\u25CF" }), _jsx(Text, { children: " " }), _jsx(Text, { color: status === 'error' ? 'red' : 'cyan', children: "Edit" }), _jsxs(Text, { dimColor: true, children: ["(", displayPath, ")"] }), _jsxs(Text, { dimColor: true, children: [" ", formatCombinedDuration()] })] }), _jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), error ? (_jsx(Text, { color: "red", children: truncate(error, 100) })) : (_jsx(_Fragment, { children: _jsx(EditResultDisplay, { additions: totalAdditions, deletions: totalDeletions }) }))] }), (expanded || isStatic) && displayDiffLines.length > 0 && (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [displayDiffLines.map((line, i) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "   " }), line.type === 'info' && (_jsx(Text, { color: "cyan", children: truncate(line.content, EDIT_DIFF_LINE_MAX_CHARS) })), line.type === 'removed' && (_jsxs(Text, { color: "red", children: ["-", truncate(line.content, EDIT_DIFF_LINE_MAX_CHARS - 1)] })), line.type === 'added' && (_jsxs(Text, { color: "green", children: ["+", truncate(line.content, EDIT_DIFF_LINE_MAX_CHARS - 1)] }))] }, i))), isTruncated && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "   " }), _jsxs(Text, { dimColor: true, children: ["... (", hiddenLinesCount, " more lines)"] })] }))] }))] }));
+};
+/**
+ * Renders a consolidated agent block that combines multiple consecutive parallel agent tool calls.
+ * Displays a tree-style UI with agent descriptions, tool use counts, and token counts.
+ */
+const ConsolidatedAgentBlockComponent = ({ block, expanded = false, isStatic = false }) => {
+    const { agents, status } = block;
+    // Determine header label: if all agents share the same type, use that; otherwise "agents"
+    const allSameType = agents.every(a => a.agentTypeLabel === agents[0].agentTypeLabel);
+    const typeLabel = allSameType ? agents[0].agentTypeLabel : '';
+    const isInProgress = status === 'generating' || status === 'running';
+    const headerText = isInProgress
+        ? `Running ${agents.length} ${typeLabel ? typeLabel + ' ' : ''}agent${agents.length === 1 ? '' : 's'}…`
+        : `Ran ${agents.length} ${typeLabel ? typeLabel + ' ' : ''}agent${agents.length === 1 ? '' : 's'}`;
+    // Status color
+    const statusColor = status === 'error' ? 'red'
+        : isInProgress ? 'cyan'
+            : 'cyan';
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: statusColor, children: isInProgress ? '○' : '●' }), _jsx(Text, { children: " " }), _jsx(Text, { color: statusColor, children: headerText })] }), agents.map((agent, i) => {
+                const isLast = i === agents.length - 1;
+                const branchChar = isLast ? '└─' : '├─';
+                const continueChar = isLast ? '  ' : '│ ';
+                // Build metadata string: "· N tool uses · XK tokens"
+                const metaParts = [];
+                if (agent.toolCallCount !== undefined && agent.toolCallCount > 0) {
+                    metaParts.push(`${agent.toolCallCount} tool use${agent.toolCallCount === 1 ? '' : 's'}`);
+                }
+                if (agent.tokensUsed !== undefined && agent.tokensUsed > 0) {
+                    metaParts.push(`${formatCompactNumber(agent.tokensUsed)} tokens`);
+                }
+                const metaStr = metaParts.length > 0 ? ' · ' + metaParts.join(' · ') : '';
+                // Agent status indicator color
+                const agentColor = agent.status === 'error' ? 'red'
+                    : (agent.status === 'generating' || agent.status === 'running' || agent.status === 'pending') ? 'yellow'
+                        : undefined;
+                return (_jsxs(Box, { flexDirection: "column", marginLeft: 3, children: [_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [branchChar, " "] }), _jsx(Text, { children: agent.taskDescription || agent.agentTypeLabel }), metaStr && _jsx(Text, { dimColor: true, children: metaStr })] }), agent.resultSummary && !expanded && (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [continueChar, " \u23BF  "] }), _jsx(Text, { color: agentColor, children: agent.resultSummary })] })), expanded && agent.rawResult && (() => {
+                            const contentLines = formatAgentResultContent(agent.rawResult, true, isStatic);
+                            if (contentLines.length === 0) {
+                                return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [continueChar, " \u23BF  "] }), _jsx(Text, { children: agent.resultSummary || 'Done' })] }));
+                            }
+                            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [continueChar, " \u23BF  "] }), _jsx(Text, { children: agent.resultSummary || 'Done' })] }), contentLines.map((line, li) => (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [continueChar, "    "] }), _jsx(Text, { children: line })] }, li)))] }));
+                        })(), !agent.resultSummary && (agent.status === 'running' || agent.status === 'pending' || agent.status === 'generating') && (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [continueChar, " \u23BF  "] }), _jsx(Text, { dimColor: true, children: "Running\u2026" })] }))] }, i));
+            })] }));
+};
+/**
+ * Renders a tool call block with bullet point and result
+ */
+const ToolBlock = ({ tool, isStreaming = true, expandMCPResults = false, isStatic = false }) => {
+    const { name, params, status, result, error, duration_ms, parsedResult } = tool;
+    const formattedParams = formatParams(params, 100, name);
+    const formattedResult = formatToolResult(name, result, error, parsedResult);
+    // Check if this is a Plan tool - needs special display format
+    const isPlanTool = name.toLowerCase() === 'plan' || name.toLowerCase() === 'enter_plan_mode';
+    // Compute display name with special handling for certain tools
+    const displayName = (() => {
+        const lowerName = name.toLowerCase();
+        if (lowerName === 'read_multiple_files') {
+            return 'Read';
+        }
+        // Plan tool - show "Nova entered plan mode"
+        if (lowerName === 'plan' || lowerName === 'enter_plan_mode') {
+            return 'Nova entered plan mode';
+        }
+        if (lowerName === 'task' || lowerName === 'spawn_task' || lowerName === 'delegate_task') {
+            // Format as "Explore Agent", "Bash Agent", etc. based on agent_type/subagent_type
+            const agentType = (params.agent_type || params.subagent_type);
+            // Try to extract model from pre-parsed result (avoids JSON.parse in render path)
+            let model;
+            if (result || parsedResult) {
+                try {
+                    const resultData = parsedResult ?? JSON.parse(result);
+                    if (typeof resultData === 'object' && resultData !== null && 'agentModel' in resultData) {
+                        model = String(resultData.agentModel);
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+            if (agentType) {
+                // Convert kebab-case/snake_case to Title Case
+                const formatted = agentType
+                    .split(/[-_]/)
+                    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                    .join(' ');
+                const modelSuffix = model ? ` (${model})` : '';
+                return `${formatted} Agent${modelSuffix}`;
+            }
+            return 'Task';
+        }
+        // Execute tools - use description as the display name (no wrapper)
+        if (lowerName === 'execute' || lowerName === 'execute_command') {
+            const description = params.description;
+            if (description) {
+                return description.length > 80 ? truncate(description, 80) : description;
+            }
+            // Fallback to command if no description
+            const command = params.command;
+            if (command) {
+                return command.length > 80 ? truncate(command, 80) : command;
+            }
+            return getToolRegistry().getDisplayName(name);
+        }
+        // Handle MCP tools - show clean "Mcp Server Tool" format
+        const mcpDisplayName = getMCPDisplayName(name);
+        if (mcpDisplayName) {
+            return mcpDisplayName;
+        }
+        return getToolRegistry().getDisplayName(name);
+    })();
+    // Get plan task summary for special display format
+    const planTaskSummary = isPlanTool ? params.task_summary : undefined;
+    // Status indicator
+    const getStatusIndicator = () => {
+        switch (status) {
+            case 'generating':
+                return isStreaming ? (_jsx(ActivityDot, { color: "cyan" })) : (_jsx(Text, { color: "cyan", children: "\u25CB" }));
+            case 'running':
+                return isStreaming ? (_jsx(ActivityDot, { color: "cyan" })) : (_jsx(Text, { color: "cyan", children: "\u25CB" }));
+            case 'success':
+                return _jsx(Text, { color: "cyan", children: "\u25CF" });
+            case 'error':
+                return _jsx(Text, { color: "red", children: "\u25CF" });
+            case 'skipped':
+                return _jsx(Text, { color: "yellow", children: "\u25CF" });
+            default:
+                return _jsx(Text, { dimColor: true, children: "\u25CF" });
+        }
+    };
+    // Tool name color based on status
+    const getNameColor = () => {
+        switch (status) {
+            case 'generating':
+                return 'cyan';
+            case 'running':
+                return 'cyan';
+            case 'error':
+                return 'red';
+            case 'skipped':
+                return 'yellow';
+            default:
+                return 'cyan';
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [getStatusIndicator(), _jsx(Text, { children: " " }), _jsx(Text, { color: getNameColor(), children: displayName }), !isPlanTool && ['spawn_task', 'task', 'delegate_task'].includes(name.toLowerCase()) && (() => {
+                        const taskText = (params.task || params.prompt);
+                        if (!taskText)
+                            return null;
+                        const singleLine = taskText.replace(/[\r\n]+/g, ' ').trim();
+                        return _jsxs(Text, { dimColor: true, children: ["(", truncate(singleLine, 120), ")"] });
+                    })(), !isPlanTool && formattedParams && !['execute', 'execute_command', 'spawn_task', 'task', 'delegate_task'].includes(name.toLowerCase()) && (_jsxs(Text, { dimColor: true, children: ["(", formattedParams, ")"] })), duration_ms !== undefined && status !== 'running' && status !== 'generating' && (_jsxs(Text, { dimColor: true, children: [" ", formatDuration(duration_ms)] }))] }), isPlanTool && planTaskSummary && (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { dimColor: true, children: planTaskSummary })] })), status === 'skipped' && ['bash', 'shell', 'execute', 'execute_command'].includes(name.toLowerCase()) && (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), typeof params.command === 'string' && params.command && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: truncate(params.command, 80) }), _jsx(Text, { dimColor: true, children: " \u2192 " })] })), _jsx(Text, { color: "yellow", children: "Skipped" })] })), status !== 'running' && status !== 'pending' && status !== 'generating' && status !== 'skipped' && formattedResult && !(status === 'success' && TOOLS_HIDE_RESULT.has(name.toLowerCase())) && !(status === 'success' && TOOLS_COLLAPSE_RESULT.has(name.toLowerCase()) && !expandMCPResults) && !isMCPTool(name) && (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), ['bash', 'shell', 'execute', 'execute_command'].includes(name.toLowerCase()) && typeof params.command === 'string' && params.command ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: truncate(params.command, 80) }), _jsx(Text, { dimColor: true, children: " \u2192 " }), _jsx(Text, { color: status === 'error' ? 'red' : undefined, children: formattedResult })] })) : (_jsx(Text, { color: status === 'error' ? 'red' : undefined, children: formattedResult }))] })), (name.toLowerCase() === 'edit' || name.toLowerCase() === 'edit_file') && status !== 'running' && status !== 'pending' && status !== 'generating' && (() => {
+                const editStats = getEditStats(result, parsedResult);
+                if (editStats?.error) {
+                    return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { color: "red", children: truncate(editStats.error, 100) })] }));
+                }
+                if (editStats) {
+                    // Build diff lines for expanded view
+                    const diffLines = [];
+                    if (expandMCPResults && editStats.changes.length > 0) {
+                        for (const change of editStats.changes) {
+                            diffLines.push({ type: 'info', content: `@@ Lines ${change.lineStart}-${change.lineEnd} @@` });
+                            for (const line of change.before) {
+                                diffLines.push({ type: 'removed', content: line });
+                            }
+                            for (const line of change.after) {
+                                diffLines.push({ type: 'added', content: line });
+                            }
+                        }
+                    }
+                    const isTruncated = diffLines.length > EDIT_DIFF_MAX_LINES;
+                    const displayDiffLines = diffLines.slice(0, EDIT_DIFF_MAX_LINES);
+                    const hiddenLinesCount = diffLines.length - EDIT_DIFF_MAX_LINES;
+                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(EditResultDisplay, { additions: editStats.additions, deletions: editStats.deletions })] }), (expandMCPResults || isStatic) && displayDiffLines.length > 0 && (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [displayDiffLines.map((line, i) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "   " }), line.type === 'info' && (_jsx(Text, { color: "cyan", children: truncate(line.content, EDIT_DIFF_LINE_MAX_CHARS) })), line.type === 'removed' && (_jsxs(Text, { color: "red", children: ["-", truncate(line.content, EDIT_DIFF_LINE_MAX_CHARS - 1)] })), line.type === 'added' && (_jsxs(Text, { color: "green", children: ["+", truncate(line.content, EDIT_DIFF_LINE_MAX_CHARS - 1)] }))] }, i))), isTruncated && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "   " }), _jsxs(Text, { dimColor: true, children: ["... (", hiddenLinesCount, " more lines)"] })] }))] }))] }));
+                }
+                return null;
+            })(), name.toLowerCase() === 'read_multiple_files' && status !== 'running' && status !== 'pending' && status !== 'generating' && (() => {
+                const fileData = getReadMultipleFiles(result, parsedResult);
+                if (fileData) {
+                    // Only show file list when expanded, but always show errors
+                    const showFileList = expandMCPResults || status !== 'success';
+                    const maxFilesToShow = 5;
+                    const filesToShow = fileData.files.slice(0, maxFilesToShow);
+                    const remainingCount = fileData.files.length - maxFilesToShow;
+                    // If collapsed and no errors, show nothing
+                    if (!showFileList && fileData.errors.length === 0) {
+                        return null;
+                    }
+                    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [showFileList && filesToShow.map((file, i) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { children: file.name }), _jsxs(Text, { dimColor: true, children: [" (", file.lineCount, " lines)"] })] }, i))), showFileList && remainingCount > 0 && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsxs(Text, { dimColor: true, children: ["...and ", remainingCount, " more"] })] })), fileData.errors.map((err, i) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { color: "red", children: err })] }, `err-${i}`)))] }));
+                }
+                return null;
+            })(), isMCPTool(name) && status !== 'running' && status !== 'pending' && status !== 'generating' && (() => {
+                // Handle errors
+                if (error) {
+                    return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { color: "red", children: truncate(error, MCP_RESULT_LINE_MAX_CHARS) })] }));
+                }
+                // Handle successful results with multi-line display
+                if (result) {
+                    const lines = formatMCPResultLines(result, expandMCPResults);
+                    if (lines.length === 0) {
+                        return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { children: "Done" })] }));
+                    }
+                    return (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: lines.map((line, i) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: i === 0 ? '⎿  ' : '   ' }), _jsx(Text, { color: status === 'error' ? 'red' : undefined, children: line })] }, i))) }));
+                }
+                return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { children: "Done" })] }));
+            })(), isAgentTool(name) && status !== 'running' && status !== 'pending' && status !== 'generating' && (() => {
+                // Handle errors
+                if (error) {
+                    return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { color: "red", children: truncate(error, MCP_RESULT_LINE_MAX_CHARS) })] }));
+                }
+                // Handle successful results with multi-line display
+                if (result) {
+                    const contentLines = formatAgentResultContent(result, expandMCPResults, isStatic, parsedResult);
+                    if (contentLines.length === 0) {
+                        // No content to display, show formatted result summary instead
+                        return formattedResult ? (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { children: formattedResult })] })) : (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { children: "Done" })] }));
+                    }
+                    // Show content with expand hint
+                    const shouldShowHint = false; // Ctrl+O no longer functional
+                    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), formattedResult && _jsx(Text, { children: formattedResult })] }), contentLines.map((line, i) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "   " }), _jsx(Text, { color: status === 'error' ? 'red' : undefined, children: line })] }, i))), shouldShowHint && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "   " }), _jsx(Text, { dimColor: true, children: "(Ctrl+O to expand)" })] }))] }));
+                }
+                return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { children: "Done" })] }));
+            })(), status === 'generating' && (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { color: "cyan", children: getGeneratingProgress(name, params) })] })), status === 'running' && (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [tool.complexityReasoning && (() => {
+                        const indent = 5; // "  ⎿  " = marginLeft(2) + "⎿  "(3)
+                        const availableWidth = Math.max(40, (process.stdout.columns || 80) - indent);
+                        const wrappedLines = wordWrap(tool.complexityReasoning, availableWidth);
+                        return (_jsx(Box, { flexDirection: "column", children: wrappedLines.map((line, i) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: i === 0 ? '⎿  ' : '   ' }), _jsx(Text, { color: "magenta", children: line })] }, i))) }));
+                    })(), ['bash', 'shell', 'execute', 'execute_command'].includes(name.toLowerCase()) && typeof params.command === 'string' && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "\u23BF  " }), _jsx(Text, { children: truncate(params.command, 80) })] })), (tool.statusMessage || 'Executing...').split('\n').map((line, i) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '   ' }), _jsx(Text, { dimColor: true, children: line })] }, i))), name.toLowerCase() === 'execute_command' && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '   ' }), _jsx(Text, { dimColor: true, children: "Ctrl+X to skip" })] }))] }))] }));
+};
+/**
+ * Formats duration in ms to human readable
+ */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+}
+/**
+ * Tools that should be hidden from UI display (internal/progress tools)
+ */
+const HIDDEN_TOOLS = new Set(['complete_plan_task']);
+/**
+ * Constants for MCP result display
+ */
+const MCP_RESULT_MAX_LINES = 5;
+const MCP_RESULT_LINE_MAX_CHARS = 100;
+/**
+ * Formats MCP tool result into multiple lines for display.
+ * Returns an array of lines, truncated to max lines unless expanded.
+ */
+function formatMCPResultLines(result, expanded = false) {
+    if (!result)
+        return [];
+    // Clean up the result - remove excessive whitespace and normalize
+    const cleaned = result
+        .replace(/\\n/g, '\n') // Handle escaped newlines
+        .replace(/\r\n/g, '\n') // Normalize line endings
+        .trim();
+    // Split into lines and filter empty ones
+    const lines = cleaned.split('\n').filter(line => line.trim().length > 0);
+    if (lines.length === 0) {
+        return [truncate(cleaned, MCP_RESULT_LINE_MAX_CHARS)];
+    }
+    // When expanded, show all lines; otherwise limit to max
+    const maxLines = expanded ? lines.length : MCP_RESULT_MAX_LINES;
+    const displayLines = lines.slice(0, maxLines);
+    // Truncate each line (even when expanded, keep lines readable)
+    const maxChars = expanded ? 500 : MCP_RESULT_LINE_MAX_CHARS;
+    const truncatedLines = displayLines.map(line => truncate(line.trim(), maxChars));
+    // Add indicator if there are more lines (only when not expanded)
+    if (!expanded && lines.length > maxLines) {
+        truncatedLines.push(`... (${lines.length - maxLines} more lines)`);
+    }
+    return truncatedLines;
+}
+/**
+ * Checks if a tool is an MCP tool.
+ */
+function isMCPTool(toolName) {
+    return toolName.toLowerCase().startsWith('mcp_');
+}
+/**
+ * Checks if a tool is an agent/task tool.
+ */
+function isAgentTool(toolName) {
+    const lowerName = toolName.toLowerCase();
+    return lowerName === 'task' || lowerName === 'spawn_task' || lowerName === 'delegate_task';
+}
+/**
+ * Formats agent tool result content for multi-line display.
+ * Extracts the 'content' or 'response' field from the result JSON.
+ */
+function formatAgentResultContent(result, expanded = false, _isStatic = false, parsedResult) {
+    try {
+        const resultData = parsedResult ?? JSON.parse(result);
+        if (typeof resultData === 'object' && resultData !== null) {
+            // Extract content from either 'content' or 'response' field
+            const content = (resultData.content || resultData.response || '');
+            if (typeof content === 'string' && content.length > 0) {
+                // Use same formatting as MCP tools
+                return formatMCPResultLines(content, expanded);
+            }
+        }
+    }
+    catch {
+        // If parsing fails, return empty array
+    }
+    return [];
+}
+/**
+ * InterleavedStream renders a sequence of text and tool blocks
+ * in Claude Code CLI style format.
+ * Memoized to prevent unnecessary re-renders during modal displays.
+ */
+const InterleavedStreamComponent = ({ blocks, isStreaming, showThinkingIndicator = true, expandMCPResults = false, isStatic = false, maxVisibleBlocks, }) => {
+    // Memoize visible blocks filtering to avoid recalculation on every render
+    const visibleBlocks = React.useMemo(() => blocks.filter((block) => block.type !== 'tool' || !HIDDEN_TOOLS.has(block.name)), [blocks]);
+    // Consolidate consecutive read/edit/agent blocks into compact display blocks.
+    // Only depends on visibleBlocks — removed isStreaming dependency to avoid
+    // re-running O(n) consolidation passes on every throttled render tick (~10fps).
+    const displayBlocks = React.useMemo(() => {
+        const readConsolidated = consolidateReadBlocks(visibleBlocks);
+        const editConsolidated = consolidateEditBlocks(readConsolidated);
+        return consolidateAgentBlocks(editConsolidated);
+    }, [visibleBlocks]);
+    // Truncate to last N blocks while streaming to keep the dynamic area small.
+    // When not streaming, render everything so the full history is visible.
+    const hiddenCount = (isStreaming && maxVisibleBlocks !== undefined && displayBlocks.length > maxVisibleBlocks)
+        ? displayBlocks.length - maxVisibleBlocks
+        : 0;
+    const renderedBlocks = hiddenCount > 0
+        ? displayBlocks.slice(-maxVisibleBlocks)
+        : displayBlocks;
+    // Thinking indicator when no blocks yet
+    if (displayBlocks.length === 0 && isStreaming && showThinkingIndicator) {
+        return (_jsxs(Box, { children: [_jsx(ActivityDot, { color: "cyan" }), _jsx(Text, { dimColor: true, children: " Thinking..." })] }));
+    }
+    // Nothing to render
+    if (displayBlocks.length === 0) {
+        return null;
+    }
+    // Detect task transitions: text blocks that follow tool blocks
+    // These are typically brief progress messages during plan execution
+    const getTextVariant = (index, block) => {
+        // Explicit variant takes precedence
+        if (block.variant)
+            return block.variant;
+        // Heuristic: if this text block follows a tool/consolidated block and is short,
+        // it's likely a task transition message
+        if (index > 0) {
+            // Map renderedBlocks index back to displayBlocks index for prev-block lookup
+            const displayIndex = index + hiddenCount;
+            const prevBlock = displayBlocks[displayIndex - 1];
+            const isShort = block.content.length < 200 && !block.content.includes('```');
+            const isPrevToolSuccess = (prevBlock.type === 'tool' && prevBlock.status === 'success') ||
+                (prevBlock.type === 'consolidated_read' && prevBlock.status === 'success') ||
+                (prevBlock.type === 'consolidated_edit' && prevBlock.status === 'success') ||
+                (prevBlock.type === 'consolidated_agent' && prevBlock.status === 'success');
+            if (isPrevToolSuccess && isShort) {
+                return 'task-progress';
+            }
+        }
+        return 'default';
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [hiddenCount > 0 && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: ["  \u2191 ", hiddenCount, " block", hiddenCount === 1 ? '' : 's', " above"] }) })), renderedBlocks.map((block, index) => {
+                const isLast = index === renderedBlocks.length - 1;
+                if (block.type === 'text') {
+                    return (_jsx(TextBlock, { content: block.content, isLast: isLast, isStreaming: isStreaming, variant: getTextVariant(index, block) }, `text-${index}`));
+                }
+                if (block.type === 'consolidated_read') {
+                    // Use first original block's ID for stable key to prevent flicker during consolidation
+                    const stableKey = block.originalBlocks[0]?.id || `consolidated-read-${index}`;
+                    return _jsx(ConsolidatedReadBlockComponent, { block: block }, stableKey);
+                }
+                if (block.type === 'consolidated_edit') {
+                    // Use first original block's ID for stable key to prevent flicker during consolidation
+                    const stableKey = block.originalBlocks[0]?.id || `consolidated-edit-${index}`;
+                    return _jsx(ConsolidatedEditBlockComponent, { block: block, expanded: expandMCPResults, isStatic: isStatic }, stableKey);
+                }
+                if (block.type === 'consolidated_agent') {
+                    const stableKey = block.originalBlocks[0]?.id || `consolidated-agent-${index}`;
+                    return _jsx(ConsolidatedAgentBlockComponent, { block: block, expanded: expandMCPResults, isStatic: isStatic }, stableKey);
+                }
+                return _jsx(ToolBlock, { tool: block, isStreaming: isStreaming, expandMCPResults: expandMCPResults, isStatic: isStatic }, block.id || `tool-${index}`);
+            })] }));
+};
+// Memoized to prevent unnecessary re-renders when props haven't changed.
+// Parent triggers re-renders via forceRender counter rather than array reference changes.
+export const InterleavedStream = React.memo(InterleavedStreamComponent);
+export default InterleavedStream;
+//# sourceMappingURL=InterleavedStream.js.map