erosolar-cli 1.7.243 → 1.7.245

package/dist/shell/terminalInput.js

@@ -3,16 +3,18 @@
  *
  * Design principles:
  * - Single source of truth for input state
+ * - One bottom-pinned chat box for the entire session (no inline anchors)
  * - Native bracketed paste support (no heuristics)
  * - Clean cursor model with render-time wrapping
  * - State machine for different input modes
  * - No readline dependency for display
  */
 import { EventEmitter } from 'node:events';
-import { isMultilinePaste, generatePasteSummary } from '../core/multilinePasteHandler.js';
+import { isMultilinePaste } from '../core/multilinePasteHandler.js';
 import { writeLock } from '../ui/writeLock.js';
-import { renderDivider } from '../ui/unified/layout.js';
+import { renderDivider, renderStatusLine } from '../ui/unified/layout.js';
 import { isStreamingMode } from '../ui/globalWriteLock.js';
+import { formatThinking } from '../ui/toolDisplay.js';
 // ANSI escape codes
 const ESC = {
     // Cursor control
@@ -55,8 +57,6 @@ export class TerminalInput extends EventEmitter {
     isPasting = false;
     pastePlaceholders = [];
     pasteCounter = 0;
-    // Streaming render timer for periodic status updates
-    streamingRenderTimer = null;
     // History
     history = [];
     historyIndex = -1;
@@ -69,6 +69,11 @@ export class TerminalInput extends EventEmitter {
     statusMessage = null;
     overrideStatusMessage = null; // Secondary status (warnings, etc.)
     streamingLabel = null; // Streaming progress indicator
+    metaElapsedSeconds = null; // Optional elapsed time for header line
+    metaTokensUsed = null; // Optional token usage
+    metaTokenLimit = null; // Optional token window
+    metaThinkingMs = null; // Optional thinking duration
+    metaThinkingHasContent = false; // Whether collapsed thinking content exists
     reservedLines = 2;
     scrollRegionActive = false;
     lastRenderContent = '';
@@ -76,22 +81,12 @@ export class TerminalInput extends EventEmitter {
     renderDirty = false;
     isRendering = false;
     pinnedTopRows = 0;
-    inlineAnchorRow = null;
-    inlineLayout = false;
-    anchorProvider = null;
-    // Flow mode: when true, renders inline after content (no absolute positioning)
-    flowMode = true;
-    flowModeRenderedLines = 0; // Track lines rendered for clearing
-    // Command suggestions (Claude Code style auto-complete)
-    commandSuggestions = [];
-    filteredSuggestions = [];
-    selectedSuggestionIndex = 0;
-    showSuggestions = false;
-    maxVisibleSuggestions = 10;
     // Lifecycle
     disposed = false;
     enabled = true;
     contextUsage = null;
+    contextAutoCompactThreshold = 90;
+    thinkingModeLabel = null;
     editMode = 'display-edits';
     verificationEnabled = true;
     autoContinueEnabled = false;
@@ -102,10 +97,6 @@ export class TerminalInput extends EventEmitter {
     // Streaming render throttle
     lastStreamingRender = 0;
     streamingRenderInterval = 250; // ms between renders during streaming
-    // Metrics tracking for status bar
-    streamingStartTime = null;
-    tokensUsed = 0;
-    thinkingEnabled = true;
     constructor(writeStream = process.stdout, config = {}) {
         super();
         this.out = writeStream;
@@ -193,11 +184,6 @@ export class TerminalInput extends EventEmitter {
             if (handled)
                 return;
         }
-        // Handle '?' for help hint (if buffer is empty)
-        if (str === '?' && this.buffer.length === 0) {
-            this.emit('showHelp');
-            return;
-        }
         // Insert printable characters
         if (str && !key?.ctrl && !key?.meta) {
             this.insertText(str);
@@ -206,158 +192,24 @@ export class TerminalInput extends EventEmitter {
     /**
      * 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 keeps the scroll region active so the prompt/status stay pinned
+     * below the streaming output. When streaming ends, we refresh the input area.
      */
     setMode(mode) {
         const prevMode = this.mode;
         this.mode = mode;
         if (mode === 'streaming' && prevMode !== 'streaming') {
-            // Track streaming start time for elapsed display
-            this.streamingStartTime = Date.now();
-            // Enable scroll region so content scrolls while input stays fixed
+            // Keep scroll region active so status/prompt stay pinned while streaming
             this.enableScrollRegion();
-            // Position cursor in scroll region for content
-            const { rows } = this.getSize();
-            const scrollBottom = Math.max(1, rows - this.reservedLines);
-            this.write(ESC.TO(scrollBottom, 1));
-            // Mark dirty for continuous updates
             this.renderDirty = true;
-            // Start periodic render timer for status updates (elapsed time, etc.)
-            this.streamingRenderTimer = setInterval(() => {
-                if (this.mode === 'streaming') {
-                    this.forceRender();
-                }
-            }, 1000);
-            // Render the input area (it's outside scroll region, stays fixed)
-            this.forceRender();
+            this.render();
         }
         else if (mode !== 'streaming' && prevMode === 'streaming') {
-            // Stop streaming render timer
-            if (this.streamingRenderTimer) {
-                clearInterval(this.streamingRenderTimer);
-                this.streamingRenderTimer = null;
-            }
-            // Reset streaming time
-            this.streamingStartTime = null;
-            // Keep scroll region active - consistent UI
-            // Re-render the input area
+            // Streaming ended - render the input area
+            this.enableScrollRegion();
             this.forceRender();
         }
     }
-    /**
-     * Enable or disable flow mode.
-     * In flow mode, the input renders immediately after content (wherever cursor is).
-     * When disabled, input renders at the absolute bottom of terminal.
-     */
-    setFlowMode(enabled) {
-        if (this.flowMode === enabled)
-            return;
-        this.flowMode = enabled;
-        this.renderDirty = true;
-        this.scheduleRender();
-    }
-    /**
-     * Check if flow mode is enabled.
-     */
-    isFlowMode() {
-        return this.flowMode;
-    }
-    /**
-     * Set available slash commands for auto-complete suggestions.
-     */
-    setCommands(commands) {
-        this.commandSuggestions = commands;
-        this.updateSuggestions();
-    }
-    /**
-     * Update filtered suggestions based on current input.
-     */
-    updateSuggestions() {
-        const input = this.buffer.trim();
-        // Only show suggestions when input starts with "/"
-        if (!input.startsWith('/')) {
-            this.showSuggestions = false;
-            this.filteredSuggestions = [];
-            this.selectedSuggestionIndex = 0;
-            return;
-        }
-        const query = input.toLowerCase();
-        this.filteredSuggestions = this.commandSuggestions.filter(cmd => cmd.command.toLowerCase().startsWith(query) ||
-            cmd.command.toLowerCase().includes(query.slice(1)));
-        // Show suggestions if we have matches
-        this.showSuggestions = this.filteredSuggestions.length > 0;
-        // Keep selection in bounds
-        if (this.selectedSuggestionIndex >= this.filteredSuggestions.length) {
-            this.selectedSuggestionIndex = Math.max(0, this.filteredSuggestions.length - 1);
-        }
-    }
-    /**
-     * Select next suggestion (arrow down / tab).
-     */
-    selectNextSuggestion() {
-        if (!this.showSuggestions || this.filteredSuggestions.length === 0)
-            return;
-        this.selectedSuggestionIndex = (this.selectedSuggestionIndex + 1) % this.filteredSuggestions.length;
-        this.renderDirty = true;
-        this.scheduleRender();
-    }
-    /**
-     * Select previous suggestion (arrow up / shift+tab).
-     */
-    selectPrevSuggestion() {
-        if (!this.showSuggestions || this.filteredSuggestions.length === 0)
-            return;
-        this.selectedSuggestionIndex = this.selectedSuggestionIndex === 0
-            ? this.filteredSuggestions.length - 1
-            : this.selectedSuggestionIndex - 1;
-        this.renderDirty = true;
-        this.scheduleRender();
-    }
-    /**
-     * Accept current suggestion and insert into buffer.
-     */
-    acceptSuggestion() {
-        if (!this.showSuggestions || this.filteredSuggestions.length === 0)
-            return false;
-        const selected = this.filteredSuggestions[this.selectedSuggestionIndex];
-        if (!selected)
-            return false;
-        // Replace buffer with selected command
-        this.buffer = selected.command + ' ';
-        this.cursor = this.buffer.length;
-        this.showSuggestions = false;
-        this.renderDirty = true;
-        this.scheduleRender();
-        return true;
-    }
-    /**
-     * Check if suggestions are visible.
-     */
-    areSuggestionsVisible() {
-        return this.showSuggestions && this.filteredSuggestions.length > 0;
-    }
-    /**
-     * Update token count for metrics display
-     */
-    setTokensUsed(tokens) {
-        this.tokensUsed = tokens;
-    }
-    /**
-     * Toggle thinking/reasoning mode
-     */
-    toggleThinking() {
-        this.thinkingEnabled = !this.thinkingEnabled;
-        this.emit('thinkingToggle', this.thinkingEnabled);
-        this.scheduleRender();
-    }
-    /**
-     * Get thinking enabled state
-     */
-    isThinkingEnabled() {
-        return this.thinkingEnabled;
-    }
     /**
      * Keep the top N rows pinned outside the scroll region (used for the launch banner).
      */
@@ -370,42 +222,6 @@ export class TerminalInput extends EventEmitter {
             }
         }
     }
-    /**
-     * Anchor prompt rendering near a specific row (inline layout). Pass null to
-     * restore the default bottom-aligned layout.
-     */
-    setInlineAnchor(row) {
-        if (row === null || row === undefined) {
-            this.inlineAnchorRow = null;
-            this.inlineLayout = false;
-            this.renderDirty = true;
-            this.render();
-            return;
-        }
-        const { rows } = this.getSize();
-        const clamped = Math.max(1, Math.min(Math.floor(row), rows));
-        this.inlineAnchorRow = clamped;
-        this.inlineLayout = true;
-        this.renderDirty = true;
-        this.render();
-    }
-    /**
-     * Provide a dynamic anchor callback. When set, the prompt will follow the
-     * output by re-evaluating the anchor before each render.
-     */
-    setInlineAnchorProvider(provider) {
-        this.anchorProvider = provider;
-        if (!provider) {
-            this.inlineLayout = false;
-            this.inlineAnchorRow = null;
-            this.renderDirty = true;
-            this.render();
-            return;
-        }
-        this.inlineLayout = true;
-        this.renderDirty = true;
-        this.render();
-    }
     /**
      * Get current mode
      */
@@ -515,6 +331,37 @@ export class TerminalInput extends EventEmitter {
         this.streamingLabel = next;
         this.scheduleRender();
     }
+    /**
+     * Surface meta status just above the divider (e.g., elapsed time or token usage).
+     */
+    setMetaStatus(meta) {
+        const nextElapsed = typeof meta.elapsedSeconds === 'number' && Number.isFinite(meta.elapsedSeconds) && meta.elapsedSeconds >= 0
+            ? Math.floor(meta.elapsedSeconds)
+            : null;
+        const nextTokens = typeof meta.tokensUsed === 'number' && Number.isFinite(meta.tokensUsed) && meta.tokensUsed >= 0
+            ? Math.floor(meta.tokensUsed)
+            : null;
+        const nextLimit = typeof meta.tokenLimit === 'number' && Number.isFinite(meta.tokenLimit) && meta.tokenLimit > 0
+            ? Math.floor(meta.tokenLimit)
+            : null;
+        const nextThinking = typeof meta.thinkingMs === 'number' && Number.isFinite(meta.thinkingMs) && meta.thinkingMs >= 0
+            ? Math.floor(meta.thinkingMs)
+            : null;
+        const nextThinkingHasContent = !!meta.thinkingHasContent;
+        if (this.metaElapsedSeconds === nextElapsed &&
+            this.metaTokensUsed === nextTokens &&
+            this.metaTokenLimit === nextLimit &&
+            this.metaThinkingMs === nextThinking &&
+            this.metaThinkingHasContent === nextThinkingHasContent) {
+            return;
+        }
+        this.metaElapsedSeconds = nextElapsed;
+        this.metaTokensUsed = nextTokens;
+        this.metaTokenLimit = nextLimit;
+        this.metaThinkingMs = nextThinking;
+        this.metaThinkingHasContent = nextThinkingHasContent;
+        this.scheduleRender();
+    }
     /**
      * Keep mode toggles (verification/auto-continue) visible in the control bar.
      * Hotkey labels remain stable so the bar looks the same before/during streaming.
@@ -524,16 +371,19 @@ export class TerminalInput extends EventEmitter {
         const nextAutoContinue = !!options.autoContinueEnabled;
         const nextVerifyHotkey = options.verificationHotkey ?? this.verificationHotkey;
         const nextAutoHotkey = options.autoContinueHotkey ?? this.autoContinueHotkey;
+        const nextThinkingLabel = options.thinkingModeLabel === undefined ? this.thinkingModeLabel : (options.thinkingModeLabel || null);
         if (this.verificationEnabled === nextVerification &&
             this.autoContinueEnabled === nextAutoContinue &&
             this.verificationHotkey === nextVerifyHotkey &&
-            this.autoContinueHotkey === nextAutoHotkey) {
+            this.autoContinueHotkey === nextAutoHotkey &&
+            this.thinkingModeLabel === nextThinkingLabel) {
             return;
         }
         this.verificationEnabled = nextVerification;
         this.autoContinueEnabled = nextAutoContinue;
         this.verificationHotkey = nextVerifyHotkey;
         this.autoContinueHotkey = nextAutoHotkey;
+        this.thinkingModeLabel = nextThinkingLabel;
         this.scheduleRender();
     }
     /**
@@ -548,192 +398,88 @@ export class TerminalInput extends EventEmitter {
     /**
      * Render the input area - Claude Code style with mode controls
      *
-     * Uses scroll region to keep input fixed while content scrolls above.
-     * During streaming, we render periodically to show status updates.
+     * IMPORTANT: During streaming mode, we skip the full render to avoid
+     * interfering with streaming content. Streaming content writes naturally
+     * to stdout, and cursor positioning during streaming would cause garbled output.
+     * A full render is done when streaming ends via forceRender().
      */
     render() {
         if (!this.canRender())
             return;
         if (this.isRendering)
             return;
-        const isStreaming = this.mode === 'streaming' || isStreamingMode();
+        // CRITICAL: During streaming, skip full render to avoid interfering
+        // with streaming content. The streaming chunks need to flow naturally
+        // without cursor repositioning breaking them up.
+        // Check both local mode and global streaming mode flag
+        if (this.mode === 'streaming' || isStreamingMode()) {
+            this.renderDirty = true; // Mark dirty so we render after streaming ends
+            return;
+        }
         const shouldSkip = !this.renderDirty &&
             this.buffer === this.lastRenderContent &&
             this.cursor === this.lastRenderCursor;
         this.renderDirty = false;
-        // Skip if nothing changed (unless streaming, where we update status)
-        if (shouldSkip && !isStreaming) {
+        // Skip if nothing changed and no explicit refresh requested
+        if (shouldSkip) {
             return;
         }
-        // If write lock is held, defer render
+        // If write lock is held, defer render to avoid race conditions
         if (writeLock.isLocked()) {
             writeLock.safeWrite(() => this.render());
             return;
         }
         this.isRendering = true;
+        // Use write lock during render to prevent interleaved output
         writeLock.lock('terminalInput.render');
         try {
-            // During streaming, save cursor position so content can continue
-            if (isStreaming) {
-                this.write('\x1b7'); // Save cursor (DECSC)
+            if (!this.scrollRegionActive) {
+                this.enableScrollRegion();
             }
-            // Render input area at bottom (outside scroll region)
-            this.renderBottomPinned();
-            // During streaming, restore cursor to scroll region for content
-            if (isStreaming) {
-                this.write('\x1b8'); // Restore cursor (DECRC)
+            const { rows, cols } = this.getSize();
+            const maxWidth = Math.max(8, cols - 4);
+            // Wrap buffer into display lines
+            const { lines, cursorLine, cursorCol } = this.wrapBuffer(maxWidth);
+            const availableForContent = Math.max(1, rows - 3); // room for separator + input + controls
+            const maxVisible = Math.max(1, Math.min(this.config.maxLines, availableForContent));
+            const displayLines = Math.min(lines.length, maxVisible);
+            const metaLines = this.buildMetaLines(cols - 2);
+            // Reserved lines: optional meta lines + separator(1) + input lines + controls(1)
+            this.updateReservedLines(displayLines + 2 + metaLines.length);
+            // 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);
             }
-        }
-        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
-     *
-     * 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);
-        // 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
-        const suggestionsToShow = 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);
-            // Top divider
-            this.write(ESC.TO(currentRow, 1));
-            this.write(ESC.CLEAR_LINE);
-            this.write(divider);
-            currentRow++;
-            // Input lines
-            let finalRow = currentRow;
-            let finalCol = 3;
-            for (let i = 0; i < visibleLines.length; i++) {
+            const visibleLines = lines.slice(startLine, startLine + displayLines);
+            const adjustedCursorLine = cursorLine - startLine;
+            // Render
+            this.write(ESC.HIDE);
+            this.write(ESC.RESET);
+            const startRow = Math.max(1, rows - this.reservedLines + 1);
+            let currentRow = startRow;
+            // Clear the reserved block to avoid stale meta/status lines
+            this.clearReservedArea(startRow, this.reservedLines, cols);
+            // Meta/status header (elapsed, tokens/context)
+            for (const metaLine of metaLines) {
                 this.write(ESC.TO(currentRow, 1));
                 this.write(ESC.CLEAR_LINE);
-                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(ESC.CLEAR_LINE);
-            this.write(divider);
-            currentRow++;
-            // Suggestions (Claude Code style)
-            for (let i = 0; i < suggestionsToShow.length; i++) {
-                this.write(ESC.TO(currentRow, 1));
-                this.write(ESC.CLEAR_LINE);
-                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++;
+                this.write(metaLine);
+                currentRow += 1;
             }
-            // Position cursor in input area
-            this.write(ESC.TO(finalRow, Math.min(finalCol, cols)));
-        }
-        else {
-            // Without suggestions: normal layout with status bar and controls
-            const totalHeight = visibleLines.length + 4; // status + topDiv + input + bottomDiv + controls
-            currentRow = Math.max(1, rows - totalHeight + 1);
-            this.updateReservedLines(totalHeight);
-            // Status bar
-            this.write(ESC.TO(currentRow, 1));
-            this.write(ESC.CLEAR_LINE);
-            this.write(this.buildStatusBar(cols));
-            currentRow++;
-            // Top divider
+            // Separator line
             this.write(ESC.TO(currentRow, 1));
             this.write(ESC.CLEAR_LINE);
+            const divider = renderDivider(cols - 2);
             this.write(divider);
-            currentRow++;
-            // Input lines
+            currentRow += 1;
+            // Render input lines
             let finalRow = currentRow;
             let finalCol = 3;
             for (let i = 0; i < visibleLines.length; i++) {
-                this.write(ESC.TO(currentRow, 1));
+                const rowNum = currentRow + i;
+                this.write(ESC.TO(rowNum, 1));
                 this.write(ESC.CLEAR_LINE);
                 const line = visibleLines[i] ?? '';
                 const absoluteLineIdx = startLine + i;
@@ -747,6 +493,7 @@ export class TerminalInput extends EventEmitter {
                 this.write(ESC.RESET);
                 this.write(ESC.BG_DARK);
                 if (isCursorLine) {
+                    // Render with block cursor
                     const col = Math.min(cursorCol, line.length);
                     const before = line.slice(0, col);
                     const at = col < line.length ? line[col] : ' ';
@@ -756,137 +503,214 @@ export class TerminalInput extends EventEmitter {
                     this.write(at);
                     this.write(ESC.RESET + ESC.BG_DARK);
                     this.write(after);
-                    finalRow = currentRow;
+                    finalRow = rowNum;
                     finalCol = this.config.promptChar.length + col + 1;
                 }
                 else {
                     this.write(line);
                 }
-                // Pad to edge
+                // Pad to edge for clean look
                 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(ESC.CLEAR_LINE);
-            this.write(divider);
-            currentRow++;
-            // Mode controls
-            this.write(ESC.TO(currentRow, 1));
+            // Mode controls line (Claude Code style)
+            const controlRow = currentRow + visibleLines.length;
+            this.write(ESC.TO(controlRow, 1));
             this.write(ESC.CLEAR_LINE);
             this.write(this.buildModeControls(cols));
-            // Position cursor in input area
+            // Position cursor
             this.write(ESC.TO(finalRow, Math.min(finalCol, cols)));
+            this.write(ESC.SHOW);
+            // Update state
+            this.lastRenderContent = this.buffer;
+            this.lastRenderCursor = this.cursor;
+        }
+        finally {
+            writeLock.unlock();
+            this.isRendering = false;
         }
-        this.write(ESC.SHOW);
-        // Update state
-        this.lastRenderContent = this.buffer;
-        this.lastRenderCursor = this.cursor;
     }
     /**
-     * Build status bar showing streaming/ready status and key info.
-     * This is the TOP line above the input area - minimal Claude Code style.
+     * Build one or more compact meta lines above the divider (thinking, status, usage).
      */
-    buildStatusBar(cols) {
-        const maxWidth = cols - 2;
-        const parts = [];
-        // Streaming status with elapsed time (left side)
-        if (this.mode === 'streaming') {
-            let statusText = '● Streaming';
-            if (this.streamingStartTime) {
-                const elapsed = Math.floor((Date.now() - this.streamingStartTime) / 1000);
-                const mins = Math.floor(elapsed / 60);
-                const secs = elapsed % 60;
-                statusText += mins > 0 ? ` ${mins}m ${secs}s` : ` ${secs}s`;
-            }
-            parts.push(`\x1b[32m${statusText}\x1b[0m`); // Green
+    buildMetaLines(width) {
+        const lines = [];
+        if (this.metaThinkingMs !== null) {
+            const thinkingText = formatThinking(this.metaThinkingMs, this.metaThinkingHasContent);
+            lines.push(renderStatusLine([{ text: thinkingText, tone: 'info' }], width));
         }
-        // Queue indicator during streaming
-        if (this.mode === 'streaming' && this.queue.length > 0) {
-            parts.push(`\x1b[36mqueued: ${this.queue.length}\x1b[0m`); // Cyan
+        const statusParts = [];
+        const statusLabel = this.statusMessage ?? this.streamingLabel;
+        if (statusLabel) {
+            statusParts.push({ text: statusLabel, tone: 'info' });
         }
-        // Paste indicator
-        if (this.pastePlaceholders.length > 0) {
-            const totalLines = this.pastePlaceholders.reduce((sum, p) => sum + p.lineCount, 0);
-            parts.push(`\x1b[36m📋 ${totalLines}L\x1b[0m`);
+        if (this.mode === 'streaming' || isStreamingMode()) {
+            statusParts.push({ text: 'esc to interrupt', tone: 'warn' });
+        }
+        if (this.metaElapsedSeconds !== null) {
+            statusParts.push({ text: this.formatElapsedLabel(this.metaElapsedSeconds), tone: 'muted' });
+        }
+        const tokensRemaining = this.computeTokensRemaining();
+        if (tokensRemaining !== null) {
+            statusParts.push({ text: `↓ ${tokensRemaining}`, tone: 'muted' });
+        }
+        if (statusParts.length) {
+            lines.push(renderStatusLine(statusParts, width));
+        }
+        const usageParts = [];
+        if (this.metaTokensUsed !== null) {
+            const formattedUsed = this.formatTokenCount(this.metaTokensUsed);
+            const formattedLimit = this.metaTokenLimit ? `/${this.formatTokenCount(this.metaTokenLimit)}` : '';
+            usageParts.push({ text: `tokens ${formattedUsed}${formattedLimit}`, tone: 'muted' });
+        }
+        if (this.contextUsage !== null) {
+            const tone = this.contextUsage >= 75 ? 'warn' : 'muted';
+            const left = Math.max(0, 100 - this.contextUsage);
+            usageParts.push({ text: `context used ${this.contextUsage}% (${left}% left)`, tone });
+        }
+        if (this.queue.length > 0) {
+            usageParts.push({ text: `queued ${this.queue.length}`, tone: 'info' });
+        }
+        if (usageParts.length) {
+            lines.push(renderStatusLine(usageParts, width));
+        }
+        return lines;
+    }
+    /**
+     * Clear the reserved bottom block (meta + divider + input + controls) before repainting.
+     */
+    clearReservedArea(startRow, reservedLines, cols) {
+        const width = Math.max(1, cols);
+        for (let i = 0; i < reservedLines; i++) {
+            const row = startRow + i;
+            this.write(ESC.TO(row, 1));
+            this.write(' '.repeat(width));
+        }
+    }
+    /**
+     * Build Claude Code style mode controls line.
+     * Combines streaming label + override status + main status for simultaneous display.
+     */
+    buildModeControls(cols) {
+        const width = Math.max(8, cols - 2);
+        const leftParts = [];
+        const rightParts = [];
+        if (this.streamingLabel) {
+            leftParts.push({ text: `◐ ${this.streamingLabel}`, tone: 'info' });
         }
-        // Override/warning status
         if (this.overrideStatusMessage) {
-            parts.push(`\x1b[33m⚠ ${this.overrideStatusMessage}\x1b[0m`); // Yellow
+            leftParts.push({ text: `⚠ ${this.overrideStatusMessage}`, tone: 'warn' });
         }
-        // If idle with empty buffer, show quick shortcuts
-        if (this.mode !== 'streaming' && this.buffer.length === 0 && parts.length === 0) {
-            return `${ESC.DIM}Type a message or / for commands${ESC.RESET}`;
+        if (this.statusMessage) {
+            leftParts.push({ text: this.statusMessage, tone: this.streamingLabel ? 'muted' : 'info' });
+        }
+        const editLabel = this.editMode === 'display-edits' ? 'accept edits on' : 'ask before edits';
+        const editIcon = this.editMode === 'display-edits' ? '⏵⏵' : '🛡';
+        leftParts.push({
+            text: `${editIcon} ${editLabel} (shift+tab to cycle)`,
+            tone: this.editMode === 'display-edits' ? 'success' : 'muted',
+        });
+        const verifyLabel = this.verificationEnabled ? 'verify+build on' : 'verify+build off';
+        leftParts.push({
+            text: `${verifyLabel} (${this.verificationHotkey.toLowerCase()})`,
+            tone: this.verificationEnabled ? 'success' : 'muted',
+        });
+        const continueLabel = this.autoContinueEnabled ? 'auto-continue on' : 'auto-continue off';
+        leftParts.push({
+            text: `${continueLabel} (${this.autoContinueHotkey.toLowerCase()})`,
+            tone: this.autoContinueEnabled ? 'info' : 'muted',
+        });
+        if (this.queue.length > 0 && this.mode !== 'streaming') {
+            leftParts.push({ text: `queued ${this.queue.length}`, tone: 'info' });
         }
-        // Multi-line indicator
         if (this.buffer.includes('\n')) {
-            parts.push(`${ESC.DIM}${this.buffer.split('\n').length}L${ESC.RESET}`);
+            const lineCount = this.buffer.split('\n').length;
+            leftParts.push({ text: `${lineCount} lines`, tone: 'muted' });
+        }
+        if (this.pastePlaceholders.length > 0) {
+            const latest = this.pastePlaceholders[this.pastePlaceholders.length - 1];
+            leftParts.push({
+                text: `paste #${latest.id} +${latest.lineCount} lines (⌫ to drop)`,
+                tone: 'info',
+            });
+        }
+        const contextRemaining = this.computeContextRemaining();
+        if (this.thinkingModeLabel) {
+            rightParts.push({ text: `thinking ${this.thinkingModeLabel} (/thinking)`, tone: 'info' });
+        }
+        if (contextRemaining !== null) {
+            const tone = contextRemaining <= 10 ? 'warn' : 'muted';
+            const label = contextRemaining === 0 && this.contextUsage !== null
+                ? 'Context auto-compact imminent'
+                : `Context left until auto-compact: ${contextRemaining}%`;
+            rightParts.push({ text: label, tone });
+        }
+        if (!rightParts.length || width < 60) {
+            const merged = rightParts.length ? [...leftParts, ...rightParts] : leftParts;
+            return renderStatusLine(merged, width);
+        }
+        const leftWidth = Math.max(12, Math.floor(width * 0.6));
+        const rightWidth = Math.max(14, width - leftWidth - 1);
+        const leftText = renderStatusLine(leftParts, leftWidth);
+        const rightText = renderStatusLine(rightParts, rightWidth);
+        const spacing = Math.max(1, width - this.visibleLength(leftText) - this.visibleLength(rightText));
+        return `${leftText}${' '.repeat(spacing)}${rightText}`;
+    }
+    computeContextRemaining() {
+        if (this.contextUsage === null) {
+            return null;
+        }
+        return Math.max(0, this.contextAutoCompactThreshold - this.contextUsage);
+    }
+    computeTokensRemaining() {
+        if (this.metaTokensUsed === null || this.metaTokenLimit === null) {
+            return null;
         }
-        if (parts.length === 0) {
-            return ''; // Empty status bar when idle
+        const remaining = Math.max(0, this.metaTokenLimit - this.metaTokensUsed);
+        return this.formatTokenCount(remaining);
+    }
+    formatElapsedLabel(seconds) {
+        if (seconds < 60) {
+            return `${seconds}s`;
         }
-        const joined = parts.join(`${ESC.DIM} · ${ESC.RESET}`);
-        return joined.slice(0, maxWidth);
+        const mins = Math.floor(seconds / 60);
+        const secs = seconds % 60;
+        return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+    }
+    formatTokenCount(value) {
+        if (!Number.isFinite(value)) {
+            return `${value}`;
+        }
+        if (value >= 1_000_000) {
+            return `${(value / 1_000_000).toFixed(1)}M`;
+        }
+        if (value >= 1_000) {
+            return `${(value / 1_000).toFixed(1)}k`;
+        }
+        return `${Math.round(value)}`;
+    }
+    visibleLength(value) {
+        const ansiPattern = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+        return value.replace(ansiPattern, '').length;
     }
     /**
-     * Build mode controls line showing toggles and context info.
-     * This is the BOTTOM line below the input area - Claude Code style layout with erosolar features.
-     *
-     * Layout: [toggles on left] ... [context info on right]
+     * Debug-only snapshot used by tests to assert rendered strings without
+     * needing a TTY. Not used by production code.
      */
-    buildModeControls(cols) {
-        const maxWidth = cols - 2;
-        // Left side: Mode toggles (erosolar-cli features)
-        const toggles = [];
-        // Edit mode toggle (⏵⏵ = auto, ⏸⏸ = ask)
-        const editIcon = this.editMode === 'display-edits' ? '⏵⏵' : '⏸⏸';
-        const editLabel = this.editMode === 'display-edits' ? 'auto-edit' : 'ask-first';
-        toggles.push(`${editIcon} ${editLabel}`);
-        // Thinking mode toggle
-        const thinkIcon = this.thinkingEnabled ? '💭' : '○';
-        toggles.push(`${thinkIcon} think`);
-        // Verification toggle
-        const verifyIcon = this.verificationEnabled ? '✓' : '○';
-        toggles.push(`${verifyIcon} verify`);
-        // Auto-continue toggle
-        const autoIcon = this.autoContinueEnabled ? '↻' : '○';
-        toggles.push(`${autoIcon} auto`);
-        const leftPart = toggles.join(' · ') + ' (⇧⇥)';
-        // Right side: Context usage information
-        let rightPart = '';
-        if (this.contextUsage !== null) {
-            const remaining = Math.max(0, 100 - this.contextUsage);
-            const urgency = remaining < 10 ? '⚠ ' : remaining < 25 ? '! ' : '';
-            rightPart = `${urgency}ctx: ${remaining}%`;
-        }
-        // Calculate spacing
-        const leftLen = leftPart.length;
-        const rightLen = rightPart.length;
-        const totalLen = leftLen + rightLen;
-        // If both fit with spacing, align right part to right edge
-        if (totalLen < maxWidth - 4) {
-            const spacing = maxWidth - totalLen;
-            return `${ESC.DIM}${leftPart}${' '.repeat(spacing)}${rightPart}${ESC.RESET}`;
-        }
-        // If they don't fit, prioritize left and truncate right
-        if (rightLen > 0 && leftLen + 8 < maxWidth) {
-            const availableForRight = maxWidth - leftLen - 4;
-            const truncatedRight = rightPart.slice(0, availableForRight);
-            return `${ESC.DIM}${leftPart}    ${truncatedRight}${ESC.RESET}`;
-        }
-        // Just show left part
-        return `${ESC.DIM}${leftPart.slice(0, maxWidth)}${ESC.RESET}`;
+    getDebugUiSnapshot(width) {
+        const cols = Math.max(8, width ?? this.getSize().cols);
+        return {
+            meta: this.buildMetaLines(cols - 2),
+            controls: this.buildModeControls(cols),
+        };
     }
     /**
      * Force a re-render
      */
     forceRender() {
-        // Ensure scroll region is enabled for consistent UI
-        this.enableScrollRegion();
         this.lastRenderContent = '';
         this.lastRenderCursor = -1;
         this.renderDirty = true;
@@ -916,9 +740,6 @@ export class TerminalInput extends EventEmitter {
      * Register with display's output interceptor to position cursor correctly.
      * When scroll region is active, output needs to go to the scroll region,
      * not the protected bottom area where the input is rendered.
-     *
-     * NOTE: With scroll region properly set, content naturally stays within
-     * the region boundaries - no cursor manipulation needed per-write.
      */
     registerOutputInterceptor(display) {
         if (this.outputInterceptorCleanup) {
@@ -926,11 +747,20 @@ export class TerminalInput extends EventEmitter {
         }
         this.outputInterceptorCleanup = display.registerOutputInterceptor({
             beforeWrite: () => {
-                // Scroll region handles content containment automatically
-                // No per-write cursor manipulation needed
+                // When the scroll region is active, temporarily move the cursor into
+                // the scrollable area so streamed output lands above the pinned prompt.
+                if (this.scrollRegionActive) {
+                    const { rows } = this.getSize();
+                    const scrollBottom = Math.max(this.pinnedTopRows + 1, rows - this.reservedLines);
+                    this.write(ESC.SAVE);
+                    this.write(ESC.TO(scrollBottom, 1));
+                }
             },
             afterWrite: () => {
-                // No cursor manipulation needed
+                // Restore cursor back to the pinned prompt after output completes.
+                if (this.scrollRegionActive) {
+                    this.write(ESC.RESTORE);
+                }
             },
         });
     }
@@ -940,11 +770,6 @@ export class TerminalInput extends EventEmitter {
     dispose() {
         if (this.disposed)
             return;
-        // Clean up streaming render timer
-        if (this.streamingRenderTimer) {
-            clearInterval(this.streamingRenderTimer);
-            this.streamingRenderTimer = null;
-        }
         // Clean up output interceptor
         if (this.outputInterceptorCleanup) {
             this.outputInterceptorCleanup();
@@ -1057,22 +882,7 @@ export class TerminalInput extends EventEmitter {
                     this.toggleEditMode();
                     return true;
                 }
-                // Tab: toggle paste expansion if in placeholder, otherwise toggle thinking
-                if (this.findPlaceholderAt(this.cursor)) {
-                    this.togglePasteExpansion();
-                }
-                else {
-                    this.toggleThinking();
-                }
-                return true;
-            case 'escape':
-                // Esc: interrupt if streaming, otherwise clear buffer
-                if (this.mode === 'streaming') {
-                    this.emit('interrupt');
-                }
-                else if (this.buffer.length > 0) {
-                    this.clear();
-                }
+                this.insertText('  ');
                 return true;
         }
         return false;
@@ -1090,7 +900,6 @@ export class TerminalInput extends EventEmitter {
         this.insertPlainText(chunk, insertPos);
         this.cursor = insertPos + chunk.length;
         this.emit('change', this.buffer);
-        this.updateSuggestions();
         this.scheduleRender();
     }
     insertNewline() {
@@ -1115,7 +924,6 @@ export class TerminalInput extends EventEmitter {
             this.cursor = Math.max(0, this.cursor - 1);
         }
         this.emit('change', this.buffer);
-        this.updateSuggestions();
         this.scheduleRender();
     }
     deleteForward() {
@@ -1365,7 +1173,9 @@ export class TerminalInput extends EventEmitter {
         if (available <= 0)
             return;
         const chunk = clean.slice(0, available);
-        if (isMultilinePaste(chunk)) {
+        const isMultiline = isMultilinePaste(chunk);
+        const isShortMultiline = isMultiline && this.shouldInlineMultiline(chunk);
+        if (isMultiline && !isShortMultiline) {
             this.insertPastePlaceholder(chunk);
         }
         else {
@@ -1385,6 +1195,7 @@ export class TerminalInput extends EventEmitter {
             return;
         this.applyScrollRegion();
         this.scrollRegionActive = true;
+        this.forceRender();
     }
     disableScrollRegion() {
         if (!this.scrollRegionActive)
@@ -1535,17 +1346,19 @@ export class TerminalInput extends EventEmitter {
         this.shiftPlaceholders(position, text.length);
         this.buffer = this.buffer.slice(0, position) + text + this.buffer.slice(position);
     }
+    shouldInlineMultiline(content) {
+        const lines = content.split('\n').length;
+        const maxInlineLines = 4;
+        const maxInlineChars = 240;
+        return lines <= maxInlineLines && content.length <= maxInlineChars;
+    }
     findPlaceholderAt(position) {
         return this.pastePlaceholders.find((ph) => position >= ph.start && position < ph.end) ?? null;
     }
-    buildPlaceholder(summary) {
+    buildPlaceholder(lineCount) {
         const id = ++this.pasteCounter;
-        const lang = summary.language ? ` ${summary.language.toUpperCase()}` : '';
-        // Show first line preview (truncated)
-        const preview = summary.preview.length > 30
-            ? `${summary.preview.slice(0, 30)}...`
-            : summary.preview;
-        const placeholder = `[📋 #${id}${lang} ${summary.lineCount}L] "${preview}"`;
+        const plural = lineCount === 1 ? '' : 's';
+        const placeholder = `[Pasted text #${id} +${lineCount} line${plural}]`;
         return { id, placeholder };
     }
     insertPastePlaceholder(content) {
@@ -1553,67 +1366,21 @@ export class TerminalInput extends EventEmitter {
         if (available <= 0)
             return;
         const cleanContent = content.slice(0, available);
-        const summary = generatePasteSummary(cleanContent);
-        // For short pastes (< 5 lines), show full content instead of placeholder
-        if (summary.lineCount < 5) {
-            const placeholder = this.findPlaceholderAt(this.cursor);
-            const insertPos = placeholder && this.cursor > placeholder.start ? placeholder.end : this.cursor;
-            this.insertPlainText(cleanContent, insertPos);
-            this.cursor = insertPos + cleanContent.length;
-            return;
-        }
-        const { id, placeholder } = this.buildPlaceholder(summary);
+        const lineCount = cleanContent.split('\n').length;
+        const { id, placeholder } = this.buildPlaceholder(lineCount);
         const insertPos = this.cursor;
         this.shiftPlaceholders(insertPos, placeholder.length);
         this.pastePlaceholders.push({
             id,
             content: cleanContent,
-            lineCount: summary.lineCount,
+            lineCount,
             placeholder,
             start: insertPos,
             end: insertPos + placeholder.length,
-            summary,
-            expanded: false,
         });
         this.buffer = this.buffer.slice(0, insertPos) + placeholder + this.buffer.slice(insertPos);
         this.cursor = insertPos + placeholder.length;
     }
-    /**
-     * Toggle expansion of a paste placeholder at the current cursor position.
-     * When expanded, shows first 3 and last 2 lines of the content.
-     */
-    togglePasteExpansion() {
-        const placeholder = this.findPlaceholderAt(this.cursor);
-        if (!placeholder)
-            return false;
-        placeholder.expanded = !placeholder.expanded;
-        // Update the placeholder text in buffer
-        const newPlaceholder = placeholder.expanded
-            ? this.buildExpandedPlaceholder(placeholder)
-            : this.buildPlaceholder(placeholder.summary).placeholder;
-        const lengthDiff = newPlaceholder.length - placeholder.placeholder.length;
-        // Update buffer
-        this.buffer =
-            this.buffer.slice(0, placeholder.start) +
-                newPlaceholder +
-                this.buffer.slice(placeholder.end);
-        // Update placeholder tracking
-        placeholder.placeholder = newPlaceholder;
-        placeholder.end = placeholder.start + newPlaceholder.length;
-        // Shift other placeholders
-        this.shiftPlaceholders(placeholder.end, lengthDiff, placeholder.id);
-        this.scheduleRender();
-        return true;
-    }
-    buildExpandedPlaceholder(ph) {
-        const lines = ph.content.split('\n');
-        const firstLines = lines.slice(0, 3).map(l => l.slice(0, 60)).join('\n');
-        const lastLines = lines.length > 5
-            ? '\n...\n' + lines.slice(-2).map(l => l.slice(0, 60)).join('\n')
-            : '';
-        const lang = ph.summary.language ? ` ${ph.summary.language.toUpperCase()}` : '';
-        return `[📋 #${ph.id}${lang} ${ph.lineCount}L ▼]\n${firstLines}${lastLines}\n[/📋 #${ph.id}]`;
-    }
     deletePlaceholder(placeholder) {
         const length = placeholder.end - placeholder.start;
         this.buffer = this.buffer.slice(0, placeholder.start) + this.buffer.slice(placeholder.end);
@@ -1621,7 +1388,11 @@ export class TerminalInput extends EventEmitter {
         this.shiftPlaceholders(placeholder.end, -length, placeholder.id);
         this.cursor = placeholder.start;
     }
-    updateContextUsage(value) {
+    updateContextUsage(value, autoCompactThreshold) {
+        if (typeof autoCompactThreshold === 'number' && Number.isFinite(autoCompactThreshold)) {
+            const boundedThreshold = Math.max(1, Math.min(100, Math.round(autoCompactThreshold)));
+            this.contextAutoCompactThreshold = boundedThreshold;
+        }
         if (value === null || !Number.isFinite(value)) {
             this.contextUsage = null;
         }