erosolar-cli 1.7.184 → 1.7.187

package/dist/ui/persistentPrompt.js

@@ -246,6 +246,12 @@ export class PinnedChatBox {
     pastedFullContent = '';
     /** Cleanup function for output interceptor registration */
     outputInterceptorCleanup;
+    // Render deduplication - prevent duplicate displays
+    lastRenderedContent = '';
+    lastRenderedCursor = -1;
+    lastRenderedRows = 0;
+    lastRenderedCols = 0;
+    isRendering = false; // Render lock to prevent concurrent renders
     constructor(writeStream, _promptText = '> ', // Unused - readline handles input display
     options = {}) {
         this.writeStream = writeStream;
@@ -311,10 +317,14 @@ export class PinnedChatBox {
     enableScrollRegion() {
         if (this.scrollRegionActive || !this.supportsRendering())
             return;
+        // Make sure reserved height matches current content/terminal width
+        this.updateReservedLinesForContent();
         const rows = this.writeStream.rows || 24;
         const scrollBottom = rows - this.reservedLines;
         // Step 1: Set scroll region (excludes bottom reserved lines)
         this.safeWrite(ANSI.SET_SCROLL_REGION(1, scrollBottom));
+        // Invalidate render state to ensure fresh render in the new scroll region
+        this.invalidateRenderedState();
         // Step 2: Render the prompt in the protected bottom area
         this.renderPersistentInput();
         // Mark scroll region as active AFTER rendering
@@ -344,14 +354,52 @@ export class PinnedChatBox {
         // Move cursor to the end of the terminal
         this.safeWrite(ANSI.CURSOR_TO_BOTTOM(rows));
     }
+    /**
+     * Check if render is needed by comparing with last rendered state.
+     * Returns true if content, cursor, or terminal size has changed.
+     */
+    needsRender() {
+        const rows = this.writeStream.rows || 24;
+        const cols = this.writeStream.columns || 80;
+        // Check if anything changed that requires a re-render
+        if (this.inputBuffer !== this.lastRenderedContent)
+            return true;
+        if (this.cursorPosition !== this.lastRenderedCursor)
+            return true;
+        if (rows !== this.lastRenderedRows)
+            return true;
+        if (cols !== this.lastRenderedCols)
+            return true;
+        return false;
+    }
+    /**
+     * Update last rendered state after successful render.
+     */
+    updateRenderedState() {
+        this.lastRenderedContent = this.inputBuffer;
+        this.lastRenderedCursor = this.cursorPosition;
+        this.lastRenderedRows = this.writeStream.rows || 24;
+        this.lastRenderedCols = this.writeStream.columns || 80;
+    }
+    /**
+     * Reset rendered state to force next render.
+     */
+    invalidateRenderedState() {
+        this.lastRenderedContent = '';
+        this.lastRenderedCursor = -1;
+        this.lastRenderedRows = 0;
+        this.lastRenderedCols = 0;
+    }
     /**
      * Render the persistent input area at the bottom of the terminal.
      *
      * CLEAN CLAUDE CODE STYLE:
      * - Line 1: Simple separator with optional queue count
-     * - Line 2: Clean prompt "> " with input and visible block cursor
+     * - Line 2+: Clean prompt "> " with input and visible block cursor
      *
      * Key for clean rendering:
+     * - Render deduplication via content/cursor comparison
+     * - Render lock to prevent concurrent renders
      * - Hide cursor during render (prevents flicker)
      * - Clear lines completely before writing
      * - Reset styles explicitly
@@ -361,63 +409,105 @@ export class PinnedChatBox {
     renderPersistentInput() {
         if (!this.supportsRendering())
             return;
-        const rows = this.writeStream.rows || 24;
-        const cols = Math.max(this.writeStream.columns || 80, 40);
-        // ANSI codes - keep simple, no theme functions
-        const HIDE_CURSOR = '\x1b[?25l';
-        const SHOW_CURSOR = '\x1b[?25h';
-        const REVERSE_VIDEO = '\x1b[7m';
-        const RESET = '\x1b[0m';
-        const DIM = '\x1b[2m';
-        // Hide cursor during render
-        this.safeWrite(HIDE_CURSOR);
-        this.safeWrite(RESET);
-        // Line 1: Separator (at row N-1)
-        this.safeWrite(ANSI.CURSOR_TO_BOTTOM(rows - 1));
-        this.safeWrite(ANSI.CLEAR_LINE);
-        const separatorWidth = Math.min(cols - 2, 60);
-        this.safeWrite(DIM);
-        this.safeWrite('─'.repeat(separatorWidth));
-        this.safeWrite(RESET);
-        // Queue count hint if processing
-        const queueCount = this.state.queuedCommands.length;
-        if (this.state.isProcessing && queueCount > 0) {
+        // Render lock - prevent concurrent renders that cause flicker
+        if (this.isRendering)
+            return;
+        // Deduplication - skip if nothing changed
+        if (!this.needsRender())
+            return;
+        this.isRendering = true;
+        try {
+            const { rows, cols, maxInputWidth } = this.getRenderDimensions();
+            // ANSI codes - keep simple, no theme functions
+            const HIDE_CURSOR = '\x1b[?25l';
+            const SHOW_CURSOR = '\x1b[?25h';
+            const REVERSE_VIDEO = '\x1b[7m';
+            const RESET = '\x1b[0m';
+            const DIM = '\x1b[2m';
+            // Hide cursor during render
+            this.safeWrite(HIDE_CURSOR);
+            this.safeWrite(RESET);
+            // Wrap input into terminal-safe lines so long text doesn't overflow
+            const { lines: wrappedLines, cursorLine: cursorLineIndex, cursorCol: cursorColInLine } = this.wrapInputBuffer(maxInputWidth);
+            const totalInputLines = Math.max(1, wrappedLines.length);
+            const displayLineCount = Math.min(totalInputLines, this.maxDisplayLines);
+            // Keep reserved height in sync with what we need to show
+            this.updateReservedLinesForContent(maxInputWidth, totalInputLines);
+            // Find cursor position: which line and column
+            let displayStartLine = 0;
+            if (totalInputLines > displayLineCount) {
+                displayStartLine = Math.max(0, cursorLineIndex - displayLineCount + 1);
+                displayStartLine = Math.min(displayStartLine, totalInputLines - displayLineCount);
+            }
+            const linesToShow = wrappedLines.slice(displayStartLine, displayStartLine + displayLineCount);
+            // Move to the start of reserved area
+            const reservedStart = rows - this.reservedLines + 1;
+            this.safeWrite(ANSI.CURSOR_TO_BOTTOM(reservedStart));
+            this.safeWrite(ANSI.CLEAR_LINE);
+            // Line 1: Separator
+            const separatorWidth = Math.min(cols - 2, 60);
             this.safeWrite(DIM);
-            this.safeWrite(`  ${queueCount} queued`);
+            this.safeWrite('─'.repeat(separatorWidth));
             this.safeWrite(RESET);
-        }
-        // Line 2: Prompt (at row N)
-        this.safeWrite(ANSI.CURSOR_TO_BOTTOM(rows));
-        this.safeWrite(ANSI.CLEAR_LINE);
-        const promptPrefix = '> ';
-        const maxInputWidth = cols - 5;
-        const input = this.inputBuffer;
-        const cursorPos = Math.min(this.cursorPosition, input.length);
-        // Handle long input
-        let displayStart = 0;
-        let displayInput = input;
-        if (input.length > maxInputWidth) {
-            if (cursorPos > maxInputWidth - 5) {
-                displayStart = cursorPos - maxInputWidth + 5;
+            // Status hints (line count, queue count)
+            const queueCount = this.state.queuedCommands.length;
+            const hints = [];
+            if (totalInputLines > 1) {
+                hints.push(`${totalInputLines} lines`);
+            }
+            if (this.state.isProcessing && queueCount > 0) {
+                hints.push(`${queueCount} queued`);
+            }
+            if (hints.length > 0) {
+                this.safeWrite(DIM);
+                this.safeWrite('  ' + hints.join(' • '));
+                this.safeWrite(RESET);
             }
-            displayInput = input.slice(displayStart, displayStart + maxInputWidth);
+            let finalCursorRow = reservedStart + 1;
+            let finalCursorCol = 3;
+            // Render each input line
+            for (let lineIdx = 0; lineIdx < linesToShow.length; lineIdx++) {
+                this.safeWrite('\n');
+                this.safeWrite(ANSI.CLEAR_LINE);
+                const line = linesToShow[lineIdx] ?? '';
+                const absoluteLineIdx = displayStartLine + lineIdx;
+                const isFirstLine = absoluteLineIdx === 0;
+                const isCursorLine = absoluteLineIdx === cursorLineIndex;
+                // Prompt prefix: ">" for first line, "│" for continuation lines
+                this.safeWrite(DIM);
+                this.safeWrite(isFirstLine ? '>' : '│');
+                this.safeWrite(RESET);
+                this.safeWrite(' ');
+                if (isCursorLine) {
+                    // Render line with cursor
+                    const displayCursorCol = Math.max(0, cursorColInLine);
+                    const beforeCursor = line.slice(0, displayCursorCol);
+                    const atCursor = line[displayCursorCol] ?? ' ';
+                    const afterCursor = line.slice(displayCursorCol + 1);
+                    this.safeWrite(beforeCursor);
+                    this.safeWrite(REVERSE_VIDEO);
+                    this.safeWrite(atCursor);
+                    this.safeWrite(RESET);
+                    this.safeWrite(afterCursor);
+                    // Remember cursor position for final positioning
+                    finalCursorRow = reservedStart + 1 + lineIdx;
+                    finalCursorCol = 3 + displayCursorCol;
+                }
+                else {
+                    // Render line without cursor
+                    this.safeWrite(line);
+                }
+            }
+            // Position terminal cursor and show it
+            this.safeWrite(ANSI.CURSOR_TO_BOTTOM(finalCursorRow));
+            this.safeWrite(ANSI.MOVE_TO_COL(finalCursorCol));
+            this.safeWrite(SHOW_CURSOR);
+            // Update rendered state for deduplication
+            this.updateRenderedState();
+        }
+        finally {
+            this.isRendering = false;
         }
-        const displayCursorPos = cursorPos - displayStart;
-        // Write prompt
-        this.safeWrite(promptPrefix);
-        // Text before cursor
-        this.safeWrite(displayInput.slice(0, displayCursorPos));
-        // Cursor block (reverse video)
-        const atCursor = displayInput[displayCursorPos] || ' ';
-        this.safeWrite(REVERSE_VIDEO);
-        this.safeWrite(atCursor);
-        this.safeWrite(RESET);
-        // Text after cursor
-        this.safeWrite(displayInput.slice(displayCursorPos + 1));
-        // Position terminal cursor and show it
-        const terminalCursorCol = promptPrefix.length + displayCursorPos + 1;
-        this.safeWrite(ANSI.MOVE_TO_COL(terminalCursorCol));
-        this.safeWrite(SHOW_CURSOR);
     }
     /**
      * Update the persistent input during streaming.
@@ -476,10 +566,13 @@ export class PinnedChatBox {
         return withoutAnsi.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
     }
     /**
-     * Sanitize queued command text (trimmed, single line)
+     * Sanitize queued command text (trimmed, preserves newlines)
      */
     sanitizeCommandText(text) {
-        return this.sanitizeInlineText(text).trim();
+        if (!text)
+            return '';
+        const clean = this.sanitizeMultilineForDisplay(text);
+        return clean.slice(0, this.maxInputLength).trim();
     }
     /**
      * Sanitize status message (single line, bounded length)
@@ -492,6 +585,56 @@ export class PinnedChatBox {
             return null;
         return clean.slice(0, this.maxStatusMessageLength);
     }
+    /**
+     * Clear paste-specific state when the user edits the buffer manually.
+     * Prevents us from sending stale paste content after edits.
+     */
+    startManualEdit() {
+        if (this.isPastedBlock) {
+            this.clearPastedBlock();
+        }
+    }
+    /**
+     * Apply a new buffer/cursor position and trigger downstream updates.
+     */
+    applyBufferChange(buffer, cursorPos) {
+        this.inputBuffer = buffer;
+        const nextCursor = typeof cursorPos === 'number' ? cursorPos : buffer.length;
+        this.cursorPosition = Math.max(0, Math.min(nextCursor, this.inputBuffer.length));
+        this.state.currentInput = this.inputBuffer;
+        this.updateReservedLinesForContent();
+        this.scheduleRender();
+    }
+    /**
+     * Treat spaces, tabs, and newlines as whitespace for navigation helpers.
+     */
+    isWhitespace(char) {
+        return char === ' ' || char === '\t' || char === '\n';
+    }
+    /**
+     * Update cursor position while keeping it in bounds and re-rendering.
+     */
+    setCursorPosition(position) {
+        this.cursorPosition = Math.max(0, Math.min(position, this.inputBuffer.length));
+        this.scheduleRender();
+    }
+    /**
+     * Insert multi-line content directly into the buffer (manual typing).
+     */
+    insertMultilineText(text) {
+        const sanitized = this.sanitizeMultilineForDisplay(text);
+        if (!sanitized)
+            return;
+        // Respect max input length
+        const availableSpace = this.maxInputLength - this.inputBuffer.length;
+        if (availableSpace <= 0)
+            return;
+        const chunk = sanitized.slice(0, availableSpace);
+        this.startManualEdit();
+        this.applyBufferChange(this.inputBuffer.slice(0, this.cursorPosition) +
+            chunk +
+            this.inputBuffer.slice(this.cursorPosition), this.cursorPosition + chunk.length);
+    }
     /**
      * Safely write to the output stream, swallowing non-fatal errors
      */
@@ -590,7 +733,8 @@ export class PinnedChatBox {
         }
         // Sanitize and truncate command text
         const truncated = sanitizedText.slice(0, this.maxInputLength);
-        const preview = truncated.length > 60 ? `${truncated.slice(0, 57)}...` : truncated;
+        const previewSource = this.sanitizeInlineText(truncated);
+        const preview = previewSource.length > 60 ? `${previewSource.slice(0, 57)}...` : previewSource;
         const cmd = {
             id: `cmd-${++this.commandIdCounter}`,
             text: truncated,
@@ -646,14 +790,25 @@ export class PinnedChatBox {
      * Handle character input with validation
      * Detects multiline paste and stores full content while showing summary
      */
-    handleInput(char) {
+    handleInput(char, options = {}) {
         if (!this.isEnabled || this.isDisposed)
             return;
         if (typeof char !== 'string')
             return;
-        // Detect multiline paste (content with newlines)
-        if (char.includes('\n') || char.includes('\r')) {
-            this.handleMultilinePaste(char);
+        const allowNewlines = options.allowNewlines ?? options.isPaste ?? false;
+        const hasNewline = char.includes('\n') || char.includes('\r');
+        const shouldHandleAsPaste = options.isPaste || (allowNewlines && hasNewline);
+        // Detect paste explicitly or any newline-containing input when allowed
+        if (shouldHandleAsPaste) {
+            if (options.isPaste) {
+                this.handleMultilinePaste(char);
+                return;
+            }
+            this.insertMultilineText(char);
+            return;
+        }
+        // Ignore unexpected newlines unless explicitly allowed
+        if (hasNewline) {
             return;
         }
         const sanitized = this.sanitizeInlineText(char);
@@ -667,13 +822,10 @@ export class PinnedChatBox {
         if (!chunk)
             return;
         // Insert character at cursor position
-        this.inputBuffer =
-            this.inputBuffer.slice(0, this.cursorPosition) +
-                chunk +
-                this.inputBuffer.slice(this.cursorPosition);
-        this.cursorPosition = Math.min(this.cursorPosition + chunk.length, this.inputBuffer.length);
-        this.state.currentInput = this.inputBuffer;
-        this.scheduleRender();
+        this.startManualEdit();
+        this.applyBufferChange(this.inputBuffer.slice(0, this.cursorPosition) +
+            chunk +
+            this.inputBuffer.slice(this.cursorPosition), this.cursorPosition + chunk.length);
     }
     /**
      * Handle multiline paste - store full content and display all lines
@@ -681,15 +833,13 @@ export class PinnedChatBox {
     handleMultilinePaste(content) {
         // Keep the original content for submission
         const displaySafeContent = this.sanitizeMultilineForDisplay(content);
-        this.pastedFullContent = content;
+        if (!displaySafeContent)
+            return;
+        const truncatedDisplay = displaySafeContent.slice(0, this.maxInputLength);
+        const truncatedOriginal = content.slice(0, this.maxInputLength);
+        this.pastedFullContent = truncatedOriginal;
         this.isPastedBlock = true;
-        // Store the full content for display (not just a summary)
-        this.inputBuffer = displaySafeContent;
-        this.cursorPosition = displaySafeContent.length;
-        this.state.currentInput = displaySafeContent;
-        // Update reserved lines based on content
-        this.updateReservedLinesForContent();
-        this.scheduleRender();
+        this.applyBufferChange(truncatedDisplay, truncatedDisplay.length);
     }
     /**
      * Public helper for routing external multi-line pastes directly into the chat box
@@ -723,37 +873,88 @@ export class PinnedChatBox {
      */
     clearPastedBlockState() {
         this.clearPastedBlock();
-        this.inputBuffer = '';
-        this.cursorPosition = 0;
-        this.state.currentInput = '';
-        this.resetReservedLines();
+        this.applyBufferChange('', 0);
     }
     /**
-     * Calculate and update reserved lines based on current input content.
-     * Ensures multi-line content is fully visible within maxDisplayLines limit.
+     * Get terminal dimensions and a safe width for rendering input content.
      */
-    updateReservedLinesForContent() {
-        const lines = this.inputBuffer.split('\n');
-        const lineCount = lines.length;
-        // Calculate needed lines: 1 for separator + lineCount for input (clamped to maxDisplayLines)
-        const inputLines = Math.min(lineCount, this.maxDisplayLines);
-        this.reservedLines = 1 + inputLines; // 1 separator + input lines
-        // If we have a scroll region active, update it
-        if (this.scrollRegionActive) {
-            const rows = this.writeStream.rows || 24;
-            const scrollBottom = rows - this.reservedLines;
-            this.safeWrite(ANSI.SET_SCROLL_REGION(1, scrollBottom));
+    getRenderDimensions() {
+        const rows = this.writeStream.rows || 24;
+        const cols = Math.max(this.writeStream.columns || 80, 40);
+        // Leave a small gutter for prefix + padding so we never wrap unexpectedly
+        const maxInputWidth = Math.max(10, cols - 5);
+        return { rows, cols, maxInputWidth };
+    }
+    /**
+     * Wrap the current input buffer to the provided width and locate the cursor.
+     */
+    wrapInputBuffer(maxInputWidth) {
+        const width = Math.max(1, maxInputWidth);
+        const rawLines = this.inputBuffer.split('\n');
+        const wrappedLines = [];
+        const targetCursor = Math.max(0, Math.min(this.cursorPosition, this.inputBuffer.length));
+        let cursorLine = 0;
+        let cursorCol = 0;
+        let absoluteIndex = 0;
+        for (let i = 0; i < rawLines.length; i++) {
+            const raw = rawLines[i] ?? '';
+            if (raw.length === 0) {
+                // Preserve empty lines so vertical space stays accurate
+                wrappedLines.push('');
+                if (targetCursor === absoluteIndex) {
+                    cursorLine = wrappedLines.length - 1;
+                    cursorCol = 0;
+                }
+            }
+            else {
+                for (let start = 0; start < raw.length; start += width) {
+                    const segment = raw.slice(start, start + width);
+                    const segmentStart = absoluteIndex + start;
+                    wrappedLines.push(segment);
+                    if (targetCursor >= segmentStart && targetCursor <= segmentStart + segment.length) {
+                        cursorLine = wrappedLines.length - 1;
+                        cursorCol = targetCursor - segmentStart;
+                    }
+                }
+            }
+            absoluteIndex += raw.length;
+            if (i < rawLines.length - 1) {
+                // Account for the newline character between raw lines
+                if (targetCursor === absoluteIndex) {
+                    cursorLine = wrappedLines.length;
+                    cursorCol = 0;
+                }
+                absoluteIndex += 1;
+            }
+        }
+        if (wrappedLines.length === 0) {
+            wrappedLines.push('');
+            cursorLine = 0;
+            cursorCol = 0;
         }
+        cursorLine = Math.min(cursorLine, wrappedLines.length - 1);
+        cursorCol = Math.min(cursorCol, wrappedLines[cursorLine]?.length ?? 0);
+        return { lines: wrappedLines, cursorLine, cursorCol };
     }
     /**
-     * Reset reserved lines to base value (for single-line input)
+     * Calculate and update reserved lines based on current input content.
+     * Ensures multi-line content is fully visible within maxDisplayLines limit.
      */
-    resetReservedLines() {
-        this.reservedLines = this.baseReservedLines;
+    updateReservedLinesForContent(maxInputWidth, wrappedLineCount) {
+        const { rows, maxInputWidth: derivedWidth } = this.getRenderDimensions();
+        const width = Math.max(1, maxInputWidth ?? derivedWidth);
+        const totalLines = wrappedLineCount ?? this.wrapInputBuffer(width).lines.length;
+        const lineCount = Math.max(1, totalLines);
+        // Calculate needed lines: 1 for separator + lineCount for input (clamped to maxDisplayLines)
+        const inputLines = Math.min(lineCount, this.maxDisplayLines);
+        const calculated = 1 + inputLines; // 1 separator + input lines
+        // Ensure we keep at least one row for output scrolling
+        const maxAllowed = Math.max(1, rows - 1);
+        const desired = Math.max(this.baseReservedLines, calculated);
+        this.reservedLines = Math.min(desired, maxAllowed);
         // If we have a scroll region active, update it
         if (this.scrollRegionActive) {
-            const rows = this.writeStream.rows || 24;
-            const scrollBottom = rows - this.reservedLines;
+            const scrollBottom = Math.max(1, rows - this.reservedLines);
             this.safeWrite(ANSI.SET_SCROLL_REGION(1, scrollBottom));
         }
     }
@@ -766,12 +967,11 @@ export class PinnedChatBox {
         this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
         if (this.cursorPosition === 0)
             return;
-        this.inputBuffer =
-            this.inputBuffer.slice(0, this.cursorPosition - 1) +
-                this.inputBuffer.slice(this.cursorPosition);
-        this.cursorPosition = Math.max(0, this.cursorPosition - 1);
-        this.state.currentInput = this.inputBuffer;
-        this.scheduleRender();
+        const newBuffer = this.inputBuffer.slice(0, this.cursorPosition - 1) +
+            this.inputBuffer.slice(this.cursorPosition);
+        const newCursor = Math.max(0, this.cursorPosition - 1);
+        this.startManualEdit();
+        this.applyBufferChange(newBuffer, newCursor);
     }
     /**
      * Handle delete key
@@ -782,11 +982,10 @@ export class PinnedChatBox {
         this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
         if (this.cursorPosition >= this.inputBuffer.length)
             return;
-        this.inputBuffer =
-            this.inputBuffer.slice(0, this.cursorPosition) +
-                this.inputBuffer.slice(this.cursorPosition + 1);
-        this.state.currentInput = this.inputBuffer;
-        this.scheduleRender();
+        const newBuffer = this.inputBuffer.slice(0, this.cursorPosition) +
+            this.inputBuffer.slice(this.cursorPosition + 1);
+        this.startManualEdit();
+        this.applyBufferChange(newBuffer, this.cursorPosition);
     }
     /**
      * Handle cursor left
@@ -794,10 +993,9 @@ export class PinnedChatBox {
     handleCursorLeft() {
         if (this.isDisposed)
             return;
-        this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
-        if (this.cursorPosition > 0) {
-            this.cursorPosition--;
-            this.scheduleRender();
+        const bounded = Math.min(this.cursorPosition, this.inputBuffer.length);
+        if (bounded > 0) {
+            this.setCursorPosition(bounded - 1);
         }
     }
     /**
@@ -806,36 +1004,103 @@ export class PinnedChatBox {
     handleCursorRight() {
         if (this.isDisposed)
             return;
-        this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
-        if (this.cursorPosition < this.inputBuffer.length) {
-            this.cursorPosition++;
-            this.scheduleRender();
+        const bounded = Math.min(this.cursorPosition, this.inputBuffer.length);
+        if (bounded < this.inputBuffer.length) {
+            this.setCursorPosition(bounded + 1);
         }
     }
     /**
-     * Handle home key
+     * Handle home key - move to start of current line (not start of buffer)
      */
     handleHome() {
         if (this.isDisposed)
             return;
-        this.cursorPosition = 0;
-        this.scheduleRender();
+        // In multi-line mode, move to start of current line
+        const { lineIndex, lines } = this.getCursorLinePosition();
+        // Calculate position at start of current line
+        let newPos = 0;
+        for (let i = 0; i < lineIndex; i++) {
+            newPos += (lines[i] ?? '').length + 1;
+        }
+        this.setCursorPosition(newPos);
     }
     /**
-     * Handle end key (Ctrl+E)
+     * Handle end key (Ctrl+E) - move to end of current line (not end of buffer)
      */
     handleEnd() {
         if (this.isDisposed)
             return;
-        this.cursorPosition = this.inputBuffer.length;
-        this.scheduleRender();
+        // In multi-line mode, move to end of current line
+        const { lineIndex, lines } = this.getCursorLinePosition();
+        const currentLine = lines[lineIndex] ?? '';
+        // Calculate position at end of current line
+        let newPos = 0;
+        for (let i = 0; i < lineIndex; i++) {
+            newPos += (lines[i] ?? '').length + 1;
+        }
+        newPos += currentLine.length;
+        this.setCursorPosition(newPos);
+    }
+    /**
+     * Handle inserting a newline character at cursor position (Shift+Enter or Option+Enter)
+     */
+    handleNewline() {
+        if (!this.isEnabled || this.isDisposed)
+            return;
+        // Respect max input length
+        if (this.inputBuffer.length >= this.maxInputLength)
+            return;
+        this.startManualEdit();
+        this.applyBufferChange(this.inputBuffer.slice(0, this.cursorPosition) +
+            '\n' +
+            this.inputBuffer.slice(this.cursorPosition), this.cursorPosition + 1);
+    }
+    /**
+     * Get cursor line and column position within multi-line content.
+     */
+    getCursorLinePosition() {
+        const lines = this.inputBuffer.split('\n');
+        let charCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const lineLen = (lines[i] ?? '').length;
+            if (charCount + lineLen >= this.cursorPosition) {
+                return {
+                    lineIndex: i,
+                    colInLine: this.cursorPosition - charCount,
+                    lines,
+                };
+            }
+            charCount += lineLen + 1; // +1 for newline
+        }
+        // Cursor at end
+        return {
+            lineIndex: lines.length - 1,
+            colInLine: (lines[lines.length - 1] ?? '').length,
+            lines,
+        };
     }
     /**
-     * Handle up arrow - navigate to previous history entry
+     * Handle up arrow - move cursor up in multi-line content, or navigate history if on first line
      */
     handleHistoryUp() {
         if (this.isDisposed)
             return;
+        // For multi-line content, move cursor up within content first
+        const { lineIndex, colInLine, lines } = this.getCursorLinePosition();
+        if (lineIndex > 0) {
+            // Move cursor to previous line, keeping column position if possible
+            const prevLine = lines[lineIndex - 1] ?? '';
+            const newCol = Math.min(colInLine, prevLine.length);
+            // Calculate new cursor position
+            let newPos = 0;
+            for (let i = 0; i < lineIndex - 1; i++) {
+                newPos += (lines[i] ?? '').length + 1;
+            }
+            newPos += newCol;
+            this.setCursorPosition(newPos);
+            return;
+        }
+        // On first line - navigate history
         if (this.inputHistory.length === 0)
             return;
         // If at current input, save it temporarily
@@ -845,33 +1110,46 @@ export class PinnedChatBox {
         // Move up in history
         if (this.historyIndex < this.inputHistory.length - 1) {
             this.historyIndex++;
-            this.inputBuffer = this.inputHistory[this.inputHistory.length - 1 - this.historyIndex] || '';
-            this.cursorPosition = this.inputBuffer.length;
-            this.state.currentInput = this.inputBuffer;
-            this.scheduleRender();
+            const nextBuffer = this.inputHistory[this.inputHistory.length - 1 - this.historyIndex] || '';
+            this.startManualEdit();
+            this.applyBufferChange(nextBuffer, nextBuffer.length);
         }
     }
     /**
-     * Handle down arrow - navigate to next history entry
+     * Handle down arrow - move cursor down in multi-line content, or navigate history if on last line
      */
     handleHistoryDown() {
         if (this.isDisposed)
             return;
+        // For multi-line content, move cursor down within content first
+        const { lineIndex, colInLine, lines } = this.getCursorLinePosition();
+        if (lineIndex < lines.length - 1) {
+            // Move cursor to next line, keeping column position if possible
+            const nextLine = lines[lineIndex + 1] ?? '';
+            const newCol = Math.min(colInLine, nextLine.length);
+            // Calculate new cursor position
+            let newPos = 0;
+            for (let i = 0; i <= lineIndex; i++) {
+                newPos += (lines[i] ?? '').length + 1;
+            }
+            newPos += newCol;
+            this.setCursorPosition(newPos);
+            return;
+        }
+        // On last line - navigate history
         if (this.historyIndex > 0) {
             // Move down in history
             this.historyIndex--;
-            this.inputBuffer = this.inputHistory[this.inputHistory.length - 1 - this.historyIndex] || '';
-            this.cursorPosition = this.inputBuffer.length;
-            this.state.currentInput = this.inputBuffer;
-            this.scheduleRender();
+            const nextBuffer = this.inputHistory[this.inputHistory.length - 1 - this.historyIndex] || '';
+            this.startManualEdit();
+            this.applyBufferChange(nextBuffer, nextBuffer.length);
         }
         else if (this.historyIndex === 0) {
             // Return to current input
             this.historyIndex = -1;
-            this.inputBuffer = this.tempCurrentInput;
-            this.cursorPosition = this.inputBuffer.length;
-            this.state.currentInput = this.inputBuffer;
-            this.scheduleRender();
+            const restored = this.tempCurrentInput;
+            this.startManualEdit();
+            this.applyBufferChange(restored, restored.length);
         }
     }
     /**
@@ -882,10 +1160,9 @@ export class PinnedChatBox {
             return;
         if (this.cursorPosition === 0)
             return;
-        this.inputBuffer = this.inputBuffer.slice(this.cursorPosition);
-        this.cursorPosition = 0;
-        this.state.currentInput = this.inputBuffer;
-        this.scheduleRender();
+        this.startManualEdit();
+        const newBuffer = this.inputBuffer.slice(this.cursorPosition);
+        this.applyBufferChange(newBuffer, 0);
     }
     /**
      * Handle Ctrl+K - delete from cursor to end of line
@@ -895,9 +1172,9 @@ export class PinnedChatBox {
             return;
         if (this.cursorPosition >= this.inputBuffer.length)
             return;
-        this.inputBuffer = this.inputBuffer.slice(0, this.cursorPosition);
-        this.state.currentInput = this.inputBuffer;
-        this.scheduleRender();
+        this.startManualEdit();
+        const newBuffer = this.inputBuffer.slice(0, this.cursorPosition);
+        this.applyBufferChange(newBuffer, this.cursorPosition);
     }
     /**
      * Handle Ctrl+W - delete word before cursor
@@ -910,17 +1187,16 @@ export class PinnedChatBox {
         // Find the start of the word (skip trailing spaces, then find word boundary)
         let pos = this.cursorPosition;
         // Skip any spaces before cursor
-        while (pos > 0 && this.inputBuffer[pos - 1] === ' ') {
+        while (pos > 0 && this.isWhitespace(this.inputBuffer[pos - 1])) {
             pos--;
         }
         // Find start of word
-        while (pos > 0 && this.inputBuffer[pos - 1] !== ' ') {
+        while (pos > 0 && !this.isWhitespace(this.inputBuffer[pos - 1])) {
             pos--;
         }
-        this.inputBuffer = this.inputBuffer.slice(0, pos) + this.inputBuffer.slice(this.cursorPosition);
-        this.cursorPosition = pos;
-        this.state.currentInput = this.inputBuffer;
-        this.scheduleRender();
+        const newBuffer = this.inputBuffer.slice(0, pos) + this.inputBuffer.slice(this.cursorPosition);
+        this.startManualEdit();
+        this.applyBufferChange(newBuffer, pos);
     }
     /**
      * Handle Alt+Left - move cursor to previous word
@@ -932,15 +1208,14 @@ export class PinnedChatBox {
             return;
         let pos = this.cursorPosition;
         // Skip any spaces before cursor
-        while (pos > 0 && this.inputBuffer[pos - 1] === ' ') {
+        while (pos > 0 && this.isWhitespace(this.inputBuffer[pos - 1])) {
             pos--;
         }
         // Find start of word
-        while (pos > 0 && this.inputBuffer[pos - 1] !== ' ') {
+        while (pos > 0 && !this.isWhitespace(this.inputBuffer[pos - 1])) {
             pos--;
         }
-        this.cursorPosition = pos;
-        this.scheduleRender();
+        this.setCursorPosition(pos);
     }
     /**
      * Handle Alt+Right - move cursor to next word
@@ -952,15 +1227,14 @@ export class PinnedChatBox {
             return;
         let pos = this.cursorPosition;
         // Skip current word
-        while (pos < this.inputBuffer.length && this.inputBuffer[pos] !== ' ') {
+        while (pos < this.inputBuffer.length && !this.isWhitespace(this.inputBuffer[pos])) {
             pos++;
         }
         // Skip any spaces
-        while (pos < this.inputBuffer.length && this.inputBuffer[pos] === ' ') {
+        while (pos < this.inputBuffer.length && this.isWhitespace(this.inputBuffer[pos])) {
             pos++;
         }
-        this.cursorPosition = pos;
-        this.scheduleRender();
+        this.setCursorPosition(pos);
     }
     /**
      * Add input to history (call after successful submit)
@@ -1027,15 +1301,12 @@ export class PinnedChatBox {
     clearInput() {
         if (this.isDisposed)
             return;
-        this.inputBuffer = '';
-        this.cursorPosition = 0;
-        this.state.currentInput = '';
         // Reset history navigation
         this.historyIndex = -1;
         this.tempCurrentInput = '';
         // Clear paste state
         this.clearPastedBlock();
-        this.scheduleRender();
+        this.applyBufferChange('', 0);
     }
     /**
      * Set input text and optionally cursor position (for readline sync)
@@ -1044,13 +1315,14 @@ export class PinnedChatBox {
     setInput(text, cursorPos) {
         if (this.isDisposed)
             return;
-        const normalized = this.sanitizeInlineText(text).slice(0, this.maxInputLength);
+        const normalized = this.sanitizeMultilineForDisplay(text).slice(0, this.maxInputLength);
         this.inputBuffer = normalized;
         // Use provided cursor position, or default to end of input
         this.cursorPosition = typeof cursorPos === 'number'
             ? Math.max(0, Math.min(cursorPos, normalized.length))
             : normalized.length;
         this.state.currentInput = normalized;
+        this.updateReservedLinesForContent();
         // Do NOT schedule render here - readline handles display during input
         // render() will only work when isProcessing=true anyway
     }
@@ -1183,10 +1455,18 @@ export class PinnedChatBox {
      * Handle terminal resize - update scroll region if active
      */
     handleResize() {
-        if (this.scrollRegionActive) {
-            // Reset and re-enable scroll region with new dimensions
+        // Invalidate render state to force re-render with new dimensions
+        this.invalidateRenderedState();
+        const wasActive = this.scrollRegionActive;
+        if (wasActive) {
+            // Reset scroll region before recalculating dimensions
             this.safeWrite(ANSI.RESET_SCROLL_REGION);
             this.scrollRegionActive = false;
+        }
+        // Recompute reserved lines for the new terminal size
+        this.updateReservedLinesForContent();
+        if (wasActive) {
+            // Re-enable scroll region with the updated height
             this.enableScrollRegion();
         }
         this.scheduleRender();
@@ -1239,13 +1519,14 @@ export class PinnedChatBox {
         return !this.isDisposed && this.isEnabled;
     }
     /**
-     * Force immediate render (bypass throttling)
+     * Force immediate render (bypass throttling and deduplication)
      */
     forceRender() {
         if (this.isDisposed)
             return;
         this.lastRenderTime = 0;
         this.renderScheduled = false;
+        this.invalidateRenderedState(); // Force re-render even if content unchanged
         this.render();
     }
     /**
@@ -1264,6 +1545,7 @@ export class PinnedChatBox {
             statusMessage: null,
             isVisible: true,
         };
+        this.invalidateRenderedState();
         this.scheduleRender();
     }
 }