erosolar-cli 1.7.183 → 1.7.185

package/dist/ui/persistentPrompt.js

@@ -215,10 +215,12 @@ const ANSI = {
 export class PinnedChatBox {
     writeStream;
     state;
-    reservedLines = 2; // Lines reserved at bottom for status bar (readline handles input)
+    baseReservedLines = 2; // Base lines reserved (separator + at least 1 input line)
+    reservedLines = 2; // Actual reserved lines (dynamically adjusted for multi-line)
     _lastRenderedHeight = 0;
     inputBuffer = '';
     cursorPosition = 0;
+    maxDisplayLines = 15; // Maximum lines to show in the input area
     commandIdCounter = 0;
     onCommandQueued;
     onInputSubmit;
@@ -232,7 +234,6 @@ export class PinnedChatBox {
     ansiPattern = /[\u001B\u009B][[\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
     oscPattern = /\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g;
     maxStatusMessageLength = 200;
-    maxPastePreviewLength = 60;
     // Scroll region management for persistent bottom input
     scrollRegionActive = false;
     // Input history for up/down navigation
@@ -245,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;
@@ -314,6 +321,8 @@ export class PinnedChatBox {
         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
@@ -343,78 +352,190 @@ 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 status on the right
-     * - Line 2: Clean prompt "> " with input and visible block cursor
-     * - Cursor is rendered as a highlighted block character
+     * - Line 1: Simple separator with optional queue count
+     * - 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
+     * - No theme functions (avoid extra ANSI codes)
+     * - Show cursor at correct position at end
      */
     renderPersistentInput() {
         if (!this.supportsRendering())
             return;
-        const rows = this.writeStream.rows || 24;
-        const cols = Math.max(this.writeStream.columns || 80, 40);
-        // ANSI codes for cursor rendering
-        const REVERSE_VIDEO = '\x1b[7m'; // Highlighted/inverted
-        const RESET = '\x1b[0m';
-        // Move to the bottom area (last 2 lines)
-        this.safeWrite(ANSI.CURSOR_TO_BOTTOM(rows - 1));
-        this.safeWrite(ANSI.CLEAR_LINE);
-        // Line 1: Separator with optional status hint on right
-        const queueCount = this.state.queuedCommands.length;
-        let statusHint = '';
-        if (this.state.isProcessing) {
-            statusHint = queueCount > 0 ? `${queueCount} queued` : '';
-        }
-        const separatorWidth = Math.min(cols - 2, 60);
-        this.safeWrite(theme.ui.border('─'.repeat(separatorWidth)));
-        // Add status hint after separator if there's room
-        if (statusHint) {
-            const remaining = cols - separatorWidth - 4;
-            if (remaining > statusHint.length) {
-                this.safeWrite('  ');
-                this.safeWrite(theme.ui.muted(statusHint));
+        // 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 = 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);
+            // Split input into lines for multi-line support
+            const inputLines = this.inputBuffer.split('\n');
+            const totalInputLines = inputLines.length;
+            const displayLineCount = Math.min(totalInputLines, this.maxDisplayLines);
+            // 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;
+                }
             }
-        }
-        // Line 2: Clean prompt with visible cursor
-        this.safeWrite('\n');
-        this.safeWrite(ANSI.CLEAR_LINE);
-        const promptPrefix = '> ';
-        const maxInputWidth = cols - 5; // Room for prompt + cursor + margin
-        // Get input and cursor position
-        const input = this.inputBuffer;
-        const cursorPos = Math.min(this.cursorPosition, input.length);
-        // Handle long input - scroll to keep cursor visible
-        let displayStart = 0;
-        let displayInput = input;
-        if (input.length > maxInputWidth) {
-            // Keep cursor visible by adjusting display window
-            if (cursorPos > maxInputWidth - 5) {
-                displayStart = cursorPos - maxInputWidth + 5;
+            // Calculate display window to keep cursor visible
+            let displayStartLine = 0;
+            if (totalInputLines > displayLineCount) {
+                if (cursorLineIndex >= displayLineCount - 1) {
+                    displayStartLine = cursorLineIndex - displayLineCount + 2;
+                }
+                displayStartLine = Math.min(displayStartLine, totalInputLines - displayLineCount);
+                displayStartLine = Math.max(0, displayStartLine);
+            }
+            const linesToShow = inputLines.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('─'.repeat(separatorWidth));
+            this.safeWrite(RESET);
+            // 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);
+            }
+            const maxInputWidth = cols - 5;
+            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(' ');
+                // 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);
+                    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(displayLine);
+                }
             }
-            displayInput = input.slice(displayStart, displayStart + maxInputWidth);
+            // 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;
         }
-        // Calculate cursor position in displayed text
-        const displayCursorPos = cursorPos - displayStart;
-        // Render: prompt + text before cursor + CURSOR + text after cursor
-        this.safeWrite(promptPrefix);
-        const beforeCursor = displayInput.slice(0, displayCursorPos);
-        const atCursor = displayInput[displayCursorPos] || ' '; // Space if at end
-        const afterCursor = displayInput.slice(displayCursorPos + 1);
-        // Text before cursor
-        this.safeWrite(beforeCursor);
-        // Cursor character (reverse video block)
-        this.safeWrite(REVERSE_VIDEO);
-        this.safeWrite(atCursor);
-        this.safeWrite(RESET);
-        // Text after cursor
-        this.safeWrite(afterCursor);
-        // Position the terminal cursor at our visual cursor position
-        // (This ensures the terminal's blinking cursor is also at the right spot)
-        const terminalCursorCol = promptPrefix.length + displayCursorPos + 1;
-        this.safeWrite(ANSI.MOVE_TO_COL(terminalCursorCol));
     }
     /**
      * Update the persistent input during streaming.
@@ -490,30 +611,93 @@ export class PinnedChatBox {
         return clean.slice(0, this.maxStatusMessageLength);
     }
     /**
-     * Build a compact preview string for pasted content
+     * Clear paste-specific state when the user edits the buffer manually.
+     * Prevents us from sending stale paste content after edits.
      */
-    buildPastePreview(firstLine) {
-        const clean = firstLine.replace(/\s+/g, ' ').trim();
-        if (!clean) {
-            return '(empty)';
+    startManualEdit() {
+        if (this.isPastedBlock) {
+            this.clearPastedBlock();
         }
-        if (clean.length > this.maxPastePreviewLength) {
-            return `${clean.slice(0, this.maxPastePreviewLength - 1)}…`;
+    }
+    /**
+     * 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();
+    }
+    /**
+     * 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();
+    }
+    /**
+     * 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
         }
-        return clean;
+        // Fallback to last line
+        const lastLine = Math.max(0, lines.length - 1);
+        return { lines, lineIndex: lastLine, column: (lines[lastLine] ?? '').length };
     }
     /**
-     * Format character counts with compact units
+     * Convert line/column back to a single cursor index.
      */
-    formatCharCount(charCount) {
-        if (!Number.isFinite(charCount) || charCount <= 0) {
-            return '0';
+    positionFromLineCol(lines, lineIndex, column) {
+        let pos = 0;
+        for (let i = 0; i < lineIndex; i++) {
+            pos += (lines[i] ?? '').length + 1; // +1 for newline
         }
-        if (charCount >= 1000) {
-            const rounded = (charCount / 1000).toFixed(charCount >= 10000 ? 0 : 1);
-            return `${rounded}k`;
+        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;
         }
-        return `${charCount}`;
+        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).
+     */
+    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
@@ -699,20 +883,18 @@ export class PinnedChatBox {
         this.scheduleRender();
     }
     /**
-     * Handle multiline paste - store full content but display summary
+     * Handle multiline paste - store full content and display all lines
      */
     handleMultilinePaste(content) {
-        // Keep the original content for submission but sanitize what we display
+        // Keep the original content for submission
         const displaySafeContent = this.sanitizeMultilineForDisplay(content);
-        const lineCount = displaySafeContent.split('\n').filter(line => line.trim().length > 0).length;
-        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;
-        // Generate a compact summary for the input line
-        const summary = this.generatePasteSummary(displaySafeContent, lineCount);
-        this.inputBuffer = summary;
-        this.cursorPosition = summary.length;
-        this.state.currentInput = summary;
-        this.scheduleRender();
+        this.applyBufferChange(truncatedDisplay, truncatedDisplay.length);
     }
     /**
      * Public helper for routing external multi-line pastes directly into the chat box
@@ -722,43 +904,6 @@ export class PinnedChatBox {
             return;
         this.handleMultilinePaste(content);
     }
-    /**
-     * Generate a short summary of pasted content for display
-     */
-    generatePasteSummary(content, lineCount) {
-        const lines = content.split('\n');
-        const firstLine = lines[0]?.trim() || '';
-        const charCount = content.length;
-        // Detect content type and get appropriate icon/label
-        let typeLabel = 'Paste';
-        let typeIcon = '📋';
-        if (firstLine.match(/^(import|export|const|let|var|function|class|def |async |from |interface |type )/)) {
-            typeIcon = '📝';
-            typeLabel = 'Code';
-        }
-        else if (firstLine.match(/^[{[\]]/)) {
-            typeIcon = '📊';
-            typeLabel = 'JSON';
-        }
-        else if (firstLine.match(/^<[!?]?[a-zA-Z]/)) {
-            typeIcon = '📄';
-            typeLabel = 'HTML';
-        }
-        else if (firstLine.match(/^#|^\/\/|^\/\*|^\*|^--/)) {
-            typeIcon = '💬';
-            typeLabel = 'Text';
-        }
-        else if (firstLine.match(/^```|^~~~|^\s{4}/)) {
-            typeIcon = '📖';
-            typeLabel = 'Markdown';
-        }
-        // Create a compact preview
-        const preview = this.buildPastePreview(firstLine);
-        // Format size info compactly
-        const sizeInfo = this.formatCharCount(charCount);
-        const lineInfo = `${lineCount || 1}L`;
-        return `${typeIcon} [${typeLabel}: ${lineInfo}/${sizeInfo}c] ${preview}`;
-    }
     /**
      * Check if current input is a pasted block
      */
@@ -786,6 +931,36 @@ export class PinnedChatBox {
         this.inputBuffer = '';
         this.cursorPosition = 0;
         this.state.currentInput = '';
+        this.resetReservedLines();
+    }
+    /**
+     * Calculate and update reserved lines based on current input content.
+     * Ensures multi-line content is fully visible within maxDisplayLines limit.
+     */
+    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));
+        }
+    }
+    /**
+     * Reset reserved lines to base value (for single-line input)
+     */
+    resetReservedLines() {
+        this.reservedLines = this.baseReservedLines;
+        // 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));
+        }
     }
     /**
      * Handle backspace
@@ -796,12 +971,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
@@ -812,11 +986,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
@@ -843,29 +1016,107 @@ export class PinnedChatBox {
         }
     }
     /**
-     * Handle home key
+     * Handle home key - move to start of current line (not start of buffer)
      */
     handleHome() {
         if (this.isDisposed)
             return;
-        this.cursorPosition = 0;
+        // 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();
     }
     /**
-     * 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;
+        // 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();
     }
     /**
-     * Handle up arrow - navigate to previous history entry
+     * 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;
+        // 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,
+        };
+    }
+    /**
+     * 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.cursorPosition = newPos;
+            this.state.currentInput = this.inputBuffer;
+            this.scheduleRender();
+            return;
+        }
+        // On first line - navigate history
         if (this.inputHistory.length === 0)
             return;
         // If at current input, save it temporarily
@@ -882,11 +1133,29 @@ export class PinnedChatBox {
         }
     }
     /**
-     * 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.cursorPosition = newPos;
+            this.state.currentInput = this.inputBuffer;
+            this.scheduleRender();
+            return;
+        }
+        // On last line - navigate history
         if (this.historyIndex > 0) {
             // Move down in history
             this.historyIndex--;
@@ -1213,6 +1482,8 @@ export class PinnedChatBox {
      * Handle terminal resize - update scroll region if active
      */
     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
             this.safeWrite(ANSI.RESET_SCROLL_REGION);
@@ -1269,13 +1540,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();
     }
     /**
@@ -1294,6 +1566,7 @@ export class PinnedChatBox {
             statusMessage: null,
             isVisible: true,
         };
+        this.invalidateRenderedState();
         this.scheduleRender();
     }
 }