erosolar-cli 1.7.185 → 1.7.188

package/dist/ui/persistentPrompt.js

@@ -317,6 +317,8 @@ 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)
@@ -415,8 +417,7 @@ export class PinnedChatBox {
             return;
         this.isRendering = true;
         try {
-            const rows = this.writeStream.rows || 24;
-            const cols = Math.max(this.writeStream.columns || 80, 40);
+            const { rows, cols, maxInputWidth } = this.getRenderDimensions();
             // ANSI codes - keep simple, no theme functions
             const HIDE_CURSOR = '\x1b[?25l';
             const SHOW_CURSOR = '\x1b[?25h';
@@ -426,44 +427,25 @@ export class PinnedChatBox {
             // Hide cursor during render
             this.safeWrite(HIDE_CURSOR);
             this.safeWrite(RESET);
-            // Split input into lines for multi-line support
-            const inputLines = this.inputBuffer.split('\n');
-            const totalInputLines = inputLines.length;
+            // 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 cursorLineIndex = 0;
-            let cursorColInLine = 0;
-            let charCount = 0;
-            for (let i = 0; i < inputLines.length; i++) {
-                const currentLine = inputLines[i] ?? '';
-                const lineLen = currentLine.length;
-                if (charCount + lineLen >= this.cursorPosition) {
-                    cursorLineIndex = i;
-                    cursorColInLine = this.cursorPosition - charCount;
-                    break;
-                }
-                charCount += lineLen + 1; // +1 for newline
-                if (i === inputLines.length - 1) {
-                    cursorLineIndex = i;
-                    cursorColInLine = currentLine.length;
-                }
-            }
-            // Calculate display window to keep cursor visible
             let displayStartLine = 0;
             if (totalInputLines > displayLineCount) {
-                if (cursorLineIndex >= displayLineCount - 1) {
-                    displayStartLine = cursorLineIndex - displayLineCount + 2;
-                }
+                displayStartLine = Math.max(0, cursorLineIndex - displayLineCount + 1);
                 displayStartLine = Math.min(displayStartLine, totalInputLines - displayLineCount);
-                displayStartLine = Math.max(0, displayStartLine);
             }
-            const linesToShow = inputLines.slice(displayStartLine, displayStartLine + 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);
+            const separatorWidth = Math.max(1, Math.min(cols - 2, 60));
             this.safeWrite(DIM);
             this.safeWrite('─'.repeat(separatorWidth));
             this.safeWrite(RESET);
@@ -481,7 +463,6 @@ export class PinnedChatBox {
                 this.safeWrite('  ' + hints.join(' • '));
                 this.safeWrite(RESET);
             }
-            const maxInputWidth = cols - 5;
             let finalCursorRow = reservedStart + 1;
             let finalCursorCol = 3;
             // Render each input line
@@ -497,21 +478,12 @@ export class PinnedChatBox {
                 this.safeWrite(isFirstLine ? '>' : '│');
                 this.safeWrite(RESET);
                 this.safeWrite(' ');
-                // Handle long lines - scroll horizontally to keep cursor visible
-                let displayStart = 0;
-                let displayLine = line;
-                if (line.length > maxInputWidth) {
-                    if (isCursorLine && cursorColInLine > maxInputWidth - 5) {
-                        displayStart = cursorColInLine - maxInputWidth + 5;
-                    }
-                    displayLine = line.slice(displayStart, displayStart + maxInputWidth);
-                }
                 if (isCursorLine) {
                     // Render line with cursor
-                    const displayCursorCol = Math.max(0, cursorColInLine - displayStart);
-                    const beforeCursor = displayLine.slice(0, displayCursorCol);
-                    const atCursor = displayLine[displayCursorCol] ?? ' ';
-                    const afterCursor = displayLine.slice(displayCursorCol + 1);
+                    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);
@@ -523,12 +495,12 @@ export class PinnedChatBox {
                 }
                 else {
                     // Render line without cursor
-                    this.safeWrite(displayLine);
+                    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(ANSI.MOVE_TO_COL(Math.max(1, Math.min(finalCursorCol, cols))));
             this.safeWrite(SHOW_CURSOR);
             // Update rendered state for deduplication
             this.updateRenderedState();
@@ -594,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)
@@ -630,6 +605,12 @@ export class PinnedChatBox {
         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.
      */
@@ -637,51 +618,6 @@ export class PinnedChatBox {
         this.cursorPosition = Math.max(0, Math.min(position, this.inputBuffer.length));
         this.scheduleRender();
     }
-    /**
-     * Convert the current cursor index into line/column info.
-     */
-    getCursorLineInfo() {
-        const lines = this.inputBuffer.split('\n');
-        let remaining = this.cursorPosition;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i] ?? '';
-            if (remaining <= line.length) {
-                return { lines, lineIndex: i, column: remaining };
-            }
-            remaining -= line.length + 1; // account for newline
-        }
-        // Fallback to last line
-        const lastLine = Math.max(0, lines.length - 1);
-        return { lines, lineIndex: lastLine, column: (lines[lastLine] ?? '').length };
-    }
-    /**
-     * Convert line/column back to a single cursor index.
-     */
-    positionFromLineCol(lines, lineIndex, column) {
-        let pos = 0;
-        for (let i = 0; i < lineIndex; i++) {
-            pos += (lines[i] ?? '').length + 1; // +1 for newline
-        }
-        return pos + column;
-    }
-    /**
-     * Move cursor vertically within a multi-line buffer.
-     * Returns true if a movement occurred.
-     */
-    moveCursorVertical(direction) {
-        const info = this.getCursorLineInfo();
-        if (info.lines.length <= 1) {
-            return false;
-        }
-        const targetLine = info.lineIndex + direction;
-        if (targetLine < 0 || targetLine >= info.lines.length) {
-            return false;
-        }
-        const targetCol = Math.min(info.column, (info.lines[targetLine] ?? '').length);
-        const newPos = this.positionFromLineCol(info.lines, targetLine, targetCol);
-        this.setCursorPosition(newPos);
-        return true;
-    }
     /**
      * Insert multi-line content directly into the buffer (manual typing).
      */
@@ -797,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,
@@ -853,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);
@@ -874,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
@@ -928,37 +873,134 @@ 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(10, this.writeStream.columns ?? 80);
+        // Leave a small gutter for prefix + padding so we never wrap unexpectedly,
+        // but respect the actual terminal width instead of forcing a wide minimum.
+        const maxInputWidth = Math.max(8, cols - 5);
+        return { rows, cols, maxInputWidth };
+    }
+    /**
+     * Wrap the current input buffer to the provided width and locate the cursor.
+     *
+     * ROBUST CURSOR TRACKING:
+     * - Uses cursorFound flag to ensure cursor is explicitly located
+     * - Falls back to direct calculation if normal tracking fails
+     * - Handles edge cases: empty input, cursor at end, cursor at newlines
+     */
+    wrapInputBuffer(maxInputWidth) {
+        const width = Math.max(1, maxInputWidth);
+        const wrappedLines = [];
+        const lineStarts = [];
+        const targetCursor = Math.max(0, Math.min(this.cursorPosition, this.inputBuffer.length));
+        // Handle empty buffer case explicitly
+        if (this.inputBuffer.length === 0) {
+            return { lines: [''], cursorLine: 0, cursorCol: 0, lineStarts: [0] };
+        }
+        let cursorLine = 0;
+        let cursorCol = 0;
+        let cursorFound = false;
+        let absoluteIndex = 0;
+        const rawLines = this.inputBuffer.split('\n');
+        for (let i = 0; i < rawLines.length; i++) {
+            const raw = rawLines[i] ?? '';
+            if (raw.length === 0) {
+                // Preserve empty lines (from newlines)
+                wrappedLines.push('');
+                lineStarts.push(absoluteIndex);
+                // Check if cursor is at this empty line position
+                if (!cursorFound && targetCursor === absoluteIndex) {
+                    cursorLine = wrappedLines.length - 1;
+                    cursorCol = 0;
+                    cursorFound = true;
+                }
+            }
+            else {
+                // Wrap long lines at width boundary
+                for (let start = 0; start < raw.length; start += width) {
+                    const segment = raw.slice(start, start + width);
+                    const segmentStart = absoluteIndex + start;
+                    const segmentEnd = segmentStart + segment.length;
+                    wrappedLines.push(segment);
+                    lineStarts.push(segmentStart);
+                    // Check if cursor falls within this segment (inclusive on both ends)
+                    if (!cursorFound && targetCursor >= segmentStart && targetCursor <= segmentEnd) {
+                        cursorLine = wrappedLines.length - 1;
+                        cursorCol = targetCursor - segmentStart;
+                        cursorFound = true;
+                    }
+                }
+            }
+            absoluteIndex += raw.length;
+            // Account for newline character between raw lines
+            if (i < rawLines.length - 1) {
+                // Check if cursor is at the newline position (start of next line)
+                if (!cursorFound && targetCursor === absoluteIndex) {
+                    cursorLine = wrappedLines.length; // Will be the next line index
+                    cursorCol = 0;
+                    cursorFound = true;
+                }
+                absoluteIndex += 1; // Account for '\n'
+            }
         }
+        // Fallback: if cursor wasn't found, calculate directly from position
+        if (!cursorFound && wrappedLines.length > 0) {
+            // Find which wrapped line contains the cursor by checking lineStarts
+            for (let i = lineStarts.length - 1; i >= 0; i--) {
+                const lineStart = lineStarts[i] ?? 0;
+                if (targetCursor >= lineStart) {
+                    cursorLine = i;
+                    cursorCol = targetCursor - lineStart;
+                    break;
+                }
+            }
+        }
+        // Safety: ensure wrappedLines has at least one entry
+        if (wrappedLines.length === 0) {
+            wrappedLines.push('');
+            lineStarts.push(0);
+            cursorLine = 0;
+            cursorCol = 0;
+        }
+        // Safety bounds checks
+        cursorLine = Math.max(0, Math.min(cursorLine, wrappedLines.length - 1));
+        const lineLen = wrappedLines[cursorLine]?.length ?? 0;
+        cursorCol = Math.max(0, Math.min(cursorCol, lineLen));
+        return { lines: wrappedLines, cursorLine, cursorCol, lineStarts };
     }
     /**
-     * Reset reserved lines to base value (for single-line input)
+     * Convert a wrapped line/column back to an absolute cursor index.
      */
-    resetReservedLines() {
-        this.reservedLines = this.baseReservedLines;
+    getWrappedCursorIndex(lineStarts, lineIndex, column) {
+        const start = lineStarts[lineIndex] ?? 0;
+        const safeColumn = Math.max(0, column);
+        return Math.max(0, Math.min(start + safeColumn, this.inputBuffer.length));
+    }
+    /**
+     * Calculate and update reserved lines based on current input content.
+     * Ensures multi-line content is fully visible within maxDisplayLines limit.
+     */
+    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));
         }
     }
@@ -997,10 +1039,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);
         }
     }
     /**
@@ -1009,10 +1050,9 @@ 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);
         }
     }
     /**
@@ -1021,15 +1061,11 @@ export class PinnedChatBox {
     handleHome() {
         if (this.isDisposed)
             return;
-        // 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.cursorPosition = newPos;
-        this.scheduleRender();
+        // In multi-line mode, move to start of the current wrapped line
+        const { maxInputWidth } = this.getRenderDimensions();
+        const { lineStarts, cursorLine } = this.wrapInputBuffer(maxInputWidth);
+        const newPos = this.getWrappedCursorIndex(lineStarts, cursorLine, 0);
+        this.setCursorPosition(newPos);
     }
     /**
      * Handle end key (Ctrl+E) - move to end of current line (not end of buffer)
@@ -1037,17 +1073,12 @@ export class PinnedChatBox {
     handleEnd() {
         if (this.isDisposed)
             return;
-        // 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.cursorPosition = newPos;
-        this.scheduleRender();
+        // In multi-line mode, move to end of the current wrapped line
+        const { maxInputWidth } = this.getRenderDimensions();
+        const { lines: wrappedLines, lineStarts, cursorLine } = this.wrapInputBuffer(maxInputWidth);
+        const currentLine = wrappedLines[cursorLine] ?? '';
+        const newPos = this.getWrappedCursorIndex(lineStarts, cursorLine, currentLine.length);
+        this.setCursorPosition(newPos);
     }
     /**
      * Handle inserting a newline character at cursor position (Shift+Enter or Option+Enter)
@@ -1058,40 +1089,10 @@ export class PinnedChatBox {
         // Respect max input length
         if (this.inputBuffer.length >= this.maxInputLength)
             return;
-        // Insert newline at cursor position
-        this.inputBuffer =
-            this.inputBuffer.slice(0, this.cursorPosition) +
-                '\n' +
-                this.inputBuffer.slice(this.cursorPosition);
-        this.cursorPosition++;
-        this.state.currentInput = this.inputBuffer;
-        // Update reserved lines for the new content
-        this.updateReservedLinesForContent();
-        this.scheduleRender();
-    }
-    /**
-     * 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,
-        };
+        this.startManualEdit();
+        this.applyBufferChange(this.inputBuffer.slice(0, this.cursorPosition) +
+            '\n' +
+            this.inputBuffer.slice(this.cursorPosition), this.cursorPosition + 1);
     }
     /**
      * Handle up arrow - move cursor up in multi-line content, or navigate history if on first line
@@ -1099,21 +1100,14 @@ export class PinnedChatBox {
     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.cursorPosition = newPos;
-            this.state.currentInput = this.inputBuffer;
-            this.scheduleRender();
+        // For multi-line content (including wrapped lines), move cursor up within content first
+        const { maxInputWidth } = this.getRenderDimensions();
+        const { lines: wrappedLines, lineStarts, cursorLine, cursorCol } = this.wrapInputBuffer(maxInputWidth);
+        if (cursorLine > 0) {
+            const prevLine = wrappedLines[cursorLine - 1] ?? '';
+            const newCol = Math.min(cursorCol, prevLine.length);
+            const newPos = this.getWrappedCursorIndex(lineStarts, cursorLine - 1, newCol);
+            this.setCursorPosition(newPos);
             return;
         }
         // On first line - navigate history
@@ -1126,10 +1120,9 @@ 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);
         }
     }
     /**
@@ -1138,39 +1131,30 @@ export class PinnedChatBox {
     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.cursorPosition = newPos;
-            this.state.currentInput = this.inputBuffer;
-            this.scheduleRender();
+        // For multi-line content (including wrapped lines), move cursor down within content first
+        const { maxInputWidth } = this.getRenderDimensions();
+        const { lines: wrappedLines, lineStarts, cursorLine, cursorCol } = this.wrapInputBuffer(maxInputWidth);
+        if (cursorLine < wrappedLines.length - 1) {
+            const nextLine = wrappedLines[cursorLine + 1] ?? '';
+            const newCol = Math.min(cursorCol, nextLine.length);
+            const newPos = this.getWrappedCursorIndex(lineStarts, cursorLine + 1, 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);
         }
     }
     /**
@@ -1181,10 +1165,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
@@ -1194,9 +1177,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
@@ -1209,17 +1192,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
@@ -1231,15 +1213,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
@@ -1251,15 +1232,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)
@@ -1326,15 +1306,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)
@@ -1343,13 +1320,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
     }
@@ -1484,10 +1462,16 @@ export class PinnedChatBox {
     handleResize() {
         // Invalidate render state to force re-render with new dimensions
         this.invalidateRenderedState();
-        if (this.scrollRegionActive) {
-            // Reset and re-enable scroll region with new dimensions
+        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();