erosolar-cli 2.1.248 → 2.1.252

package/dist/ui/UnifiedUIRenderer.js

@@ -78,13 +78,14 @@ export class UnifiedUIRenderer extends EventEmitter {
     activityStarFrames = ['✳', '✴', '✵', '✶', '✷', '✸'];
     // Token count during streaming
     streamingTokens = 0;
-    // Fun phrases to cycle through when no specific activity is provided
+    // User-friendly activity phrases (clean, professional)
     funActivityPhrases = [
-        'Moseying', 'Ruminating', 'Pondering', 'Cogitating', 'Mulling',
-        'Contemplating', 'Deliberating', 'Noodling', 'Percolating', 'Stewing',
-        'Brewing', 'Simmering', 'Churning', 'Puzzling', 'Meandering',
-        'Wandering', 'Musing', 'Daydreaming', 'Woolgathering', 'Chewing',
+        'Thinking', 'Processing', 'Analyzing', 'Working', 'Preparing',
     ];
+    maxCuratedReasoningLines = 8;
+    maxCuratedReasoningChars = 1800;
+    thoughtDedupWindowMs = 15000;
+    lastCuratedThought = null;
     statusMeta = {};
     toggleState = {
         verificationEnabled: false,
@@ -93,6 +94,37 @@ export class UnifiedUIRenderer extends EventEmitter {
         dualRlEnabled: false,
     };
     // ------------ Helpers ------------
+    /** Ensure cursor is always within valid bounds for the current buffer */
+    clampCursor() {
+        this.cursor = Math.max(0, Math.min(this.cursor, this.buffer.length));
+    }
+    /** Safely append to paste buffer with size limit enforcement */
+    appendToPasteBuffer(buffer, text) {
+        if (this.pasteBufferOverflow)
+            return; // Already at limit
+        const current = buffer === 'paste' ? this.pasteBuffer : this.plainPasteBuffer;
+        const remaining = this.maxPasteBufferSize - current.length;
+        if (remaining <= 0) {
+            this.pasteBufferOverflow = true;
+            return;
+        }
+        const toAdd = text.length <= remaining ? text : text.slice(0, remaining);
+        if (buffer === 'paste') {
+            this.pasteBuffer += toAdd;
+        }
+        else {
+            this.plainPasteBuffer += toAdd;
+        }
+        if (toAdd.length < text.length) {
+            this.pasteBufferOverflow = true;
+        }
+    }
+    /** Strip ANSI escape sequences from text to prevent injection */
+    sanitizePasteContent(text) {
+        // Remove all ANSI escape sequences (CSI, OSC, etc.)
+        // eslint-disable-next-line no-control-regex
+        return text.replace(/\x1b\[[0-9;]*[A-Za-z]|\x1b\][^\x07]*\x07|\x1b[PX^_][^\x1b]*\x1b\\|\x1b./g, '');
+    }
     formatHotkey(combo) {
         if (!combo?.trim())
             return null;
@@ -109,6 +141,9 @@ export class UnifiedUIRenderer extends EventEmitter {
     plainPasteWindowMs = 60;
     plainPasteTriggerChars = 24;
     plainPasteEarlyNewlineChars = 2; // Guard for short first lines in plain paste mode
+    // Paste buffer limits to prevent memory exhaustion
+    maxPasteBufferSize = 10 * 1024 * 1024; // 10MB max paste size
+    pasteBufferOverflow = false; // Track if paste was truncated
     cursorVisibleColumn = 1;
     inBracketedPaste = false;
     pasteBuffer = '';
@@ -118,6 +153,10 @@ export class UnifiedUIRenderer extends EventEmitter {
     pasteBurstWindowStart = 0;
     pasteBurstCharCount = 0;
     plainRecentChunks = [];
+    // Pending insert buffer: holds characters during paste detection window to prevent visual leak
+    pendingInsertBuffer = '';
+    pendingInsertTimer = null;
+    pendingInsertDelayMs = 80; // Wait before committing chars as normal input
     lastRenderedEventKey = null;
     lastOutputEndedWithNewline = true;
     hasRenderedPrompt = false;
@@ -130,6 +169,12 @@ export class UnifiedUIRenderer extends EventEmitter {
     pendingRender = false;
     lastRenderTime = 0;
     renderThrottleMs = 16; // ~60fps max
+    renderThrottleTimer = null;
+    // Disposal state to prevent operations after cleanup
+    disposed = false;
+    // Bound event handlers for proper cleanup
+    boundResizeHandler = null;
+    boundKeypressHandler = null;
     inputCapture = null;
     constructor(output = process.stdout, input = process.stdin, _options) {
         super();
@@ -148,12 +193,14 @@ export class UnifiedUIRenderer extends EventEmitter {
         });
         this.rl.setPrompt('');
         this.updateTerminalSize();
-        this.output.on('resize', () => {
-            if (!this.plainMode) {
+        // Use bound handlers so we can remove them on cleanup
+        this.boundResizeHandler = () => {
+            if (!this.plainMode && !this.disposed) {
                 this.updateTerminalSize();
                 this.renderPrompt();
             }
-        });
+        };
+        this.output.on('resize', this.boundResizeHandler);
         this.setupInputHandlers();
     }
     initialize() {
@@ -180,8 +227,15 @@ export class UnifiedUIRenderer extends EventEmitter {
         this.renderPrompt();
     }
     cleanup() {
+        // Mark as disposed first to prevent any pending operations
+        this.disposed = true;
         this.cancelInputCapture(new Error('Renderer disposed'));
         this.cancelPlainPasteCapture();
+        // Clear render throttle timer
+        if (this.renderThrottleTimer) {
+            clearTimeout(this.renderThrottleTimer);
+            this.renderThrottleTimer = null;
+        }
         // Stop any running animations
         if (this.spinnerInterval) {
             clearInterval(this.spinnerInterval);
@@ -197,6 +251,17 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         this.contextMeter.dispose();
         disposeAnimations();
+        // Remove event listeners to prevent memory leaks
+        if (this.boundResizeHandler) {
+            this.output.removeListener('resize', this.boundResizeHandler);
+            this.boundResizeHandler = null;
+        }
+        if (this.boundKeypressHandler) {
+            this.input.removeListener('keypress', this.boundKeypressHandler);
+            this.boundKeypressHandler = null;
+        }
+        // Remove all EventEmitter listeners from this instance
+        this.removeAllListeners();
         if (!this.interactive) {
             this.rl.close();
             return;
@@ -213,6 +278,8 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         this.rl.close();
         this.lastOverlay = null;
+        // Clear event queue
+        this.eventQueue = [];
     }
     suspendPromptRendering() {
         this.promptRenderingSuspended = true;
@@ -233,9 +300,13 @@ export class UnifiedUIRenderer extends EventEmitter {
         if (this.input.isTTY) {
             this.input.setRawMode(true);
         }
-        this.input.on('keypress', (str, key) => {
-            this.handleKeypress(str, key);
-        });
+        // Use bound handler so we can remove it on cleanup
+        this.boundKeypressHandler = (str, key) => {
+            if (!this.disposed) {
+                this.handleKeypress(str, key);
+            }
+        };
+        this.input.on('keypress', this.boundKeypressHandler);
     }
     emitInputChange() {
         const payload = {
@@ -385,8 +456,16 @@ export class UnifiedUIRenderer extends EventEmitter {
                 else if (this.historyIndex > 0) {
                     this.historyIndex--;
                 }
-                this.buffer = this.history[this.historyIndex] ?? '';
+                // Validate index is within bounds before accessing
+                if (this.historyIndex >= 0 && this.historyIndex < this.history.length) {
+                    this.buffer = this.history[this.historyIndex] ?? '';
+                }
+                else {
+                    this.historyIndex = -1;
+                    this.buffer = '';
+                }
                 this.cursor = this.buffer.length;
+                this.inputRenderOffset = 0; // Reset render offset for new buffer
                 this.updateSuggestions();
                 this.renderPrompt();
                 this.emitInputChange();
@@ -403,10 +482,16 @@ export class UnifiedUIRenderer extends EventEmitter {
                     this.historyIndex = -1;
                     this.buffer = '';
                 }
-                else {
+                else if (this.historyIndex >= 0) {
                     this.buffer = this.history[this.historyIndex] ?? '';
                 }
+                else {
+                    // Safety: invalid state, reset
+                    this.historyIndex = -1;
+                    this.buffer = '';
+                }
                 this.cursor = this.buffer.length;
+                this.inputRenderOffset = 0; // Reset render offset for new buffer
                 this.updateSuggestions();
                 this.renderPrompt();
                 this.emitInputChange();
@@ -419,8 +504,50 @@ export class UnifiedUIRenderer extends EventEmitter {
             return;
         }
         if (str && !key.ctrl && !key.meta) {
-            this.insertText(str);
+            // Defer insertion to allow paste detection window to catch rapid input
+            this.queuePendingInsert(str);
+        }
+    }
+    /**
+     * Queue characters for deferred insertion. This prevents visual "leak" of
+     * pasted content by holding characters until we're confident it's not a paste.
+     */
+    queuePendingInsert(text) {
+        this.pendingInsertBuffer += text;
+        // Clear any existing timer
+        if (this.pendingInsertTimer) {
+            clearTimeout(this.pendingInsertTimer);
+            this.pendingInsertTimer = null;
+        }
+        // Schedule commit after delay - if paste detection triggers first, it will consume the buffer
+        this.pendingInsertTimer = setTimeout(() => {
+            this.commitPendingInsert();
+        }, this.pendingInsertDelayMs);
+    }
+    /**
+     * Commit pending characters as normal input (not a paste).
+     */
+    commitPendingInsert() {
+        if (this.pendingInsertTimer) {
+            clearTimeout(this.pendingInsertTimer);
+            this.pendingInsertTimer = null;
+        }
+        if (this.pendingInsertBuffer && !this.inPlainPaste && !this.inBracketedPaste) {
+            this.insertText(this.pendingInsertBuffer);
+        }
+        this.pendingInsertBuffer = '';
+    }
+    /**
+     * Consume pending insert buffer into paste detection (prevents visual leak).
+     */
+    consumePendingInsertForPaste() {
+        if (this.pendingInsertTimer) {
+            clearTimeout(this.pendingInsertTimer);
+            this.pendingInsertTimer = null;
         }
+        const consumed = this.pendingInsertBuffer;
+        this.pendingInsertBuffer = '';
+        return consumed;
     }
     handleBracketedPaste(str, key) {
         const sequence = key?.sequence || str;
@@ -429,7 +556,10 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         if (sequence === '\x1b[200~') {
             this.inBracketedPaste = true;
-            this.pasteBuffer = '';
+            this.pasteBufferOverflow = false; // Reset overflow flag for new paste
+            // Consume any pending insert buffer to prevent leak
+            const pending = this.consumePendingInsertForPaste();
+            this.pasteBuffer = pending; // Include any chars that arrived before bracketed paste started
             this.cancelPlainPasteCapture();
             return true;
         }
@@ -441,7 +571,7 @@ export class UnifiedUIRenderer extends EventEmitter {
             return true;
         }
         if (key?.name === 'return' || key?.name === 'enter') {
-            this.pasteBuffer += '\n';
+            this.appendToPasteBuffer('paste', '\n');
             return true;
         }
         if (key?.name === 'backspace') {
@@ -449,11 +579,11 @@ export class UnifiedUIRenderer extends EventEmitter {
             return true;
         }
         if (typeof str === 'string' && str.length > 0) {
-            this.pasteBuffer += str;
+            this.appendToPasteBuffer('paste', str);
             return true;
         }
         if (typeof sequence === 'string' && sequence.length > 0) {
-            this.pasteBuffer += sequence;
+            this.appendToPasteBuffer('paste', sequence);
             return true;
         }
         return true;
@@ -461,11 +591,18 @@ export class UnifiedUIRenderer extends EventEmitter {
     commitPasteBuffer() {
         if (!this.inBracketedPaste)
             return;
-        const content = this.pasteBuffer.replace(/\r\n?/g, '\n');
+        // Sanitize to remove any injected escape sequences, then normalize line endings
+        const sanitized = this.sanitizePasteContent(this.pasteBuffer);
+        const content = sanitized.replace(/\r\n?/g, '\n');
         if (content) {
             const lines = content.split('\n');
+            const wasTruncated = this.pasteBufferOverflow;
             if (lines.length > 1 || content.length > 200) {
-                this.collapsedPaste = { text: content, lines: lines.length, chars: content.length };
+                this.collapsedPaste = {
+                    text: content,
+                    lines: lines.length,
+                    chars: content.length + (wasTruncated ? '+' : 0), // Indicate truncation
+                };
                 this.buffer = '';
                 this.cursor = 0;
                 this.updateSuggestions();
@@ -478,6 +615,7 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         this.inBracketedPaste = false;
         this.pasteBuffer = '';
+        this.pasteBufferOverflow = false;
         this.cancelPlainPasteCapture();
     }
     handlePlainPaste(str, key) {
@@ -517,23 +655,35 @@ export class UnifiedUIRenderer extends EventEmitter {
         let chunkAlreadyCaptured = false;
         if (!this.inPlainPaste) {
             this.inPlainPaste = true;
+            this.pasteBufferOverflow = false; // Reset overflow flag for new paste
+            // Consume pending insert buffer first - this is the primary source now
+            const pending = this.consumePendingInsertForPaste();
             const reclaimed = this.reclaimRecentPlainChunks();
-            if (reclaimed.length > 0) {
-                const removeCount = Math.min(this.buffer.length, reclaimed.length);
-                const suffix = this.buffer.slice(-removeCount);
-                if (removeCount > 0 && suffix === reclaimed.slice(-removeCount)) {
-                    this.buffer = this.buffer.slice(0, this.buffer.length - removeCount);
-                    this.cursor = Math.max(0, this.buffer.length);
+            // Combine pending buffer with any reclaimed chunks
+            const combined = pending + reclaimed;
+            if (combined.length > 0) {
+                // Remove any chars that leaked into buffer (legacy reclaim path)
+                if (reclaimed.length > 0) {
+                    const removeCount = Math.min(this.buffer.length, reclaimed.length);
+                    const suffix = this.buffer.slice(-removeCount);
+                    if (removeCount > 0 && suffix === reclaimed.slice(-removeCount)) {
+                        this.buffer = this.buffer.slice(0, this.buffer.length - removeCount);
+                        this.cursor = Math.max(0, this.buffer.length);
+                        this.clampCursor(); // Ensure cursor is valid
+                    }
+                }
+                this.plainPasteBuffer = combined.slice(0, this.maxPasteBufferSize);
+                if (combined.length > this.maxPasteBufferSize) {
+                    this.pasteBufferOverflow = true;
                 }
-                this.plainPasteBuffer = reclaimed;
-                chunkAlreadyCaptured = reclaimed.endsWith(chunk);
+                chunkAlreadyCaptured = combined.endsWith(chunk);
             }
             else {
                 this.plainPasteBuffer = '';
             }
         }
         if (!chunkAlreadyCaptured) {
-            this.plainPasteBuffer += chunk;
+            this.appendToPasteBuffer('plainPaste', chunk);
         }
         this.schedulePlainPasteCommit();
         return true;
@@ -554,6 +704,12 @@ export class UnifiedUIRenderer extends EventEmitter {
             clearTimeout(this.plainPasteTimer);
             this.plainPasteTimer = null;
         }
+        // Also cancel pending insert buffer
+        if (this.pendingInsertTimer) {
+            clearTimeout(this.pendingInsertTimer);
+            this.pendingInsertTimer = null;
+        }
+        this.pendingInsertBuffer = '';
         this.inPlainPaste = false;
         this.plainPasteBuffer = '';
         this.plainRecentChunks = [];
@@ -589,11 +745,15 @@ export class UnifiedUIRenderer extends EventEmitter {
     finalizePlainPaste() {
         if (!this.inPlainPaste)
             return;
-        const content = this.plainPasteBuffer.replace(/\r\n?/g, '\n');
+        // Sanitize to remove any injected escape sequences, then normalize line endings
+        const sanitized = this.sanitizePasteContent(this.plainPasteBuffer);
+        const content = sanitized.replace(/\r\n?/g, '\n');
+        const wasTruncated = this.pasteBufferOverflow;
         this.inPlainPaste = false;
         this.plainPasteBuffer = '';
         this.plainRecentChunks = [];
         this.resetPlainPasteBurst();
+        this.pasteBufferOverflow = false;
         if (this.plainPasteTimer) {
             clearTimeout(this.plainPasteTimer);
             this.plainPasteTimer = null;
@@ -602,7 +762,11 @@ export class UnifiedUIRenderer extends EventEmitter {
             return;
         const lines = content.split('\n');
         if (lines.length > 1 || content.length > 200) {
-            this.collapsedPaste = { text: content, lines: lines.length, chars: content.length };
+            this.collapsedPaste = {
+                text: content,
+                lines: lines.length,
+                chars: content.length + (wasTruncated ? '+' : 0),
+            };
             this.buffer = '';
             this.cursor = 0;
             this.updateSuggestions();
@@ -621,8 +785,11 @@ export class UnifiedUIRenderer extends EventEmitter {
         if (this.collapsedPaste) {
             this.expandCollapsedPaste();
         }
+        // Ensure cursor is valid before slicing
+        this.clampCursor();
         this.buffer = this.buffer.slice(0, this.cursor) + text + this.buffer.slice(this.cursor);
         this.cursor += text.length;
+        this.clampCursor(); // Ensure cursor remains valid after modification
         this.updateSuggestions();
         this.renderPrompt();
         this.emitInputChange();
@@ -739,11 +906,19 @@ export class UnifiedUIRenderer extends EventEmitter {
     }
     navigateSuggestions(direction) {
         if (!this.buffer.startsWith('/') || this.suggestions.length === 0) {
+            // Reset index if suggestions were cleared but index wasn't
+            if (this.suggestionIndex !== -1 && this.suggestions.length === 0) {
+                this.suggestionIndex = -1;
+            }
             return false;
         }
-        const next = this.suggestionIndex + direction;
+        // Ensure current index is valid before computing next
+        const currentIndex = this.suggestionIndex >= 0 && this.suggestionIndex < this.suggestions.length
+            ? this.suggestionIndex
+            : -1;
+        const next = currentIndex + direction;
         const clamped = Math.max(0, Math.min(this.suggestions.length - 1, next));
-        if (clamped === this.suggestionIndex) {
+        if (clamped === this.suggestionIndex && this.suggestionIndex >= 0) {
             return true;
         }
         this.suggestionIndex = clamped;
@@ -812,11 +987,11 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
     }
     async processQueue() {
-        if (this.isProcessingQueue)
+        if (this.isProcessingQueue || this.disposed)
             return;
         this.isProcessingQueue = true;
         try {
-            while (this.eventQueue.length > 0) {
+            while (this.eventQueue.length > 0 && !this.disposed) {
                 const event = this.eventQueue.shift();
                 if (!event)
                     continue;
@@ -826,9 +1001,14 @@ export class UnifiedUIRenderer extends EventEmitter {
                 }
                 catch (error) {
                     // Never allow a rendering failure to stall the event queue
+                    if (this.disposed)
+                        break; // Don't try to write after disposal
                     const message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown renderer error';
                     this.output.write(`\n[renderer] ${message}\n`);
                 }
+                // Check disposed before continuing
+                if (this.disposed)
+                    break;
                 // For prompt events, ensure the overlay is rendered immediately
                 // This guarantees prompts are visible before async processing continues
                 if (event.type === 'prompt') {
@@ -844,7 +1024,7 @@ export class UnifiedUIRenderer extends EventEmitter {
             }
             // ALWAYS render prompt after queue completes to keep bottom UI persistent
             // This ensures status/toggles stay pinned and responses are fully rendered
-            if (this.output.isTTY) {
+            if (this.output.isTTY && !this.disposed) {
                 this.allowPromptRender = true;
                 this.renderPrompt();
             }
@@ -974,9 +1154,18 @@ export class UnifiedUIRenderer extends EventEmitter {
                 if (this.isGarbageOutput(event.content)) {
                     return '';
                 }
-                // Strip any existing bullet prefix (○ or ⏺) and use consistent wrapping
-                const cleanContent = event.content.replace(/^[○⏺]\s*/, '');
-                return this.formatThinkingBlock(cleanContent);
+                const curated = this.curateReasoningContent(event.content);
+                if (!curated || this.isGarbageOutput(curated)) {
+                    return '';
+                }
+                if (!this.shouldRenderThought(curated)) {
+                    return '';
+                }
+                this.lastCuratedThought = {
+                    text: curated.replace(/\s+/g, ' ').trim().toLowerCase(),
+                    at: Date.now(),
+                };
+                return this.formatThinkingBlock(curated);
             }
             case 'tool': {
                 // Compact tool display: ⚡ToolName → result
@@ -1036,6 +1225,70 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         return false;
     }
+    curateReasoningContent(content) {
+        const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n').trim();
+        if (!normalized)
+            return null;
+        const limited = normalized.length > this.maxCuratedReasoningChars
+            ? normalized.slice(0, this.maxCuratedReasoningChars)
+            : normalized;
+        const segments = limited
+            .split('\n')
+            .flatMap(line => line.split(/(?<=[.?!])\s+/))
+            .map(line => line.replace(/^[•*⏺○\-\u2022]+\s*/, '').trim())
+            .filter(Boolean);
+        if (segments.length === 0) {
+            return null;
+        }
+        const seen = new Set();
+        const deduped = [];
+        for (const segment of segments) {
+            const normalizedSegment = segment.replace(/\s+/g, ' ');
+            const key = normalizedSegment.toLowerCase();
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            deduped.push(normalizedSegment);
+            if (deduped.length >= this.maxCuratedReasoningLines) {
+                break;
+            }
+        }
+        if (deduped.length === 0) {
+            return null;
+        }
+        const structured = deduped.filter(line => this.looksStructuredThought(line));
+        const selected = structured.length > 0 ? structured : deduped;
+        const limitedSelection = selected.slice(0, this.maxCuratedReasoningLines);
+        const bulleted = limitedSelection.map(line => this.ensureReasoningBullet(line));
+        return bulleted.join('\n');
+    }
+    ensureReasoningBullet(line) {
+        if (/^([•*⏺○\-]|\d+[.)])\s/.test(line)) {
+            return line;
+        }
+        return `• ${line}`;
+    }
+    looksStructuredThought(line) {
+        return (/^(\d+[.)]\s|step\s*\d+|plan\b|next\b|then\b|goal\b)/i.test(line) ||
+            /^[-*•]\s/.test(line) ||
+            line.includes('->') ||
+            line.includes('→') ||
+            line.includes(': '));
+    }
+    shouldRenderThought(content) {
+        const normalized = content.replace(/\s+/g, ' ').trim().toLowerCase();
+        if (!normalized) {
+            return false;
+        }
+        const now = Date.now();
+        if (this.lastCuratedThought && this.lastCuratedThought.text === normalized) {
+            if (now - this.lastCuratedThought.at < this.thoughtDedupWindowMs) {
+                return false;
+            }
+        }
+        return true;
+    }
     /**
      * Format text in Claude Code style: ⏺ prefix with wrapped continuation lines
      * Example:
@@ -1397,7 +1650,7 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         // Build the box
         const result = [];
-        const labelText = ' thinking ';
+        const labelText = ' reasoning ';
         const headerLine = `╭─${labelText}${'─'.repeat(Math.max(0, maxBoxWidth - labelText.length - 4))}─╮`;
         result.push(thinkingStyle.border(headerLine));
         for (const line of wrappedLines) {
@@ -1630,14 +1883,21 @@ export class UnifiedUIRenderer extends EventEmitter {
     }
     // ------------ Prompt rendering ------------
     renderPrompt() {
+        // Don't render if disposed
+        if (this.disposed)
+            return;
         // Throttle renders to prevent excessive redraws during rapid input
         const now = Date.now();
         if (now - this.lastRenderTime < this.renderThrottleMs) {
             if (!this.pendingRender) {
                 this.pendingRender = true;
-                setTimeout(() => {
+                // Track the timer for cleanup
+                this.renderThrottleTimer = setTimeout(() => {
+                    this.renderThrottleTimer = null;
                     this.pendingRender = false;
-                    this.renderPromptImmediate();
+                    if (!this.disposed) {
+                        this.renderPromptImmediate();
+                    }
                 }, this.renderThrottleMs);
             }
             return;
@@ -1645,6 +1905,9 @@ export class UnifiedUIRenderer extends EventEmitter {
         this.renderPromptImmediate();
     }
     renderPromptImmediate() {
+        // Don't render if disposed
+        if (this.disposed)
+            return;
         this.lastRenderTime = Date.now();
         if (!this.interactive) {
             this.isPromptActive = false;
@@ -2347,7 +2610,9 @@ export class UnifiedUIRenderer extends EventEmitter {
     }
     setBuffer(text, cursorPos) {
         this.buffer = text;
-        this.cursor = cursorPos ?? text.length;
+        // Validate cursor position to prevent out-of-bounds issues
+        const requestedCursor = cursorPos ?? text.length;
+        this.cursor = Math.max(0, Math.min(requestedCursor, text.length));
         this.inputRenderOffset = 0;
         this.updateSuggestions();
         this.renderPrompt();