erosolar-cli 1.7.155 → 1.7.156

package/dist/ui/persistentPrompt.js

@@ -215,8 +215,8 @@ const ANSI = {
 export class PinnedChatBox {
     writeStream;
     state;
+    reservedLines = 2; // Lines reserved at bottom for status bar (readline handles input)
     _lastRenderedHeight = 0;
-    maxInputLines = 5; // Max lines to show before truncating
     inputBuffer = '';
     cursorPosition = 0;
     commandIdCounter = 0;
@@ -234,8 +234,6 @@ export class PinnedChatBox {
     maxStatusMessageLength = 200;
     // Scroll region management for persistent bottom input
     scrollRegionActive = false;
-    // Track the row position we should return to after rendering status (bottom of scroll region)
-    scrollRegionBottomRow = 0;
     // Input history for up/down navigation
     inputHistory = [];
     historyIndex = -1;
@@ -246,13 +244,6 @@ export class PinnedChatBox {
     pastedFullContent = '';
     /** Cleanup function for output interceptor registration */
     outputInterceptorCleanup;
-    // Performance: Track if we're in the middle of a rapid input sequence
-    inputSequenceTimer = null;
-    // Visual state: Track if cursor should blink
-    showCursor = true;
-    cursorBlinkTimer = null;
-    // Session tracking for elapsed time display
-    sessionStartTime = Date.now();
     constructor(writeStream, _promptText = '> ', // Unused - readline handles input display
     options = {}) {
         this.writeStream = writeStream;
@@ -262,7 +253,6 @@ export class PinnedChatBox {
         this.maxQueueSize = options.maxQueueSize ?? 100;
         this.state = {
             isProcessing: false,
-            isReasoningModel: false,
             queuedCommands: [],
             currentInput: '',
             contextUsage: 0,
@@ -276,11 +266,6 @@ export class PinnedChatBox {
      * Register with the display's output interceptor system.
      * With scroll regions, output flows in the scrollable area while
      * the input stays pinned at the bottom.
-     *
-     * NOTE: We no longer re-render the persistent input on every afterWrite
-     * because this caused the input to appear multiple times in the scroll
-     * output (the chat box was being "logged" to the terminal history).
-     * Instead, we only render when state actually changes (via scheduleRender).
      */
     registerOutputInterceptor(display) {
         if (this.outputInterceptorCleanup) {
@@ -292,333 +277,106 @@ export class PinnedChatBox {
                 // No need to clear - terminal handles it
             },
             afterWrite: () => {
-                // NOTE: We intentionally do NOT re-render here anymore.
-                // The scroll region keeps the input pinned at the bottom, and
-                // re-rendering on every write was causing the chat box to appear
-                // multiple times in the terminal output history.
-                // The chat box is only re-rendered when input state changes
-                // (typing, cursor blink, etc.) via scheduleRender().
+                // Debounced re-render of persistent input after streaming output
+                if (this.scrollRegionActive && this.state.isProcessing) {
+                    if (this.pendingAfterWriteRender) {
+                        clearTimeout(this.pendingAfterWriteRender);
+                    }
+                    // Debounce to ~30fps to avoid excessive rendering during fast streaming
+                    this.pendingAfterWriteRender = setTimeout(() => {
+                        this.pendingAfterWriteRender = null;
+                        if (!this.isDisposed && this.scrollRegionActive) {
+                            this.renderPersistentInput();
+                        }
+                    }, 33);
+                }
             },
         });
     }
     /**
      * Enable scroll region to keep bottom lines reserved for input.
      * Content scrolls in the upper region, input stays pinned at bottom.
-     *
-     * Optimized for stability:
-     * - Validates terminal dimensions before setting region
-     * - Uses atomic cursor save/restore operations
-     * - Ensures clean state transition
      */
     enableScrollRegion() {
         if (!this.supportsRendering() || this.scrollRegionActive)
             return;
         const rows = this.writeStream.rows || 24;
-        // Dynamically size the reserved area based on current input height
-        const reservedHeight = this.getReservedLines();
-        // Sanity check: need at least 6 rows for scroll region to work properly
-        if (rows < reservedHeight + 4)
-            return;
-        // Track the bottom row of the scroll region for reference
-        this.scrollRegionBottomRow = rows - reservedHeight;
-        // Hide cursor during setup
-        this.safeWrite(ANSI.HIDE_CURSOR);
-        // First, scroll terminal content up to make room for the chat box
-        // This ensures prompt and content are visible above the reserved area
-        // Move cursor to where chat box will be, then scroll up
-        this.safeWrite(`\u001b[${rows};1H`); // Move to bottom
-        for (let i = 0; i < reservedHeight; i++) {
-            this.safeWrite('\n'); // Scroll content up
-        }
-        // Set scroll region to exclude bottom lines (1 to scrollRegionBottomRow)
-        this.safeWrite(ANSI.SET_SCROLL_REGION(1, this.scrollRegionBottomRow));
+        const reservedHeight = this.reservedLines;
+        // Set scroll region to exclude bottom lines
+        this.safeWrite(ANSI.SET_SCROLL_REGION(1, rows - reservedHeight));
+        // Move cursor to end of scroll region
+        this.safeWrite(`\u001b[${rows - reservedHeight};1H`);
         this.scrollRegionActive = true;
-        // Force immediate render to ensure persistent chat box is visible
-        this.forceRender();
-        // Render the persistent input area at the bottom (outside scroll region)
-        this.renderStatusBarOnly();
-        // Position cursor at the bottom of the scroll region
-        // New streaming content will appear here and scroll up naturally
-        this.safeWrite(`\u001b[${this.scrollRegionBottomRow};1H`);
-        // Keep terminal cursor hidden during streaming - we show a visual cursor in the chat box instead
-        // This prevents the cursor from appearing in the stream output area
-        // The visual cursor (inverted block) in renderPersistentInput() provides user feedback
-        // Start cursor blink for visual feedback that input is active
-        this.startCursorBlink();
-    }
-    /**
-     * Render only the status bar at bottom without affecting cursor position.
-     * Used during initial scroll region setup.
-     */
-    renderStatusBarOnly() {
-        if (!this.supportsRendering())
-            return;
-        const rows = this.writeStream.rows || 24;
-        const cols = Math.max(this.writeStream.columns || 80, 40);
-        const borderWidth = cols - 2;
-        // Calculate starting row (4 lines: top border + input + bottom border + status)
-        let currentRow = rows - 3;
-        // Build status line
-        const queueCount = this.state.queuedCommands.length;
-        let statusText = '';
-        if (this.state.isProcessing) {
-            const icon = this.state.isReasoningModel ? '🧠' : '⏳';
-            const queuePart = queueCount > 0 ? ` +${queueCount}` : '';
-            statusText = `${icon}${queuePart} [Enter: queue]`;
-        }
-        // Use absolute row positioning to prevent scroll history leakage
-        // Top border with status on right
-        const statusSuffix = statusText ? ` ${statusText}` : '';
-        const topBorderWidth = Math.max(10, borderWidth - statusSuffix.length);
-        this.safeWrite(`\u001b[${currentRow};1H${ANSI.CLEAR_LINE}`);
-        this.safeWrite(theme.ui.border('─'.repeat(topBorderWidth)) + theme.ui.muted(statusSuffix));
-        currentRow++;
-        // Input line with prompt
-        this.safeWrite(`\u001b[${currentRow};1H${ANSI.CLEAR_LINE}`);
-        this.safeWrite(theme.ui.muted('> '));
-        currentRow++;
-        // Bottom border
-        this.safeWrite(`\u001b[${currentRow};1H${ANSI.CLEAR_LINE}`);
-        this.safeWrite(theme.ui.border('─'.repeat(borderWidth)));
-        currentRow++;
-        // Status line (context + time)
-        const contextTimeLine = this.buildContextTimeStatus(cols);
-        if (contextTimeLine) {
-            this.safeWrite(`\u001b[${currentRow};1H${ANSI.CLEAR_LINE}`);
-            this.safeWrite(contextTimeLine);
-        }
+        // Render the persistent input area at the bottom
+        this.renderPersistentInput();
     }
     /**
      * Disable scroll region and restore normal terminal behavior.
-     * Ensures clean state restoration.
      */
     disableScrollRegion() {
         if (!this.supportsRendering() || !this.scrollRegionActive)
             return;
-        // Stop cursor blink
-        this.stopCursorBlink();
-        // Atomic operation: hide cursor, reset region, show cursor
-        this.safeWrite(ANSI.HIDE_CURSOR);
         // Reset scroll region to full terminal
         this.safeWrite(ANSI.RESET_SCROLL_REGION);
         this.scrollRegionActive = false;
-        this.safeWrite(ANSI.SHOW_CURSOR);
-    }
-    /**
-     * Start cursor blink animation for visual feedback during typing
-     */
-    startCursorBlink() {
-        if (this.cursorBlinkTimer)
-            return;
-        this.showCursor = true;
-        this.cursorBlinkTimer = setInterval(() => {
-            if (!this.scrollRegionActive || this.isDisposed) {
-                this.stopCursorBlink();
-                return;
-            }
-            this.showCursor = !this.showCursor;
-            // Only re-render if we're actually showing the input line
-            if (this.state.isProcessing && this.inputBuffer.length > 0) {
-                this.renderPersistentInput();
-            }
-        }, 530); // Standard cursor blink rate
-    }
-    /**
-     * Stop cursor blink animation
-     */
-    stopCursorBlink() {
-        if (this.cursorBlinkTimer) {
-            clearInterval(this.cursorBlinkTimer);
-            this.cursorBlinkTimer = null;
-        }
-        this.showCursor = true;
-    }
-    /**
-     * Calculate how many lines the current input needs for display
-     */
-    calculateInputLines(cols) {
-        if (!this.inputBuffer)
-            return 1;
-        const contentWidth = cols - 4; // Account for "> " prompt and padding
-        const lines = this.inputBuffer.split('\n');
-        let totalLines = 0;
-        for (const line of lines) {
-            // Each line wraps based on terminal width
-            totalLines += Math.max(1, Math.ceil(line.length / contentWidth));
-        }
-        return Math.min(totalLines, this.maxInputLines);
-    }
-    /**
-     * Get the current reserved line count based on input content
-     */
-    getReservedLines() {
-        const cols = this.writeStream.columns || 80;
-        const inputLines = this.calculateInputLines(cols);
-        return inputLines + 3; // top border + input lines + bottom border + status line
     }
     /**
      * Render the persistent input area at the bottom of the terminal.
      * Called when scroll region is active to keep input visible during streaming.
-     *
-     * Layout:
-     * ─────────────────────────────────────────────────── ⏳ +2 [Enter: queue]
-     * > input text here
-     *   continued on next line if needed
-     * ───────────────────────────────────────────────────────────────────────
+     * Shows actual input line so users can see what they're typing.
      */
     renderPersistentInput() {
         if (!this.supportsRendering())
             return;
-        // IMPORTANT: Only render when scroll region is active
-        // This prevents the chat box from leaking into the scroll history
-        if (!this.scrollRegionActive)
-            return;
         const rows = this.writeStream.rows || 24;
         const cols = Math.max(this.writeStream.columns || 80, 40);
-        const borderWidth = cols - 2;
-        // Calculate dynamic height based on input content
-        const inputLines = this.calculateInputLines(cols);
-        const totalHeight = inputLines + 3; // top border + input + bottom border + status line
-        // Calculate starting row for the chat box (reserved area at bottom)
-        const startRow = rows - totalHeight + 1;
-        let currentRow = startRow;
-        // Build the entire output as a single string for atomic write
-        const output = [];
-        // CRITICAL FIX FOR UI LEAK:
-        // 1. Save cursor position (so streaming can continue from where it was)
-        // 2. Use absolute row positioning (no newlines that add to scroll buffer)
-        // 3. Restore cursor position (streaming continues seamlessly)
-        output.push('\u001b7'); // DECSC - save cursor position
-        // Build status indicators for top border
+        // Save cursor position
+        this.safeWrite(ANSI.SAVE_CURSOR);
+        // Move to the reserved bottom area (outside scroll region)
+        this.safeWrite(ANSI.CURSOR_TO_BOTTOM(rows - 1));
+        // Build status line
         const queueCount = this.state.queuedCommands.length;
         let statusText = '';
         if (this.state.isProcessing) {
-            const icon = this.state.isReasoningModel ? '🧠' : '⏳';
-            const queuePart = queueCount > 0 ? ` +${queueCount}` : '';
-            statusText = `${icon}${queuePart} [Enter: queue]`;
+            const queuePart = queueCount > 0 ? ` (${queueCount} queued)` : '';
+            statusText = `⏳ Processing...${queuePart} [Esc: cancel · Enter: queue]`;
         }
-        else if (queueCount > 0) {
-            statusText = `📋 ${queueCount} queued`;
+        else if (this.state.statusMessage) {
+            statusText = this.state.statusMessage;
         }
-        // Top border with status on right
-        const statusSuffix = statusText ? ` ${statusText}` : '';
-        const topBorderWidth = Math.max(10, borderWidth - statusSuffix.length);
-        const topBorder = theme.ui.border('─'.repeat(topBorderWidth)) + theme.ui.muted(statusSuffix);
-        output.push(`\u001b[${currentRow};1H${ANSI.CLEAR_LINE}${topBorder}`);
-        currentRow++;
-        // Input lines
+        else if (queueCount > 0) {
+            statusText = `${queueCount} follow-up${queueCount === 1 ? '' : 's'} queued`;
+        }
+        // Render separator and status on bottom lines
+        const separatorWidth = Math.min(cols - 2, 72);
+        const separator = theme.ui.border('─'.repeat(separatorWidth));
+        // Line rows-1: separator
+        this.safeWrite(ANSI.CLEAR_LINE);
+        this.safeWrite(separator);
+        // Line rows: input line with prompt or status
+        this.safeWrite(`\n${ANSI.CLEAR_LINE}`);
+        // Show actual input line during processing so user can see what they're typing
+        const promptPrefix = theme.ui.muted('> ');
         const currentInput = this.inputBuffer;
-        const contentWidth = cols - 4;
-        if (!currentInput) {
-            // Empty input - show just the prompt
-            output.push(`\u001b[${currentRow};1H${ANSI.CLEAR_LINE}${theme.ui.muted('> ')}`);
-            // Visual cursor at prompt position
-            if (this.showCursor) {
-                output.push('\u001b[7m \u001b[27m'); // Inverted space for cursor
-            }
-            currentRow++;
-        }
-        else {
-            // Wrap input text into display lines
-            const displayLines = this.wrapInputForDisplay(currentInput, contentWidth, inputLines);
-            for (let i = 0; i < displayLines.length; i++) {
-                output.push(`\u001b[${currentRow};1H${ANSI.CLEAR_LINE}`);
-                const lineContent = displayLines[i] ?? '';
-                const isFirstLine = i === 0;
-                const prompt = isFirstLine ? theme.ui.muted('> ') : '  ';
-                output.push(prompt);
-                // Check if cursor is on this line
-                const cursorOnThisLine = this.isCursorOnDisplayLine(i, displayLines, contentWidth);
-                if (cursorOnThisLine !== false && this.showCursor) {
-                    // Render with cursor
-                    const cursorCol = cursorOnThisLine;
-                    const before = lineContent.slice(0, cursorCol);
-                    const at = lineContent[cursorCol] || ' ';
-                    const after = lineContent.slice(cursorCol + 1);
-                    output.push(before);
-                    output.push(`\u001b[7m${at}\u001b[27m`); // Inverted for cursor
-                    output.push(after);
-                }
-                else {
-                    output.push(lineContent);
-                }
-                currentRow++;
-            }
-            // Show truncation indicator if content exceeds max lines
-            if (this.inputBuffer.split('\n').length > this.maxInputLines ||
-                this.inputBuffer.length > contentWidth * this.maxInputLines) {
-                const truncatedLines = this.inputBuffer.split('\n').length - this.maxInputLines;
-                if (truncatedLines > 0) {
-                    output.push(theme.ui.muted(` (+${truncatedLines} more lines)`));
-                }
-            }
-        }
-        // Bottom border (full width)
-        output.push(`\u001b[${currentRow};1H${ANSI.CLEAR_LINE}${theme.ui.border('─'.repeat(borderWidth))}`);
-        currentRow++;
-        // Status line below: Context usage and session elapsed time
-        const statusLine = this.buildContextTimeStatus(cols);
-        if (statusLine) {
-            output.push(`\u001b[${currentRow};1H${ANSI.CLEAR_LINE}${statusLine}`);
-        }
-        // Restore cursor position so streaming continues from where it left off
-        // This is critical - without it, streaming would jump to a fixed position
-        output.push('\u001b8'); // DECRC - restore cursor position
-        // Ensure terminal cursor stays hidden in the stream area
-        // We show a visual cursor (inverted block) in the chat box instead
-        output.push(ANSI.HIDE_CURSOR);
-        // Single atomic write for smoothness
-        this.safeWrite(output.join(''));
-        this._lastRenderedHeight = totalHeight;
-    }
-    /**
-     * Wrap input text into display lines for rendering
-     */
-    wrapInputForDisplay(input, maxWidth, maxLines) {
-        const lines = [];
-        const inputLines = input.split('\n');
-        for (const line of inputLines) {
-            if (lines.length >= maxLines)
-                break;
-            if (line.length <= maxWidth) {
-                lines.push(line);
-            }
-            else {
-                // Wrap long lines
-                for (let i = 0; i < line.length && lines.length < maxLines; i += maxWidth) {
-                    lines.push(line.slice(i, i + maxWidth));
-                }
+        const maxInputDisplay = cols - 4; // Reserve space for prompt and cursor
+        // Truncate input if too long, showing end of input
+        let displayInput = currentInput;
+        if (displayInput.length > maxInputDisplay) {
+            displayInput = '…' + displayInput.slice(-(maxInputDisplay - 1));
+        }
+        // Render prompt + input
+        this.safeWrite(promptPrefix);
+        this.safeWrite(displayInput);
+        // Show status hint on the right if there's room
+        if (statusText && currentInput.length < maxInputDisplay - statusText.length - 5) {
+            const padding = cols - 3 - currentInput.length - statusText.length - 3;
+            if (padding > 3) {
+                this.safeWrite(' '.repeat(padding));
+                this.safeWrite(theme.ui.muted(statusText.slice(0, cols - currentInput.length - 6)));
             }
         }
-        return lines;
-    }
-    /**
-     * Determine if cursor should appear on a given display line
-     * Returns the column position if yes, false if no
-     */
-    isCursorOnDisplayLine(lineIndex, displayLines, _maxWidth) {
-        // Calculate which display line the cursor is on
-        let charCount = 0;
-        for (let i = 0; i < displayLines.length; i++) {
-            const line = displayLines[i] ?? '';
-            const lineLength = line.length;
-            const lineEnd = charCount + lineLength;
-            // Account for newlines in original input
-            if (i > 0)
-                charCount++; // +1 for the newline character
-            if (this.cursorPosition >= charCount && this.cursorPosition <= lineEnd) {
-                if (i === lineIndex) {
-                    return this.cursorPosition - charCount;
-                }
-            }
-            charCount = lineEnd;
-        }
-        // Cursor at end of last line
-        if (lineIndex === displayLines.length - 1 && this.cursorPosition >= charCount) {
-            const lastLine = displayLines[lineIndex] ?? '';
-            return lastLine.length;
-        }
-        return false;
+        // Restore cursor to scroll region
+        this.safeWrite(ANSI.RESTORE_CURSOR);
     }
     /**
      * Update the persistent input during streaming.
@@ -639,53 +397,6 @@ export class PinnedChatBox {
             typeof this.writeStream.write === 'function' &&
             this.writeStream.writable !== false);
     }
-    /**
-     * Build status line showing context usage and session elapsed time
-     */
-    buildContextTimeStatus(cols) {
-        const parts = [];
-        // Context usage with visual bar
-        const contextPct = this.state.contextUsage;
-        if (contextPct > 0) {
-            const barWidth = 10;
-            const filled = Math.round((contextPct / 100) * barWidth);
-            const empty = barWidth - filled;
-            const bar = `${'█'.repeat(filled)}${'░'.repeat(empty)}`;
-            // Color based on usage level
-            let contextColor = theme.success;
-            if (contextPct >= 80)
-                contextColor = theme.error;
-            else if (contextPct >= 60)
-                contextColor = theme.warning;
-            parts.push(`${theme.ui.muted('Context')} ${contextColor(bar)} ${contextColor(`${contextPct}%`)}`);
-        }
-        // Session elapsed time
-        const elapsedMs = Date.now() - this.sessionStartTime;
-        const elapsedSecs = Math.floor(elapsedMs / 1000);
-        const elapsedStr = this.formatElapsedTime(elapsedSecs);
-        parts.push(`${theme.ui.muted('Session')} ${theme.info(elapsedStr)}`);
-        if (parts.length === 0)
-            return '';
-        // Center the status line
-        const statusText = parts.join(theme.ui.muted(' │ '));
-        const visibleLen = this.stripAnsi(statusText).length;
-        const padding = Math.max(0, Math.floor((cols - visibleLen) / 2));
-        return ' '.repeat(padding) + statusText;
-    }
-    /**
-     * Format elapsed seconds as human-readable time
-     */
-    formatElapsedTime(seconds) {
-        if (seconds < 60)
-            return `${seconds}s`;
-        const mins = Math.floor(seconds / 60);
-        const secs = seconds % 60;
-        if (mins < 60)
-            return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
-        const hours = Math.floor(mins / 60);
-        const remainMins = mins % 60;
-        return `${hours}h ${remainMins}m`;
-    }
     /**
      * Strip ANSI escape codes
      */
@@ -751,15 +462,6 @@ export class PinnedChatBox {
             this.scheduleRender();
         }
     }
-    /**
-     * Set whether current model is a reasoning model (o1, deepseek-reasoner).
-     * Reasoning models don't stream text - they think internally then respond.
-     */
-    setReasoningModel(isReasoning) {
-        if (this.isDisposed)
-            return;
-        this.state.isReasoningModel = isReasoning;
-    }
     /**
      * Set processing state
      * Enables scroll region during processing to keep input visible while streaming
@@ -881,19 +583,14 @@ export class PinnedChatBox {
     /**
      * Handle character input with validation
      * Detects multiline paste and stores full content while showing summary
-     *
-     * Optimized for fast typing:
-     * - Batches rapid keystrokes
-     * - Immediate visual feedback
-     * - Efficient state updates
      */
     handleInput(char) {
         if (!this.isEnabled || this.isDisposed)
             return;
         if (typeof char !== 'string')
             return;
-        // Detect multiline paste (content with newlines or very long single paste)
-        if (char.includes('\n') || char.length > 100) {
+        // Detect multiline paste (content with newlines)
+        if (char.includes('\n')) {
             this.handleMultilinePaste(char);
             return;
         }
@@ -914,122 +611,63 @@ export class PinnedChatBox {
                 this.inputBuffer.slice(this.cursorPosition);
         this.cursorPosition = Math.min(this.cursorPosition + chunk.length, this.inputBuffer.length);
         this.state.currentInput = this.inputBuffer;
-        // Reset cursor blink on input for immediate visual feedback
-        this.showCursor = true;
-        // Fast render for single keystrokes during streaming
-        if (this.scrollRegionActive && this.state.isProcessing) {
-            // During streaming: immediate render for responsiveness
-            this.renderPersistentInput();
-        }
-        else {
-            // Normal mode: use standard scheduling
-            this.scheduleRender();
-        }
+        this.scheduleRender();
     }
     /**
-     * Handle multiline paste - show full content for small/medium pastes, summarized block for large ones
-     * Claude Code style: show all lines unless very long, then show first/last lines with ellipsis
-     * CRITICAL: Must work correctly in all circumstances:
-     * - During streaming (scroll region active)
-     * - During idle (normal readline mode)
-     * - Small/medium pastes (≤15 lines) - show full content
-     * - Large pastes (>15 lines) - show block with first/last lines
+     * Handle multiline paste - store full content but display summary
      */
     handleMultilinePaste(content) {
         const lines = content.split('\n');
         const lineCount = lines.length;
-        // Show full content for small/medium pastes (up to 15 lines)
-        // For larger pastes, show a summarized block with first/last lines
-        const isSmallPaste = lineCount <= 15;
-        if (isSmallPaste) {
-            // Show full content for small/medium pastes
-            this.pastedFullContent = '';
-            this.isPastedBlock = false;
-            this.inputBuffer = content;
-            this.cursorPosition = content.length;
-            this.state.currentInput = content;
-        }
-        else {
-            // Show summarized block for large pastes
-            this.pastedFullContent = content;
-            this.isPastedBlock = true;
-            const summary = this.generatePasteSummary(content, lineCount);
-            this.inputBuffer = summary;
-            this.cursorPosition = summary.length;
-            this.state.currentInput = summary;
-        }
-        // Use consistent rendering approach as handleInput:
-        // During streaming with scroll region active, render immediately
-        // Otherwise use scheduled render
-        if (this.scrollRegionActive && this.state.isProcessing) {
-            this.renderPersistentInput();
-        }
-        else {
-            this.scheduleRender();
-        }
+        this.pastedFullContent = content;
+        this.isPastedBlock = true;
+        // Generate a summary for display
+        const summary = this.generatePasteSummary(content, lineCount);
+        this.inputBuffer = summary;
+        this.cursorPosition = summary.length;
+        this.state.currentInput = summary;
+        this.scheduleRender();
     }
     /**
-     * Generate a block summary of pasted content for display (Claude Code style)
-     * Shows first few lines, ellipsis with count, and last line
+     * Generate a short summary of pasted content for display
      */
     generatePasteSummary(content, lineCount) {
         const lines = content.split('\n');
+        const firstLine = lines[0]?.trim() || '';
         const charCount = content.length;
-        // Detect content type for header
-        const firstNonEmpty = lines.find(l => l.trim()) || '';
-        let typeLabel = 'text';
-        const codePatterns = [
-            [/^(import|export|from\s+['"]|require\s*\()/, 'code'],
-            [/^(function|const|let|var|class|interface|type|enum)\s+\w/, 'code'],
-            [/^(def |class |import |from |async def |@\w+)/, 'python'],
-            [/^(package |func |type |import |var |const )\w/, 'go'],
-            [/^(fn |use |mod |struct |impl |pub )/, 'rust'],
-            [/^\s*[{[]/, 'json'],
-            [/^<[!?]?[a-zA-Z]/, 'markup'],
-            [/^(SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)\s/i, 'sql'],
-            [/^#!\//, 'script'],
-        ];
-        for (const [pattern, label] of codePatterns) {
-            if (pattern.test(firstNonEmpty)) {
-                typeLabel = label;
-                break;
-            }
-        }
-        // Format size info
-        const sizeStr = charCount >= 1000
-            ? `${(charCount / 1000).toFixed(1)}k chars`
-            : `${charCount} chars`;
-        // Build block display: show first 4 lines, ellipsis, last 2 lines
-        const showFirstLines = 4;
-        const showLastLines = 2;
-        const hiddenLines = lineCount - showFirstLines - showLastLines;
-        const displayLines = [];
-        // Header line
-        displayLines.push(`📋 Pasted ${lineCount} lines (${typeLabel}, ${sizeStr}):`);
-        // First N lines (truncate long lines)
-        const maxLineWidth = 60;
-        for (let i = 0; i < Math.min(showFirstLines, lines.length); i++) {
-            let line = lines[i] || '';
-            if (line.length > maxLineWidth) {
-                line = line.slice(0, maxLineWidth - 1) + '…';
-            }
-            displayLines.push(`  ${line}`);
-        }
-        // Ellipsis with hidden count (if there are hidden lines)
-        if (hiddenLines > 0) {
-            displayLines.push(`  ... (${hiddenLines} more lines)`);
-            // Last N lines
-            for (let i = lineCount - showLastLines; i < lineCount; i++) {
-                if (i >= showFirstLines) { // Avoid duplicates
-                    let line = lines[i] || '';
-                    if (line.length > maxLineWidth) {
-                        line = line.slice(0, maxLineWidth - 1) + '…';
-                    }
-                    displayLines.push(`  ${line}`);
-                }
-            }
-        }
-        return displayLines.join('\n');
+        // Detect content type and get appropriate icon/label
+        let typeLabel = 'Pasted';
+        let typeIcon = '📋';
+        if (firstLine.match(/^(import|export|const|let|var|function|class|def |async |from |interface |type )/)) {
+            typeIcon = '📝';
+            typeLabel = 'Code';
+        }
+        else if (firstLine.match(/^[{[\]]/)) {
+            typeIcon = '📊';
+            typeLabel = 'JSON';
+        }
+        else if (firstLine.match(/^<[!?]?[a-zA-Z]/)) {
+            typeIcon = '📄';
+            typeLabel = 'XML/HTML';
+        }
+        else if (firstLine.match(/^#|^\/\/|^\/\*|^\*|^--/)) {
+            typeIcon = '💬';
+            typeLabel = 'Text';
+        }
+        else if (firstLine.match(/^```|^~~~|^\s{4}/)) {
+            typeIcon = '📖';
+            typeLabel = 'Markdown';
+        }
+        // Create a compact preview
+        const maxPreviewLen = 25;
+        const preview = firstLine.length > maxPreviewLen
+            ? firstLine.slice(0, maxPreviewLen - 1) + '…'
+            : firstLine || '(empty)';
+        // Format size info compactly
+        const sizeInfo = charCount > 1000
+            ? `${(charCount / 1000).toFixed(1)}k`
+            : `${charCount}`;
+        return `${typeIcon} [${typeLabel}: ${lineCount}L/${sizeInfo}c] ${preview}`;
     }
     /**
      * Check if current input is a pasted block
@@ -1060,7 +698,7 @@ export class PinnedChatBox {
         this.state.currentInput = '';
     }
     /**
-     * Handle backspace - deletes paste chips as a single unit
+     * Handle backspace
      */
     handleBackspace() {
         if (!this.isEnabled || this.isDisposed)
@@ -1068,28 +706,6 @@ export class PinnedChatBox {
         this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
         if (this.cursorPosition === 0)
             return;
-        // Check if we're at the end of a paste chip (character before cursor is ']')
-        const charBefore = this.inputBuffer[this.cursorPosition - 1];
-        if (charBefore === ']') {
-            // Find the matching '[' to get the full chip
-            const beforeCursor = this.inputBuffer.slice(0, this.cursorPosition);
-            const chipStart = beforeCursor.lastIndexOf('[');
-            if (chipStart !== -1) {
-                // Verify this looks like a paste chip (contains emoji)
-                const potentialChip = beforeCursor.slice(chipStart);
-                if (potentialChip.match(/^\[📋|^\[📝|^\[📊|^\[📄/)) {
-                    // Delete the entire chip
-                    this.inputBuffer =
-                        this.inputBuffer.slice(0, chipStart) +
-                            this.inputBuffer.slice(this.cursorPosition);
-                    this.cursorPosition = chipStart;
-                    this.state.currentInput = this.inputBuffer;
-                    this.scheduleRender();
-                    return;
-                }
-            }
-        }
-        // Normal single character delete
         this.inputBuffer =
             this.inputBuffer.slice(0, this.cursorPosition - 1) +
                 this.inputBuffer.slice(this.cursorPosition);
@@ -1098,7 +714,7 @@ export class PinnedChatBox {
         this.scheduleRender();
     }
     /**
-     * Handle delete key - deletes paste chips as a single unit
+     * Handle delete key
      */
     handleDelete() {
         if (!this.isEnabled || this.isDisposed)
@@ -1106,23 +722,6 @@ export class PinnedChatBox {
         this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
         if (this.cursorPosition >= this.inputBuffer.length)
             return;
-        // Check if we're at the start of a paste chip (character at cursor is '[')
-        const charAtCursor = this.inputBuffer[this.cursorPosition];
-        if (charAtCursor === '[') {
-            // Check if this looks like a paste chip
-            const afterCursor = this.inputBuffer.slice(this.cursorPosition);
-            const chipMatch = afterCursor.match(/^\[(?:📋|📝|📊|📄)[^\]]*\]/);
-            if (chipMatch) {
-                // Delete the entire chip
-                this.inputBuffer =
-                    this.inputBuffer.slice(0, this.cursorPosition) +
-                        this.inputBuffer.slice(this.cursorPosition + chipMatch[0].length);
-                this.state.currentInput = this.inputBuffer;
-                this.scheduleRender();
-                return;
-            }
-        }
-        // Normal single character delete
         this.inputBuffer =
             this.inputBuffer.slice(0, this.cursorPosition) +
                 this.inputBuffer.slice(this.cursorPosition + 1);
@@ -1524,6 +1123,12 @@ export class PinnedChatBox {
     handleResize() {
         this.scheduleRender();
     }
+    /**
+     * Get number of reserved lines at bottom
+     */
+    getReservedLines() {
+        return this.reservedLines;
+    }
     /**
      * Get last rendered height (for layout calculations)
      */
@@ -1536,25 +1141,16 @@ export class PinnedChatBox {
     dispose() {
         if (this.isDisposed)
             return;
-        // Clean up all timers
-        this.stopCursorBlink();
+        // Clean up pending render timeout
         if (this.pendingAfterWriteRender) {
             clearTimeout(this.pendingAfterWriteRender);
             this.pendingAfterWriteRender = null;
         }
-        if (this.inputSequenceTimer) {
-            clearTimeout(this.inputSequenceTimer);
-            this.inputSequenceTimer = null;
-        }
         // Clean up output interceptor registration
         if (this.outputInterceptorCleanup) {
             this.outputInterceptorCleanup();
             this.outputInterceptorCleanup = undefined;
         }
-        // Disable scroll region before clearing
-        if (this.scrollRegionActive) {
-            this.disableScrollRegion();
-        }
         try {
             this.clear();
         }
@@ -1594,7 +1190,6 @@ export class PinnedChatBox {
         this.cursorPosition = 0;
         this.state = {
             isProcessing: false,
-            isReasoningModel: false,
             queuedCommands: [],
             currentInput: '',
             contextUsage: 0,