erosolar-cli 1.7.285 → 1.7.289

package/dist/shell/terminalInput.js

@@ -11,7 +11,6 @@
 import { EventEmitter } from 'node:events';
 import { isMultilinePaste, generatePasteSummary } from '../core/multilinePasteHandler.js';
 import { writeLock } from '../ui/writeLock.js';
-import { renderDivider } from '../ui/unified/layout.js';
 import { UI_COLORS, DEFAULT_UI_CONFIG, } from '../ui/terminalUISchema.js';
 // ANSI escape codes
 const ESC = {
@@ -71,7 +70,6 @@ export class TerminalInput extends EventEmitter {
     overrideStatusMessage = null; // Secondary status (warnings, etc.)
     streamingLabel = null; // Streaming progress indicator
     reservedLines = 2;
-    scrollRegionActive = false;
     lastRenderContent = '';
     lastRenderCursor = -1;
     renderDirty = false;
@@ -288,12 +286,57 @@ export class TerminalInput extends EventEmitter {
         // Position cursor in input area
         this.write(ESC.TO(startRow + (this.modelInfo ? 3 : 2), this.config.promptChar.length + 1));
     }
+    /**
+     * Render input area at current cursor position (inline, not pinned).
+     * Used after streaming ends - renders input below the streamed content.
+     */
+    renderInlineInputAreaAtCursor() {
+        const { cols } = this.getSize();
+        const divider = '─'.repeat(cols - 1);
+        const { dim: DIM, reset: R } = UI_COLORS;
+        // Status bar - shows "Type a message" hint
+        process.stdout.write(this.buildStatusBar(cols) + '\n');
+        // Model info line (if set)
+        if (this.modelInfo) {
+            let modelLine = `${DIM}${this.modelInfo}${R}`;
+            if (this.contextUsage !== null) {
+                const rem = Math.max(0, 100 - this.contextUsage);
+                if (rem < 10)
+                    modelLine += ` ${UI_COLORS.red}⚠ ctx: ${rem}%${R}`;
+                else if (rem < 25)
+                    modelLine += ` ${UI_COLORS.yellow}! ctx: ${rem}%${R}`;
+                else
+                    modelLine += ` ${DIM}· ctx: ${rem}%${R}`;
+            }
+            process.stdout.write(modelLine + '\n');
+        }
+        // Top divider
+        process.stdout.write(divider + '\n');
+        // Input line with prompt and any buffer content
+        const { lines, cursorCol } = this.wrapBuffer(cols - 4);
+        const displayLine = lines[0] ?? '';
+        process.stdout.write(ESC.BG_DARK + ESC.DIM + this.config.promptChar + ESC.RESET);
+        process.stdout.write(ESC.BG_DARK + displayLine);
+        const padding = Math.max(0, cols - this.config.promptChar.length - displayLine.length - 1);
+        if (padding > 0)
+            process.stdout.write(' '.repeat(padding));
+        process.stdout.write(ESC.RESET + '\n');
+        // Bottom divider
+        process.stdout.write(divider + '\n');
+        // Mode controls
+        process.stdout.write(this.buildModeControls(cols) + '\n');
+        // Show cursor
+        this.write(ESC.SHOW);
+        // Update tracking
+        this.lastRenderContent = this.buffer;
+        this.lastRenderCursor = this.cursor;
+    }
     /**
      * Set the input mode
      *
-     * Streaming mode disables scroll region and lets content flow naturally.
-     * The input area will be re-rendered after streaming ends at wherever
-     * the cursor is (below the streamed content).
+     * Streaming mode: NO scroll region, NO bottom-pinned input.
+     * Content flows naturally after the initial launch layout.
+     * After streaming ends, input area renders inline at current position.
      */
     setMode(mode) {
         const prevMode = this.mode;
@@ -301,322 +344,34 @@ export class TerminalInput extends EventEmitter {
         if (mode === 'streaming' && prevMode !== 'streaming') {
             // Track streaming start time for elapsed display
             this.streamingStartTime = Date.now();
-            const { rows } = this.getSize();
             // Ensure unified UI is initialized (if not already done on launch)
             if (!this.unifiedUIInitialized) {
                 this.initializeUnifiedUI();
             }
-            // Set up scroll region to reserve bottom for persistent input area
-            this.pinnedTopRows = 0;
-            this.reservedLines = 6; // status + model + divider + input + divider + controls
-            // Ensure scroll region is enabled (may have been initialized already)
-            if (!this.scrollRegionActive) {
-                const contentBottomRow = Math.max(1, rows - this.reservedLines);
-                this.write(ESC.TO(contentBottomRow, 1));
-                this.enableScrollRegion();
-            }
-            // Render bottom input area
-            this.renderBottomInputArea();
-            // Start timer to update bottom input area (updates elapsed time)
-            this.streamingRenderTimer = setInterval(() => {
-                if (this.mode === 'streaming') {
-                    this.updateStreamingStatus();
-                    this.renderBottomInputArea();
-                }
-            }, 1000);
+            // NO scroll region - let content flow naturally
+            // NO bottom-pinned input area
+            // Don't clear anything - content flows from current cursor position
+            // The cursor should already be positioned after the user's prompt
             this.renderDirty = true;
         }
         else if (mode !== 'streaming' && prevMode === 'streaming') {
-            // Stop streaming render timer
+            // Stop streaming render timer (if any)
             if (this.streamingRenderTimer) {
                 clearInterval(this.streamingRenderTimer);
                 this.streamingRenderTimer = null;
             }
             // Reset streaming time
             this.streamingStartTime = null;
-            // Keep scroll region active for consistent bottom-pinned UI
-            // (scroll region reserves bottom for input area in all modes)
             // Reset flow mode tracking
             this.flowModeRenderedLines = 0;
-            // Render using unified bottom input area (same layout as streaming)
+            // Add spacing after streamed content
+            this.write('\n\n');
+            // Render input area inline at current position (below streamed content)
             writeLock.withLock(() => {
-                this.renderBottomInputArea();
+                this.renderInlineInputAreaAtCursor();
             }, 'terminalInput.streamingEnd');
         }
     }
-    /**
-     * Update streaming status label (called by timer)
-     */
-    updateStreamingStatus() {
-        if (this.mode !== 'streaming' || !this.streamingStartTime)
-            return;
-        // Calculate elapsed time
-        const elapsed = Date.now() - this.streamingStartTime;
-        const seconds = Math.floor(elapsed / 1000);
-        const minutes = Math.floor(seconds / 60);
-        const secs = seconds % 60;
-        // Format elapsed time
-        let elapsedStr;
-        if (minutes > 0) {
-            elapsedStr = `${minutes}m ${secs}s`;
-        }
-        else {
-            elapsedStr = `${secs}s`;
-        }
-        // Update streaming label
-        this.streamingLabel = `Streaming ${elapsedStr}`;
-    }
-    /**
-     * Render input area - unified for streaming and normal modes.
-     *
-     * In streaming mode: renders at absolute bottom, uses cursor save/restore
-     * In normal mode: renders right after the banner (pinnedTopRows + 1)
-     */
-    renderPinnedInputArea() {
-        const { rows, cols } = this.getSize();
-        const maxWidth = Math.max(8, cols - 4);
-        const divider = renderDivider(cols - 2);
-        const isStreaming = this.mode === 'streaming';
-        // Wrap buffer into display lines (multi-line support)
-        const { lines, cursorLine, cursorCol } = this.wrapBuffer(maxWidth);
-        const availableForContent = Math.max(1, rows - 5); // Reserve 5 lines for UI
-        const maxVisible = Math.max(1, Math.min(this.config.maxLines, availableForContent));
-        const displayLines = Math.min(lines.length, maxVisible);
-        // Calculate display window (keep cursor visible)
-        let startLine = 0;
-        if (lines.length > displayLines) {
-            startLine = Math.max(0, cursorLine - displayLines + 1);
-            startLine = Math.min(startLine, lines.length - displayLines);
-        }
-        const visibleLines = lines.slice(startLine, startLine + displayLines);
-        const adjustedCursorLine = cursorLine - startLine;
-        // Calculate total height: status + (model info if set) + topDiv + input lines + bottomDiv + controls
-        const hasModelInfo = !!this.modelInfo;
-        const totalHeight = 4 + visibleLines.length + (hasModelInfo ? 1 : 0);
-        // Save cursor position during streaming (so content flow resumes correctly)
-        if (isStreaming) {
-            this.write(ESC.SAVE);
-        }
-        this.write(ESC.HIDE);
-        this.write(ESC.RESET);
-        // Calculate start row based on mode:
-        // - Streaming: absolute bottom (rows - totalHeight + 1)
-        // - Normal: right after content (contentEndRow + 1)
-        let currentRow;
-        if (isStreaming) {
-            currentRow = Math.max(1, rows - totalHeight + 1);
-        }
-        else {
-            // In normal mode, render right after content
-            // Use contentEndRow if set, otherwise use pinnedTopRows
-            const contentRow = this.contentEndRow > 0 ? this.contentEndRow : this.pinnedTopRows;
-            currentRow = Math.max(1, contentRow + 1);
-        }
-        let finalRow = currentRow;
-        let finalCol = 3;
-        // Clear from current position to end of screen to remove any "ghost" content
-        this.write(ESC.TO(currentRow, 1));
-        this.write(ESC.CLEAR_TO_END);
-        // Status bar
-        this.write(ESC.TO(currentRow, 1));
-        this.write(isStreaming ? this.buildStreamingStatusBar(cols) : this.buildStatusBar(cols));
-        currentRow++;
-        // Model info line (if set) - displayed below status, above input
-        if (hasModelInfo) {
-            const { dim: DIM, reset: R } = UI_COLORS;
-            this.write(ESC.TO(currentRow, 1));
-            // Build model info with context usage
-            let modelLine = `${DIM}${this.modelInfo}${R}`;
-            if (this.contextUsage !== null) {
-                const rem = Math.max(0, 100 - this.contextUsage);
-                if (rem < 10)
-                    modelLine += ` ${UI_COLORS.red}⚠ ctx: ${rem}%${R}`;
-                else if (rem < 25)
-                    modelLine += ` ${UI_COLORS.yellow}! ctx: ${rem}%${R}`;
-                else
-                    modelLine += ` ${DIM}· ctx: ${rem}%${R}`;
-            }
-            this.write(modelLine);
-            currentRow++;
-        }
-        // Top divider
-        this.write(ESC.TO(currentRow, 1));
-        this.write(divider);
-        currentRow++;
-        // Input lines with background styling
-        for (let i = 0; i < visibleLines.length; i++) {
-            this.write(ESC.TO(currentRow, 1));
-            const line = visibleLines[i] ?? '';
-            const absoluteLineIdx = startLine + i;
-            const isFirstLine = absoluteLineIdx === 0;
-            const isCursorLine = i === adjustedCursorLine;
-            // Background
-            this.write(ESC.BG_DARK);
-            // Prompt prefix
-            this.write(ESC.DIM);
-            this.write(isFirstLine ? this.config.promptChar : this.config.continuationChar);
-            this.write(ESC.RESET);
-            this.write(ESC.BG_DARK);
-            if (isCursorLine) {
-                const col = Math.min(cursorCol, line.length);
-                const before = line.slice(0, col);
-                const at = col < line.length ? line[col] : ' ';
-                const after = col < line.length ? line.slice(col + 1) : '';
-                this.write(before);
-                this.write(ESC.REVERSE + ESC.BOLD);
-                this.write(at);
-                this.write(ESC.RESET + ESC.BG_DARK);
-                this.write(after);
-                finalRow = currentRow;
-                finalCol = this.config.promptChar.length + col + 1;
-            }
-            else {
-                this.write(line);
-            }
-            // Pad to edge
-            const lineLen = this.config.promptChar.length + line.length + (isCursorLine && cursorCol >= line.length ? 1 : 0);
-            const padding = Math.max(0, cols - lineLen - 1);
-            if (padding > 0)
-                this.write(' '.repeat(padding));
-            this.write(ESC.RESET);
-            currentRow++;
-        }
-        // Bottom divider
-        this.write(ESC.TO(currentRow, 1));
-        this.write(divider);
-        currentRow++;
-        // Mode controls line
-        this.write(ESC.TO(currentRow, 1));
-        this.write(this.buildModeControls(cols));
-        // Restore cursor position during streaming, or show cursor in normal mode
-        if (isStreaming) {
-            this.write(ESC.RESTORE);
-        }
-        else {
-            // Position cursor in input area
-            this.write(ESC.TO(finalRow, Math.min(finalCol, cols)));
-            this.write(ESC.SHOW);
-        }
-        // Update reserved lines for scroll region calculations
-        this.updateReservedLines(totalHeight);
-    }
-    /**
-     * Render input area during streaming (alias for unified method)
-     */
-    renderStreamingInputArea() {
-        this.renderPinnedInputArea();
-    }
-    /**
-     * Render bottom input area - UNIFIED for all modes.
-     * Uses cursor save/restore to update bottom without affecting content flow.
-     *
-     * Layout (same for idle/streaming/ready):
-     * - Status bar (streaming timer or "Type a message")
-     * - Model info line (provider · model · ctx)
-     * - Divider
-     * - Input area
-     * - Divider
-     * - Mode controls
-     */
-    renderBottomInputArea() {
-        const { rows, cols } = this.getSize();
-        const maxWidth = Math.max(8, cols - 4);
-        const divider = renderDivider(cols - 2);
-        const { dim: DIM, reset: R } = UI_COLORS;
-        const isStreaming = this.mode === 'streaming';
-        // Wrap buffer into display lines
-        const { lines, cursorLine, cursorCol } = this.wrapBuffer(maxWidth);
-        // Allow multi-line in non-streaming, single line during streaming
-        const maxDisplayLines = isStreaming ? 1 : 3;
-        const displayLines = Math.min(lines.length, maxDisplayLines);
-        const visibleLines = lines.slice(0, displayLines);
-        // Calculate total height for bottom area
-        const hasModelInfo = !!this.modelInfo;
-        const totalHeight = 4 + displayLines + (hasModelInfo ? 1 : 0);
-        // Ensure scroll region is always enabled (unified behavior)
-        if (!this.scrollRegionActive || this.reservedLines !== totalHeight) {
-            this.reservedLines = totalHeight;
-            this.enableScrollRegion();
-        }
-        const startRow = Math.max(1, rows - totalHeight + 1);
-        // Save cursor, hide it
-        this.write(ESC.SAVE);
-        this.write(ESC.HIDE);
-        let currentRow = startRow;
-        // Clear the bottom reserved area
-        for (let r = startRow; r <= rows; r++) {
-            this.write(ESC.TO(r, 1));
-            this.write(ESC.CLEAR_LINE);
-        }
-        // Status bar - UNIFIED: same format for all modes
-        this.write(ESC.TO(currentRow, 1));
-        this.write(isStreaming ? this.buildStreamingStatusBar(cols) : this.buildStatusBar(cols));
-        currentRow++;
-        // Model info line (if set)
-        if (hasModelInfo) {
-            this.write(ESC.TO(currentRow, 1));
-            let modelLine = `${DIM}${this.modelInfo}${R}`;
-            if (this.contextUsage !== null) {
-                const rem = Math.max(0, 100 - this.contextUsage);
-                if (rem < 10)
-                    modelLine += ` ${UI_COLORS.red}⚠ ctx: ${rem}%${R}`;
-                else if (rem < 25)
-                    modelLine += ` ${UI_COLORS.yellow}! ctx: ${rem}%${R}`;
-                else
-                    modelLine += ` ${DIM}· ctx: ${rem}%${R}`;
-            }
-            this.write(modelLine);
-            currentRow++;
-        }
-        // Top divider
-        this.write(ESC.TO(currentRow, 1));
-        this.write(divider);
-        currentRow++;
-        // Input lines with background styling
-        for (let i = 0; i < visibleLines.length; i++) {
-            this.write(ESC.TO(currentRow, 1));
-            const line = visibleLines[i] ?? '';
-            const isFirstLine = i === 0;
-            this.write(ESC.BG_DARK);
-            this.write(ESC.DIM);
-            this.write(isFirstLine ? this.config.promptChar : this.config.continuationChar);
-            this.write(ESC.RESET);
-            this.write(ESC.BG_DARK);
-            this.write(line);
-            // Pad to edge
-            const lineLen = this.config.promptChar.length + line.length;
-            const padding = Math.max(0, cols - lineLen - 1);
-            if (padding > 0)
-                this.write(' '.repeat(padding));
-            this.write(ESC.RESET);
-            currentRow++;
-        }
-        // Bottom divider
-        this.write(ESC.TO(currentRow, 1));
-        this.write(divider);
-        currentRow++;
-        // Mode controls
-        this.write(ESC.TO(currentRow, 1));
-        this.write(this.buildModeControls(cols));
-        // Cursor positioning depends on mode:
-        // - Streaming: restore to content area (where streaming output continues)
-        // - Normal: position in input area for typing
-        if (isStreaming) {
-            this.write(ESC.RESTORE);
-        }
-        else {
-            // Position cursor in input area
-            // Input line is at: startRow + (hasModelInfo ? 2 : 1) + cursorLine
-            const inputStartRow = startRow + (hasModelInfo ? 2 : 1) + 1; // +1 for status bar, +1 for divider
-            const targetRow = inputStartRow + Math.min(cursorLine, displayLines - 1);
-            const targetCol = this.config.promptChar.length + cursorCol + 1;
-            this.write(ESC.TO(targetRow, Math.min(targetCol, cols)));
-        }
-        this.write(ESC.SHOW);
-        // Track last render state
-        this.lastRenderContent = this.buffer;
-        this.lastRenderCursor = this.cursor;
-    }
     /**
      * Enable or disable flow mode.
      * In flow mode, the input renders immediately after content (wherever cursor is).
@@ -739,16 +494,11 @@ export class TerminalInput extends EventEmitter {
         return this.thinkingEnabled;
     }
     /**
-     * Keep the top N rows pinned outside the scroll region (used for the launch banner).
+     * Keep the top N rows pinned (used for the launch banner tracking).
+     * Note: No longer uses scroll regions - inline rendering only.
      */
     setPinnedHeaderLines(count) {
-        // Set pinned header rows (banner area that scroll region excludes)
-        if (this.pinnedTopRows !== count) {
-            this.pinnedTopRows = count;
-            if (this.scrollRegionActive) {
-                this.applyScrollRegion();
-            }
-        }
+        this.pinnedTopRows = count;
     }
     /**
      * Anchor prompt rendering near a specific row (inline layout). Pass null to
@@ -817,14 +567,17 @@ export class TerminalInput extends EventEmitter {
     }
     /**
      * Clear the buffer
+     * @param skipRender - If true, don't trigger a re-render (used during submit flow)
      */
-    clear() {
+    clear(skipRender = false) {
         this.buffer = '';
         this.cursor = 0;
         this.historyIndex = -1;
         this.tempInput = '';
         this.pastePlaceholders = [];
-        this.scheduleRender();
+        if (!skipRender) {
+            this.scheduleRender();
+        }
     }
     /**
      * Get queued inputs
@@ -936,18 +689,21 @@ export class TerminalInput extends EventEmitter {
         this.scheduleRender();
     }
     /**
-     * Render the input area - UNIFIED for all modes
+     * Render the input area
      *
-     * Uses the same bottom-pinned layout with scroll regions for:
-     * - Idle mode: Shows "Type a message" hint
-     * - Streaming mode: Shows "● Streaming Xs" timer
-     * - Ready mode: Shows status info
+     * - Idle mode: Renders inline input area
+     * - Streaming mode: NO render (content flows naturally, no UI updates)
+     * - Ready mode: Renders inline input area
      */
     render() {
         if (!this.canRender())
             return;
         if (this.isRendering)
             return;
+        // During streaming, do NOT render - let content flow naturally
+        if (this.mode === 'streaming') {
+            return;
+        }
         const shouldSkip = !this.renderDirty &&
             this.buffer === this.lastRenderContent &&
             this.cursor === this.lastRenderCursor;
@@ -964,176 +720,14 @@ export class TerminalInput extends EventEmitter {
         this.isRendering = true;
         writeLock.lock('terminalInput.render');
         try {
-            // UNIFIED: Use the same bottom input area for all modes
-            this.renderBottomInputArea();
+            // Render inline input area at current position
+            this.renderInlineInputAreaAtCursor();
         }
         finally {
             writeLock.unlock();
             this.isRendering = false;
         }
     }
-    /**
-     * Render in flow mode - delegates to bottom-pinned for stability.
-     *
-     * Flow mode attempted inline rendering but caused duplicate renders
-     * due to unreliable cursor position tracking. Bottom-pinned is reliable.
-     */
-    renderFlowMode() {
-        // Use stable bottom-pinned approach
-        this.renderBottomPinned();
-    }
-    /**
-     * Render in bottom-pinned mode - Claude Code style with suggestions
-     *
-     * Works for both normal and streaming modes:
-     * - During streaming: saves/restores cursor position
-     * - Status bar shows streaming info or "Type a message"
-     *
-     * Layout when suggestions visible:
-     * - Top divider
-     * - Input line(s)
-     * - Bottom divider
-     * - Suggestions (command list)
-     *
-     * Layout when suggestions hidden:
-     * - Status bar (Ready/Streaming)
-     * - Top divider
-     * - Input line(s)
-     * - Bottom divider
-     * - Mode controls
-     */
-    renderBottomPinned() {
-        const { rows, cols } = this.getSize();
-        const maxWidth = Math.max(8, cols - 4);
-        const isStreaming = this.mode === 'streaming';
-        // Use unified pinned input area (works for both streaming and normal)
-        // Only use complex rendering when suggestions are visible
-        const hasSuggestions = !isStreaming && this.showSuggestions && this.filteredSuggestions.length > 0;
-        if (!hasSuggestions) {
-            this.renderPinnedInputArea();
-            return;
-        }
-        // Wrap buffer into display lines
-        const { lines, cursorLine, cursorCol } = this.wrapBuffer(maxWidth);
-        const availableForContent = Math.max(1, rows - 3);
-        const maxVisible = Math.max(1, Math.min(this.config.maxLines, availableForContent));
-        const displayLines = Math.min(lines.length, maxVisible);
-        // Calculate display window (keep cursor visible)
-        let startLine = 0;
-        if (lines.length > displayLines) {
-            startLine = Math.max(0, cursorLine - displayLines + 1);
-            startLine = Math.min(startLine, lines.length - displayLines);
-        }
-        const visibleLines = lines.slice(startLine, startLine + displayLines);
-        const adjustedCursorLine = cursorLine - startLine;
-        // Calculate suggestion display (not during streaming)
-        const suggestionsToShow = (!isStreaming && this.showSuggestions)
-            ? this.filteredSuggestions.slice(0, this.maxVisibleSuggestions)
-            : [];
-        const suggestionLines = suggestionsToShow.length;
-        this.write(ESC.HIDE);
-        this.write(ESC.RESET);
-        const divider = renderDivider(cols - 2);
-        // Calculate positions from absolute bottom
-        let currentRow;
-        if (suggestionLines > 0) {
-            // With suggestions: input area + dividers + suggestions
-            // Layout: [topDiv] [input] [bottomDiv] [suggestions...]
-            const totalHeight = 2 + visibleLines.length + suggestionLines; // 2 dividers
-            currentRow = Math.max(1, rows - totalHeight + 1);
-            this.updateReservedLines(totalHeight);
-            // Clear from current position to end of screen to remove any "ghost" content
-            this.write(ESC.TO(currentRow, 1));
-            this.write(ESC.CLEAR_TO_END);
-            // Top divider
-            this.write(ESC.TO(currentRow, 1));
-            this.write(divider);
-            currentRow++;
-            // Input lines
-            let finalRow = currentRow;
-            let finalCol = 3;
-            for (let i = 0; i < visibleLines.length; i++) {
-                this.write(ESC.TO(currentRow, 1));
-                const line = visibleLines[i] ?? '';
-                const absoluteLineIdx = startLine + i;
-                const isFirstLine = absoluteLineIdx === 0;
-                const isCursorLine = i === adjustedCursorLine;
-                this.write(isFirstLine ? this.config.promptChar : this.config.continuationChar);
-                if (isCursorLine) {
-                    const col = Math.min(cursorCol, line.length);
-                    this.write(line.slice(0, col));
-                    this.write(ESC.REVERSE);
-                    this.write(col < line.length ? line[col] : ' ');
-                    this.write(ESC.RESET);
-                    this.write(line.slice(col + 1));
-                    finalRow = currentRow;
-                    finalCol = this.config.promptChar.length + col + 1;
-                }
-                else {
-                    this.write(line);
-                }
-                currentRow++;
-            }
-            // Bottom divider
-            this.write(ESC.TO(currentRow, 1));
-            this.write(divider);
-            currentRow++;
-            // Suggestions (Claude Code style)
-            for (let i = 0; i < suggestionsToShow.length; i++) {
-                this.write(ESC.TO(currentRow, 1));
-                const suggestion = suggestionsToShow[i];
-                const isSelected = i === this.selectedSuggestionIndex;
-                // Indent and highlight selected
-                this.write('  ');
-                if (isSelected) {
-                    this.write(ESC.REVERSE);
-                    this.write(ESC.BOLD);
-                }
-                this.write(suggestion.command);
-                if (isSelected) {
-                    this.write(ESC.RESET);
-                }
-                // Description (dimmed)
-                const descSpace = cols - suggestion.command.length - 8;
-                if (descSpace > 10 && suggestion.description) {
-                    const desc = suggestion.description.slice(0, descSpace);
-                    this.write(ESC.RESET);
-                    this.write(ESC.DIM);
-                    this.write('  ');
-                    this.write(desc);
-                    this.write(ESC.RESET);
-                }
-                currentRow++;
-            }
-            // Position cursor in input area
-            this.write(ESC.TO(finalRow, Math.min(finalCol, cols)));
-        }
-        this.write(ESC.SHOW);
-        // Update state
-        this.lastRenderContent = this.buffer;
-        this.lastRenderCursor = this.cursor;
-    }
-    /**
-     * Build status bar for streaming mode (shows elapsed time, queue count).
-     */
-    buildStreamingStatusBar(cols) {
-        const { green: GREEN, cyan: CYAN, dim: DIM, reset: R } = UI_COLORS;
-        // Streaming status with elapsed time
-        let elapsed = '0s';
-        if (this.streamingStartTime) {
-            const secs = Math.floor((Date.now() - this.streamingStartTime) / 1000);
-            const mins = Math.floor(secs / 60);
-            elapsed = mins > 0 ? `${mins}m ${secs % 60}s` : `${secs}s`;
-        }
-        let status = `${GREEN}● Streaming${R} ${elapsed}`;
-        // Queue indicator
-        if (this.queue.length > 0) {
-            status += ` ${DIM}·${R} ${CYAN}${this.queue.length} queued${R}`;
-        }
-        // Hint for typing
-        status += ` ${DIM}· type to queue message${R}`;
-        return status;
-    }
     /**
      * Build status bar showing streaming/ready status and key info.
      * This is the TOP line above the input area - minimal Claude Code style.
@@ -1294,7 +888,8 @@ export class TerminalInput extends EventEmitter {
         }
         this.disposed = true;
         this.enabled = false;
-        this.disableScrollRegion();
+        // Reset scroll region if it was set
+        this.write(ESC.RESET_SCROLL);
         this.disableBracketedPaste();
         this.buffer = '';
         this.queue = [];
@@ -1685,12 +1280,13 @@ export class TerminalInput extends EventEmitter {
                 timestamp: Date.now(),
             });
             this.emit('queue', text);
-            this.clear(); // Clear immediately for queued input
+            this.clear(); // Clear immediately for queued input, re-render to update queue display
         }
         else {
-            // In idle mode, clear the input first, then emit submit.
-            // The prompt will be logged as a visible message by the caller.
-            this.clear();
+            // In idle mode, clear the input WITHOUT rendering.
+            // The caller will display the user message and start streaming.
+            // We'll render the input area again after streaming ends.
+            this.clear(true); // Skip render - streaming will handle display
             this.emit('submit', text);
         }
     }
@@ -1720,40 +1316,6 @@ export class TerminalInput extends EventEmitter {
         this.scheduleRender();
     }
     // ===========================================================================
-    // SCROLL REGION
-    // ===========================================================================
-    enableScrollRegion() {
-        if (this.scrollRegionActive || !this.isTTY())
-            return;
-        this.applyScrollRegion();
-        this.scrollRegionActive = true;
-    }
-    disableScrollRegion() {
-        if (!this.scrollRegionActive)
-            return;
-        this.write(ESC.RESET_SCROLL);
-        this.scrollRegionActive = false;
-    }
-    applyScrollRegion() {
-        const { rows } = this.getSize();
-        const scrollTop = Math.max(1, this.pinnedTopRows + 1);
-        const scrollBottom = Math.max(scrollTop, rows - this.reservedLines);
-        this.write(ESC.SET_SCROLL(scrollTop, scrollBottom));
-    }
-    updateReservedLines(contentLines) {
-        const { rows } = this.getSize();
-        const baseLines = 2; // separator + control bar
-        const needed = baseLines + contentLines;
-        const maxAllowed = Math.max(baseLines, rows - 1 - this.pinnedTopRows);
-        const newReserved = Math.min(Math.max(baseLines, needed), maxAllowed);
-        if (newReserved !== this.reservedLines) {
-            this.reservedLines = newReserved;
-            if (this.scrollRegionActive) {
-                this.applyScrollRegion();
-            }
-        }
-    }
-    // ===========================================================================
     // BUFFER WRAPPING
     // ===========================================================================
     wrapBuffer(maxWidth) {