erosolar-cli 1.7.185 → 1.7.187

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,38 +427,19 @@ 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));
@@ -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,7 +495,7 @@ export class PinnedChatBox {
                 }
                 else {
                     // Render line without cursor
-                    this.safeWrite(displayLine);
+                    this.safeWrite(line);
                 }
             }
             // Position terminal cursor and show it
@@ -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,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));
         }
     }
@@ -997,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);
         }
     }
     /**
@@ -1009,10 +1004,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);
         }
     }
     /**
@@ -1028,8 +1022,7 @@ export class PinnedChatBox {
         for (let i = 0; i < lineIndex; i++) {
             newPos += (lines[i] ?? '').length + 1;
         }
-        this.cursorPosition = newPos;
-        this.scheduleRender();
+        this.setCursorPosition(newPos);
     }
     /**
      * Handle end key (Ctrl+E) - move to end of current line (not end of buffer)
@@ -1046,8 +1039,7 @@ export class PinnedChatBox {
             newPos += (lines[i] ?? '').length + 1;
         }
         newPos += currentLine.length;
-        this.cursorPosition = newPos;
-        this.scheduleRender();
+        this.setCursorPosition(newPos);
     }
     /**
      * Handle inserting a newline character at cursor position (Shift+Enter or Option+Enter)
@@ -1058,16 +1050,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();
+        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.
@@ -1111,9 +1097,7 @@ export class PinnedChatBox {
                 newPos += (lines[i] ?? '').length + 1;
             }
             newPos += newCol;
-            this.cursorPosition = newPos;
-            this.state.currentInput = this.inputBuffer;
-            this.scheduleRender();
+            this.setCursorPosition(newPos);
             return;
         }
         // On first line - navigate history
@@ -1126,10 +1110,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);
         }
     }
     /**
@@ -1150,27 +1133,23 @@ export class PinnedChatBox {
                 newPos += (lines[i] ?? '').length + 1;
             }
             newPos += newCol;
-            this.cursorPosition = newPos;
-            this.state.currentInput = this.inputBuffer;
-            this.scheduleRender();
+            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 +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
@@ -1194,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
@@ -1209,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
@@ -1231,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
@@ -1251,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)
@@ -1326,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)
@@ -1343,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
     }
@@ -1484,10 +1457,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();