erosolar-cli 1.7.194 → 1.7.196

package/dist/ui/persistentPrompt.js

@@ -1,1529 +0,0 @@
-/**
- * PersistentPrompt - Minimal, stable chat input at bottom of terminal
- *
- * Design principles:
- * - Simple: No complex cursor manipulation or multi-line rendering
- * - Stable: Uses standard readline without fighting it
- * - Reliable: Clear separation between output area and input area
- */
-import * as readline from 'node:readline';
-import { theme } from './theme.js';
-/**
- * Minimal prompt manager that doesn't fight with readline
- */
-export class PersistentPrompt {
-    writeStream;
-    promptText;
-    statusBarState;
-    isEnabled = true;
-    promptState;
-    constructor(writeStream, promptText = '> ') {
-        this.writeStream = writeStream;
-        this.promptText = promptText;
-        this.statusBarState = {};
-        this.promptState = {
-            userInput: '',
-            cursorPosition: 0,
-            isVisible: true,
-        };
-    }
-    /**
-     * Update the prompt text
-     */
-    setPromptText(text) {
-        this.promptText = text;
-    }
-    /**
-     * Get the formatted prompt string
-     */
-    getPrompt() {
-        return this.promptText;
-    }
-    /**
-     * Update user input state (for tracking only - readline handles display)
-     */
-    updateInput(input, cursorPos) {
-        this.promptState.userInput = input;
-        this.promptState.cursorPosition = cursorPos;
-    }
-    /**
-     * Update status bar information
-     */
-    updateStatusBar(state) {
-        this.statusBarState = { ...this.statusBarState, ...state };
-    }
-    /**
-     * Show a status line above the prompt (call before readline.prompt())
-     */
-    showStatus() {
-        if (!this.isEnabled)
-            return;
-        const status = this.buildStatusLine();
-        if (status) {
-            this.writeStream.write(`\n${status}\n`);
-        }
-    }
-    /**
-     * Show the prompt
-     */
-    show() {
-        this.promptState.isVisible = true;
-    }
-    /**
-     * Hide the prompt
-     */
-    hide() {
-        this.promptState.isVisible = false;
-    }
-    /**
-     * Enable or disable
-     */
-    setEnabled(enabled) {
-        this.isEnabled = enabled;
-    }
-    /**
-     * Clear - no-op for minimal implementation
-     */
-    clear() {
-        // Intentionally minimal - let readline handle clearing
-    }
-    /**
-     * Build status line string
-     * NOTE: Context usage is NOT shown here - it's already displayed by
-     * display.showStatusLine() which shows "Session Xm • Context Y% used • Ready for prompts"
-     */
-    buildStatusLine() {
-        const parts = [];
-        if (this.statusBarState.fileChanges) {
-            parts.push(this.statusBarState.fileChanges);
-        }
-        // Context usage removed - display.showStatusLine() already shows it
-        if (this.statusBarState.message?.trim()) {
-            parts.push(this.statusBarState.message.trim());
-        }
-        if (!parts.length) {
-            return null;
-        }
-        return theme.ui.muted(parts.join(' • '));
-    }
-    /**
-     * Handle terminal resize - no-op for minimal implementation
-     */
-    handleResize() {
-        // Readline handles resize
-    }
-    /**
-     * Dispose
-     */
-    dispose() {
-        // Nothing to clean up in minimal implementation
-    }
-}
-/**
- * Simple input box that wraps readline with stable behavior
- */
-export class SimpleInputBox {
-    rl = null;
-    promptText;
-    statusText = '';
-    constructor(promptText = '> ') {
-        this.promptText = promptText;
-    }
-    /**
-     * Initialize readline interface
-     */
-    init(input, output) {
-        this.rl = readline.createInterface({
-            input,
-            output,
-            prompt: this.promptText,
-            terminal: true,
-        });
-        return this.rl;
-    }
-    /**
-     * Set prompt text
-     */
-    setPrompt(text) {
-        this.promptText = text;
-        if (this.rl) {
-            this.rl.setPrompt(text);
-        }
-    }
-    /**
-     * Set status text (shown above prompt on next prompt())
-     */
-    setStatus(text) {
-        this.statusText = text;
-    }
-    /**
-     * Show prompt with optional status line
-     */
-    prompt(preserveCursor) {
-        if (!this.rl)
-            return;
-        // Show status line if set
-        if (this.statusText) {
-            process.stdout.write(`\n${theme.ui.muted(this.statusText)}\n`);
-            this.statusText = '';
-        }
-        this.rl.prompt(preserveCursor);
-    }
-    /**
-     * Get readline interface
-     */
-    getInterface() {
-        return this.rl;
-    }
-    /**
-     * Close and cleanup
-     */
-    close() {
-        if (this.rl) {
-            this.rl.close();
-            this.rl = null;
-        }
-    }
-}
-/**
- * ANSI escape codes for terminal control
- */
-const ANSI = {
-    SAVE_CURSOR: '\u001b7',
-    RESTORE_CURSOR: '\u001b8',
-    CURSOR_TO_BOTTOM: (rows) => `\u001b[${Math.max(1, rows)};1H`,
-    CLEAR_LINE: '\u001b[2K',
-    CLEAR_TO_END: '\u001b[0J',
-    MOVE_UP: (n) => `\u001b[${Math.max(0, n)}A`,
-    MOVE_DOWN: (n) => `\u001b[${Math.max(0, n)}B`,
-    MOVE_TO_COL: (col) => `\u001b[${Math.max(1, col)}G`,
-    HIDE_CURSOR: '\u001b[?25l',
-    SHOW_CURSOR: '\u001b[?25h',
-    // Scroll region
-    SET_SCROLL_REGION: (top, bottom) => `\u001b[${Math.max(1, top)};${Math.max(1, bottom)}r`,
-    RESET_SCROLL_REGION: '\u001b[r',
-};
-/**
- * PinnedChatBox - Persistent input box pinned to bottom of terminal
- *
- * Features:
- * - Always visible at bottom of terminal
- * - Accepts input while AI is processing (queues commands)
- * - Shows queue status and context usage
- * - Non-blocking - doesn't interfere with output scroll
- */
-export class PinnedChatBox {
-    writeStream;
-    state;
-    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;
-    renderScheduled = false;
-    isEnabled = true;
-    isDisposed = false;
-    lastRenderTime = 0;
-    renderThrottleMs = 16; // ~60fps max
-    maxInputLength = 10000; // Prevent memory issues
-    maxQueueSize = 100; // Prevent queue overflow
-    ansiPattern = /[\u001B\u009B][[\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
-    oscPattern = /\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g;
-    maxStatusMessageLength = 200;
-    // Scroll region management for persistent bottom input
-    scrollRegionActive = false;
-    // Input history for up/down navigation
-    inputHistory = [];
-    historyIndex = -1;
-    tempCurrentInput = ''; // Stores current input when navigating history
-    maxHistorySize = 100;
-    // Multiline paste tracking for summary display
-    isPastedBlock = false;
-    pastedFullContent = '';
-    // Prevent accidental submit right after paste (trailing newline issue)
-    lastPasteTime = 0;
-    pasteSubmitGuardMs = 150; // Ignore submit within 150ms of paste
-    /** 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;
-        this.onCommandQueued = options.onCommandQueued;
-        this.onInputSubmit = options.onInputSubmit;
-        this.maxInputLength = options.maxInputLength ?? 10000;
-        this.maxQueueSize = options.maxQueueSize ?? 100;
-        this.state = {
-            isProcessing: false,
-            queuedCommands: [],
-            currentInput: '',
-            contextUsage: 0,
-            statusMessage: null,
-            isVisible: true,
-        };
-    }
-    /** Pending render timeout for debounced afterWrite */
-    pendingAfterWriteRender = null;
-    /**
-     * Register with the display's output interceptor system.
-     *
-     * With true scroll regions, output flows naturally in the scrollable area
-     * and the bottom is PROTECTED automatically - no re-rendering needed.
-     *
-     * This is a no-op now because scroll regions handle everything.
-     */
-    registerOutputInterceptor(display) {
-        if (this.outputInterceptorCleanup) {
-            this.outputInterceptorCleanup();
-        }
-        // With true scroll regions, the bottom area is protected automatically.
-        // Output goes to the scroll region, input stays in the protected area.
-        // No afterWrite re-rendering needed - that was causing flicker.
-        this.outputInterceptorCleanup = display.registerOutputInterceptor({
-            beforeWrite: () => {
-                // Ensure cursor is in scroll region before output
-                if (this.scrollRegionActive) {
-                    const rows = this.writeStream.rows || 24;
-                    const scrollBottom = rows - this.reservedLines;
-                    // Move cursor to scroll region if it's in the protected area
-                    this.safeWrite(ANSI.SAVE_CURSOR);
-                    this.safeWrite(ANSI.CURSOR_TO_BOTTOM(scrollBottom));
-                }
-            },
-            afterWrite: () => {
-                // Restore cursor to prompt area after output
-                if (this.scrollRegionActive) {
-                    this.safeWrite(ANSI.RESTORE_CURSOR);
-                }
-            },
-        });
-    }
-    /**
-     * Enable scroll region to keep bottom lines reserved for input.
-     * Sets terminal scroll region to exclude the bottom 2 lines (separator + prompt).
-     *
-     * TRUE SCROLL REGION approach:
-     * 1. Set scroll region (rows 1 to N-2) - protects bottom 2 lines
-     * 2. Render the prompt in protected area (rows N-1 and N)
-     * 3. Leave cursor at prompt - user can type immediately
-     * 4. Output writes will go to scroll region via beforeWrite/afterWrite hooks
-     */
-    enableScrollRegion() {
-        if (this.scrollRegionActive || !this.supportsRendering())
-            return;
-        // Make sure reserved height matches current content/terminal width
-        this.updateReservedLinesForContent();
-        const rows = this.writeStream.rows || 24;
-        const scrollBottom = rows - this.reservedLines;
-        // Step 1: Set scroll region (excludes bottom reserved lines)
-        this.safeWrite(ANSI.SET_SCROLL_REGION(1, scrollBottom));
-        // Invalidate render state to ensure fresh render in the new scroll region
-        this.invalidateRenderedState();
-        // Step 2: Render the prompt in the protected bottom area
-        this.renderPersistentInput();
-        // Mark scroll region as active AFTER rendering
-        this.scrollRegionActive = true;
-        // Cursor is now at the prompt (from renderPersistentInput)
-        // User can start typing immediately
-    }
-    /**
-     * Disable scroll region and restore normal terminal behavior.
-     *
-     * 1. Reset scroll region to full terminal
-     * 2. Clear the reserved bottom area (will be replaced by readline prompt)
-     * 3. Move cursor to the end
-     */
-    disableScrollRegion() {
-        if (!this.scrollRegionActive || !this.supportsRendering())
-            return;
-        this.scrollRegionActive = false;
-        // Reset scroll region to full terminal
-        this.safeWrite(ANSI.RESET_SCROLL_REGION);
-        // Clear the bottom reserved lines (they'll be replaced by readline)
-        const rows = this.writeStream.rows || 24;
-        for (let i = 0; i < this.reservedLines; i++) {
-            this.safeWrite(ANSI.CURSOR_TO_BOTTOM(rows - i));
-            this.safeWrite(ANSI.CLEAR_LINE);
-        }
-        // 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 MULTI-LINE CHAT BOX:
-     * - Line 1: Simple separator with line count hint
-     * - Line 2+: Input lines with dark background, block cursor highlight
-     *
-     * Key features:
-     * - Dark background (ANSI 48;5;236) for entire input area
-     * - Block cursor shown via reverse video
-     * - Clean vertical layout for multi-line input
-     * - Proper cursor tracking through wrapped lines
-     */
-    renderPersistentInput() {
-        if (!this.supportsRendering())
-            return;
-        // Render lock - prevent concurrent renders that cause flicker
-        if (this.isRendering)
-            return;
-        // Deduplication - skip if nothing changed
-        if (!this.needsRender())
-            return;
-        this.isRendering = true;
-        try {
-            const { rows, cols, maxInputWidth } = this.getRenderDimensions();
-            // ANSI codes
-            const HIDE_CURSOR = '\x1b[?25l';
-            const SHOW_CURSOR = '\x1b[?25h';
-            const RESET = '\x1b[0m';
-            const DIM = '\x1b[2m';
-            // Dark gray background for input area (256-color: 236)
-            const INPUT_BG = '\x1b[48;5;236m';
-            // Cursor: bright white on dark background with reverse for visibility
-            const CURSOR_STYLE = '\x1b[7;1m';
-            // Hide cursor during render
-            this.safeWrite(HIDE_CURSOR);
-            this.safeWrite(RESET);
-            // Wrap input into terminal-safe lines
-            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
-            this.updateReservedLinesForContent(maxInputWidth, totalInputLines);
-            // Calculate which lines to display (keep cursor visible)
-            let displayStartLine = 0;
-            if (totalInputLines > displayLineCount) {
-                displayStartLine = Math.max(0, cursorLineIndex - displayLineCount + 1);
-                displayStartLine = Math.min(displayStartLine, totalInputLines - displayLineCount);
-            }
-            const linesToShow = wrappedLines.slice(displayStartLine, displayStartLine + displayLineCount);
-            // Move to reserved area start
-            const reservedStart = rows - this.reservedLines + 1;
-            this.safeWrite(ANSI.CURSOR_TO_BOTTOM(reservedStart));
-            this.safeWrite(ANSI.CLEAR_LINE);
-            // Separator line with status
-            const separatorWidth = Math.max(1, Math.min(cols - 2, 55));
-            this.safeWrite(DIM);
-            this.safeWrite('─'.repeat(separatorWidth));
-            // Status hints on same line as separator
-            const hints = [];
-            if (totalInputLines > 1) {
-                hints.push(`${totalInputLines} lines`);
-            }
-            const queueCount = this.state.queuedCommands.length;
-            if (this.state.isProcessing && queueCount > 0) {
-                hints.push(`${queueCount} queued`);
-            }
-            if (hints.length > 0) {
-                this.safeWrite('  ' + hints.join(' • '));
-            }
-            this.safeWrite(RESET);
-            let finalCursorRow = reservedStart + 1;
-            let finalCursorCol = 3;
-            // Render each input line with background
-            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;
-                // Start background for this line
-                this.safeWrite(INPUT_BG);
-                // Prompt prefix
-                this.safeWrite(DIM);
-                this.safeWrite(isFirstLine ? '> ' : '│ ');
-                this.safeWrite(RESET);
-                this.safeWrite(INPUT_BG);
-                if (isCursorLine) {
-                    // Render line with block cursor
-                    const cursorPos = Math.max(0, Math.min(cursorColInLine, line.length));
-                    const beforeCursor = line.slice(0, cursorPos);
-                    const atCursor = cursorPos < line.length ? (line[cursorPos] ?? ' ') : ' ';
-                    const afterCursor = cursorPos < line.length ? line.slice(cursorPos + 1) : '';
-                    this.safeWrite(beforeCursor);
-                    this.safeWrite(CURSOR_STYLE);
-                    this.safeWrite(atCursor);
-                    this.safeWrite(RESET);
-                    this.safeWrite(INPUT_BG);
-                    this.safeWrite(afterCursor);
-                    // Track cursor position for terminal cursor
-                    finalCursorRow = reservedStart + 1 + lineIdx;
-                    finalCursorCol = 3 + cursorPos;
-                }
-                else {
-                    this.safeWrite(line);
-                }
-                // Pad to fill background to edge, then reset
-                const lineLen = 2 + line.length + (isCursorLine && cursorColInLine >= line.length ? 1 : 0);
-                const padding = Math.max(0, cols - lineLen - 1);
-                if (padding > 0) {
-                    this.safeWrite(' '.repeat(padding));
-                }
-                this.safeWrite(RESET);
-            }
-            // Position terminal cursor and show it
-            this.safeWrite(ANSI.CURSOR_TO_BOTTOM(finalCursorRow));
-            this.safeWrite(ANSI.MOVE_TO_COL(Math.max(1, Math.min(finalCursorCol, cols))));
-            this.safeWrite(SHOW_CURSOR);
-            // Update rendered state
-            this.updateRenderedState();
-        }
-        finally {
-            this.isRendering = false;
-        }
-    }
-    /**
-     * Update the persistent input display.
-     *
-     * Always renders the input area with proper cursor tracking and background.
-     * During processing, scroll region protects the bottom area.
-     * During normal mode, this provides custom styling over readline.
-     */
-    updatePersistentInput() {
-        // Always render to show input with proper cursor tracking and background
-        this.renderPersistentInput();
-    }
-    /**
-     * Determine if we can safely render to the terminal.
-     * Protects against non-TTY streams and disposed instances.
-     */
-    supportsRendering() {
-        return (!this.isDisposed &&
-            this.isEnabled &&
-            Boolean(this.writeStream.isTTY) &&
-            typeof this.writeStream.write === 'function' &&
-            this.writeStream.writable !== false);
-    }
-    /**
-     * Strip ANSI escape codes
-     */
-    stripAnsi(text) {
-        this.ansiPattern.lastIndex = 0;
-        this.oscPattern.lastIndex = 0;
-        return text
-            .replace(this.oscPattern, '')
-            .replace(this.ansiPattern, '');
-    }
-    /**
-     * Sanitize inline text to a single safe line (no control/ANSI codes)
-     */
-    sanitizeInlineText(text) {
-        if (!text)
-            return '';
-        const withoutAnsi = this.stripAnsi(text);
-        return withoutAnsi
-            .replace(/[\r\n\u2028\u2029]/g, ' ')
-            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
-    }
-    /**
-     * Sanitize multiline content for safe display (preserves newlines for counting)
-     */
-    sanitizeMultilineForDisplay(text) {
-        if (!text)
-            return '';
-        const withoutAnsi = this.stripAnsi(text.replace(/\r/g, ''));
-        return withoutAnsi.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
-    }
-    /**
-     * Sanitize queued command text (trimmed, preserves newlines)
-     */
-    sanitizeCommandText(text) {
-        if (!text)
-            return '';
-        const clean = this.sanitizeMultilineForDisplay(text);
-        return clean.slice(0, this.maxInputLength).trim();
-    }
-    /**
-     * Sanitize status message (single line, bounded length)
-     */
-    sanitizeStatusMessage(message) {
-        if (!message)
-            return null;
-        const clean = this.sanitizeInlineText(message).trim();
-        if (!clean)
-            return null;
-        return clean.slice(0, this.maxStatusMessageLength);
-    }
-    /**
-     * Clear paste-specific state when the user edits the buffer manually.
-     * Prevents us from sending stale paste content after edits.
-     */
-    startManualEdit() {
-        if (this.isPastedBlock) {
-            this.clearPastedBlock();
-        }
-    }
-    /**
-     * Apply a new buffer/cursor position and trigger downstream updates.
-     */
-    applyBufferChange(buffer, cursorPos) {
-        this.inputBuffer = buffer;
-        const nextCursor = typeof cursorPos === 'number' ? cursorPos : buffer.length;
-        this.cursorPosition = Math.max(0, Math.min(nextCursor, this.inputBuffer.length));
-        this.state.currentInput = this.inputBuffer;
-        this.updateReservedLinesForContent();
-        this.scheduleRender();
-    }
-    /**
-     * Treat spaces, tabs, and newlines as whitespace for navigation helpers.
-     */
-    isWhitespace(char) {
-        return char === ' ' || char === '\t' || char === '\n';
-    }
-    /**
-     * Update cursor position while keeping it in bounds and re-rendering.
-     */
-    setCursorPosition(position) {
-        this.cursorPosition = Math.max(0, Math.min(position, this.inputBuffer.length));
-        this.scheduleRender();
-    }
-    /**
-     * Insert multi-line content directly into the buffer (manual typing).
-     */
-    insertMultilineText(text) {
-        const sanitized = this.sanitizeMultilineForDisplay(text);
-        if (!sanitized)
-            return;
-        // Respect max input length
-        const availableSpace = this.maxInputLength - this.inputBuffer.length;
-        if (availableSpace <= 0)
-            return;
-        const chunk = sanitized.slice(0, availableSpace);
-        this.startManualEdit();
-        this.applyBufferChange(this.inputBuffer.slice(0, this.cursorPosition) +
-            chunk +
-            this.inputBuffer.slice(this.cursorPosition), this.cursorPosition + chunk.length);
-    }
-    /**
-     * Safely write to the output stream, swallowing non-fatal errors
-     */
-    safeWrite(content) {
-        try {
-            if (this.writeStream.writable) {
-                this.writeStream.write(content);
-            }
-        }
-        catch {
-            // Swallow write errors (e.g., stream closed) to avoid crashing the app
-        }
-    }
-    /**
-     * Enable or disable the pinned chat box
-     */
-    setEnabled(enabled) {
-        if (this.isDisposed)
-            return;
-        if (!enabled && this.isEnabled) {
-            this.clear();
-        }
-        this.isEnabled = enabled;
-        if (enabled) {
-            this.scheduleRender();
-        }
-    }
-    /**
-     * Set processing state
-     *
-     * TRUE SCROLL REGION approach (like Claude Code):
-     * - Enable scroll region at start (protects bottom 2-3 lines)
-     * - Output flows naturally in scroll region (cursor stays there)
-     * - Bottom area is PROTECTED - no re-rendering needed after each chunk
-     * - User types directly into protected bottom area
-     * - Disable scroll region when done
-     */
-    setProcessing(isProcessing) {
-        if (this.isDisposed)
-            return;
-        const wasProcessing = this.state.isProcessing;
-        this.state.isProcessing = isProcessing;
-        if (isProcessing && !wasProcessing) {
-            // Starting processing - enable scroll region to protect bottom
-            this.enableScrollRegion();
-        }
-        else if (!isProcessing && wasProcessing) {
-            // Ending processing - disable scroll region, restore normal mode
-            this.disableScrollRegion();
-        }
-    }
-    /**
-     * Update context usage percentage
-     * NOTE: This only tracks the value - it no longer triggers render since
-     * context display is handled by display.showStatusLine() instead
-     */
-    setContextUsage(percentage) {
-        if (this.isDisposed)
-            return;
-        const value = Number.isFinite(percentage) ? percentage : 0;
-        this.state.contextUsage = Math.max(0, Math.min(100, value));
-        // Don't schedule render - context display is handled by display.showStatusLine()
-    }
-    /**
-     * Set status message
-     */
-    setStatusMessage(message) {
-        if (this.isDisposed)
-            return;
-        this.state.statusMessage = this.sanitizeStatusMessage(message);
-        this.scheduleRender();
-    }
-    /**
-     * Queue a command for execution with overflow protection
-     */
-    queueCommand(text, type = 'request') {
-        if (this.isDisposed)
-            return null;
-        // Validate input
-        if (typeof text !== 'string')
-            return null;
-        const sanitizedText = this.sanitizeCommandText(text);
-        if (!sanitizedText)
-            return null;
-        // Check queue size limit
-        if (this.state.queuedCommands.length >= this.maxQueueSize) {
-            // Remove oldest non-slash commands to make room
-            const idx = this.state.queuedCommands.findIndex(c => c.type !== 'slash');
-            if (idx >= 0) {
-                this.state.queuedCommands.splice(idx, 1);
-            }
-            else {
-                // Queue is full of slash commands, reject
-                return null;
-            }
-        }
-        // Sanitize and truncate command text
-        const truncated = sanitizedText.slice(0, this.maxInputLength);
-        const previewSource = this.sanitizeInlineText(truncated);
-        const preview = previewSource.length > 60 ? `${previewSource.slice(0, 57)}...` : previewSource;
-        const cmd = {
-            id: `cmd-${++this.commandIdCounter}`,
-            text: truncated,
-            type,
-            timestamp: Date.now(),
-            preview,
-        };
-        this.state.queuedCommands.push(cmd);
-        this.scheduleRender();
-        if (this.onCommandQueued) {
-            try {
-                this.onCommandQueued(cmd);
-            }
-            catch (err) {
-                // Don't let callback errors break the queue
-                console.error('Error in onCommandQueued callback:', err);
-            }
-        }
-        return cmd;
-    }
-    /**
-     * Remove a command from the queue
-     */
-    dequeueCommand() {
-        if (this.isDisposed)
-            return undefined;
-        const cmd = this.state.queuedCommands.shift();
-        this.scheduleRender();
-        return cmd;
-    }
-    /**
-     * Clear the entire queue
-     */
-    clearQueue() {
-        if (this.isDisposed)
-            return;
-        this.state.queuedCommands = [];
-        this.scheduleRender();
-    }
-    /**
-     * Get current queue
-     */
-    getQueue() {
-        return [...this.state.queuedCommands];
-    }
-    /**
-     * Get queue length
-     */
-    getQueueLength() {
-        return this.state.queuedCommands.length;
-    }
-    /**
-     * Handle character input with validation
-     * Detects multiline paste and stores full content while showing summary
-     */
-    handleInput(char, options = {}) {
-        if (!this.isEnabled || this.isDisposed)
-            return;
-        if (typeof char !== 'string')
-            return;
-        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) {
-            this.lastPasteTime = Date.now(); // Guard against trailing newline triggering submit
-            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);
-        if (!sanitized)
-            return;
-        // Respect max input length
-        const availableSpace = this.maxInputLength - this.inputBuffer.length;
-        if (availableSpace <= 0)
-            return;
-        const chunk = sanitized.slice(0, availableSpace);
-        if (!chunk)
-            return;
-        // Insert character at cursor position
-        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
-     */
-    handleMultilinePaste(content) {
-        // Keep the original content for submission
-        const displaySafeContent = this.sanitizeMultilineForDisplay(content);
-        if (!displaySafeContent)
-            return;
-        const truncatedDisplay = displaySafeContent.slice(0, this.maxInputLength);
-        const truncatedOriginal = content.slice(0, this.maxInputLength);
-        this.pastedFullContent = truncatedOriginal;
-        this.isPastedBlock = true;
-        this.applyBufferChange(truncatedDisplay, truncatedDisplay.length);
-    }
-    /**
-     * Public helper for routing external multi-line pastes directly into the chat box
-     */
-    handlePaste(content) {
-        if (!content || !this.isEnabled || this.isDisposed)
-            return;
-        this.lastPasteTime = Date.now(); // Guard against trailing newline triggering submit
-        this.handleMultilinePaste(content);
-    }
-    /**
-     * Check if current input is a pasted block
-     */
-    hasPastedBlock() {
-        return this.isPastedBlock;
-    }
-    /**
-     * Get the full pasted content (for submission)
-     */
-    getPastedContent() {
-        return this.pastedFullContent;
-    }
-    /**
-     * Clear pasted block state
-     */
-    clearPastedBlock() {
-        this.isPastedBlock = false;
-        this.pastedFullContent = '';
-    }
-    /**
-     * Public method to clear pasted block state (for Ctrl+C clearing)
-     */
-    clearPastedBlockState() {
-        this.clearPastedBlock();
-        this.applyBufferChange('', 0);
-    }
-    /**
-     * Get terminal dimensions and a safe width for rendering input content.
-     */
-    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 };
-    }
-    /**
-     * Convert a wrapped line/column back to an absolute cursor index.
-     */
-    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 scrollBottom = Math.max(1, rows - this.reservedLines);
-            this.safeWrite(ANSI.SET_SCROLL_REGION(1, scrollBottom));
-        }
-    }
-    /**
-     * Handle backspace
-     */
-    handleBackspace() {
-        if (!this.isEnabled || this.isDisposed)
-            return;
-        this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
-        if (this.cursorPosition === 0)
-            return;
-        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
-     */
-    handleDelete() {
-        if (!this.isEnabled || this.isDisposed)
-            return;
-        this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
-        if (this.cursorPosition >= this.inputBuffer.length)
-            return;
-        const newBuffer = this.inputBuffer.slice(0, this.cursorPosition) +
-            this.inputBuffer.slice(this.cursorPosition + 1);
-        this.startManualEdit();
-        this.applyBufferChange(newBuffer, this.cursorPosition);
-    }
-    /**
-     * Handle cursor left
-     */
-    handleCursorLeft() {
-        if (this.isDisposed)
-            return;
-        const bounded = Math.min(this.cursorPosition, this.inputBuffer.length);
-        if (bounded > 0) {
-            this.setCursorPosition(bounded - 1);
-        }
-    }
-    /**
-     * Handle cursor right
-     */
-    handleCursorRight() {
-        if (this.isDisposed)
-            return;
-        const bounded = Math.min(this.cursorPosition, this.inputBuffer.length);
-        if (bounded < this.inputBuffer.length) {
-            this.setCursorPosition(bounded + 1);
-        }
-    }
-    /**
-     * Handle home key - move to start of current line (not start of buffer)
-     */
-    handleHome() {
-        if (this.isDisposed)
-            return;
-        // 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)
-     */
-    handleEnd() {
-        if (this.isDisposed)
-            return;
-        // 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)
-     */
-    handleNewline() {
-        if (!this.isEnabled || this.isDisposed)
-            return;
-        // Respect max input length
-        if (this.inputBuffer.length >= this.maxInputLength)
-            return;
-        this.startManualEdit();
-        this.applyBufferChange(this.inputBuffer.slice(0, this.cursorPosition) +
-            '\n' +
-            this.inputBuffer.slice(this.cursorPosition), this.cursorPosition + 1);
-    }
-    /**
-     * 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 (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
-        if (this.inputHistory.length === 0)
-            return;
-        // If at current input, save it temporarily
-        if (this.historyIndex === -1) {
-            this.tempCurrentInput = this.inputBuffer;
-        }
-        // Move up in history
-        if (this.historyIndex < this.inputHistory.length - 1) {
-            this.historyIndex++;
-            const nextBuffer = this.inputHistory[this.inputHistory.length - 1 - this.historyIndex] || '';
-            this.startManualEdit();
-            this.applyBufferChange(nextBuffer, nextBuffer.length);
-        }
-    }
-    /**
-     * 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 (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--;
-            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;
-            const restored = this.tempCurrentInput;
-            this.startManualEdit();
-            this.applyBufferChange(restored, restored.length);
-        }
-    }
-    /**
-     * Handle Ctrl+U - delete from cursor to start of line
-     */
-    handleDeleteToStart() {
-        if (this.isDisposed)
-            return;
-        if (this.cursorPosition === 0)
-            return;
-        this.startManualEdit();
-        const newBuffer = this.inputBuffer.slice(this.cursorPosition);
-        this.applyBufferChange(newBuffer, 0);
-    }
-    /**
-     * Handle Ctrl+K - delete from cursor to end of line
-     */
-    handleDeleteToEnd() {
-        if (this.isDisposed)
-            return;
-        if (this.cursorPosition >= this.inputBuffer.length)
-            return;
-        this.startManualEdit();
-        const newBuffer = this.inputBuffer.slice(0, this.cursorPosition);
-        this.applyBufferChange(newBuffer, this.cursorPosition);
-    }
-    /**
-     * Handle Ctrl+W - delete word before cursor
-     */
-    handleDeleteWord() {
-        if (this.isDisposed)
-            return;
-        if (this.cursorPosition === 0)
-            return;
-        // 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.isWhitespace(this.inputBuffer[pos - 1])) {
-            pos--;
-        }
-        // Find start of word
-        while (pos > 0 && !this.isWhitespace(this.inputBuffer[pos - 1])) {
-            pos--;
-        }
-        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
-     */
-    handleWordLeft() {
-        if (this.isDisposed)
-            return;
-        if (this.cursorPosition === 0)
-            return;
-        let pos = this.cursorPosition;
-        // Skip any spaces before cursor
-        while (pos > 0 && this.isWhitespace(this.inputBuffer[pos - 1])) {
-            pos--;
-        }
-        // Find start of word
-        while (pos > 0 && !this.isWhitespace(this.inputBuffer[pos - 1])) {
-            pos--;
-        }
-        this.setCursorPosition(pos);
-    }
-    /**
-     * Handle Alt+Right - move cursor to next word
-     */
-    handleWordRight() {
-        if (this.isDisposed)
-            return;
-        if (this.cursorPosition >= this.inputBuffer.length)
-            return;
-        let pos = this.cursorPosition;
-        // Skip current word
-        while (pos < this.inputBuffer.length && !this.isWhitespace(this.inputBuffer[pos])) {
-            pos++;
-        }
-        // Skip any spaces
-        while (pos < this.inputBuffer.length && this.isWhitespace(this.inputBuffer[pos])) {
-            pos++;
-        }
-        this.setCursorPosition(pos);
-    }
-    /**
-     * Add input to history (call after successful submit)
-     */
-    addToHistory(input) {
-        if (!input || this.isDisposed)
-            return;
-        // Don't add duplicates of the last entry
-        if (this.inputHistory.length > 0 && this.inputHistory[this.inputHistory.length - 1] === input) {
-            return;
-        }
-        this.inputHistory.push(input);
-        // Trim history if too large
-        if (this.inputHistory.length > this.maxHistorySize) {
-            this.inputHistory = this.inputHistory.slice(-this.maxHistorySize);
-        }
-        // Reset history navigation state
-        this.historyIndex = -1;
-        this.tempCurrentInput = '';
-    }
-    /**
-     * Handle enter/submit
-     * If there's pasted content, sends the full content (not the summary)
-     */
-    handleSubmit() {
-        if (!this.isEnabled || this.isDisposed)
-            return null;
-        // Guard: Ignore submit if it comes too soon after a paste (trailing newline issue)
-        const timeSincePaste = Date.now() - this.lastPasteTime;
-        if (timeSincePaste < this.pasteSubmitGuardMs) {
-            return null;
-        }
-        // If we have pasted content, use the full content instead of the display summary
-        let input;
-        if (this.isPastedBlock && this.pastedFullContent) {
-            input = this.pastedFullContent;
-        }
-        else {
-            input = this.sanitizeCommandText(this.inputBuffer);
-        }
-        if (!input)
-            return null;
-        // Add to history before processing (store summary for paste, not full content)
-        const historyEntry = this.isPastedBlock
-            ? this.inputBuffer // Store the summary in history
-            : input;
-        this.addToHistory(historyEntry);
-        // If processing, queue the command instead of submitting
-        if (this.state.isProcessing) {
-            const type = input.startsWith('/') ? 'slash' : 'request';
-            const queued = this.queueCommand(input, type);
-            if (!queued) {
-                this.setStatusMessage(`Queue is full (${this.maxQueueSize}). Submit after current task or clear queued items.`);
-                return null;
-            }
-            this.clearInput();
-            return null;
-        }
-        // Clear input and paste state, then notify
-        this.clearInput();
-        if (this.onInputSubmit) {
-            this.onInputSubmit(input);
-        }
-        return input;
-    }
-    /**
-     * Clear input buffer
-     */
-    clearInput() {
-        if (this.isDisposed)
-            return;
-        // Reset history navigation
-        this.historyIndex = -1;
-        this.tempCurrentInput = '';
-        // Clear paste state
-        this.clearPastedBlock();
-        this.applyBufferChange('', 0);
-    }
-    /**
-     * Set input text and optionally cursor position (for readline sync)
-     * Note: Does NOT trigger render - readline handles display during input
-     */
-    setInput(text, cursorPos) {
-        if (this.isDisposed)
-            return;
-        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
-    }
-    /**
-     * Get current input
-     */
-    getInput() {
-        return this.inputBuffer;
-    }
-    /**
-     * Schedule a render on next tick (debounced and throttled)
-     */
-    scheduleRender() {
-        if (this.renderScheduled || !this.supportsRendering())
-            return;
-        const now = Date.now();
-        const timeSinceLastRender = now - this.lastRenderTime;
-        // Throttle renders to prevent terminal flooding
-        if (timeSinceLastRender < this.renderThrottleMs) {
-            this.renderScheduled = true;
-            setTimeout(() => {
-                this.renderScheduled = false;
-                if (!this.isDisposed) {
-                    this.render();
-                }
-            }, this.renderThrottleMs - timeSinceLastRender);
-            return;
-        }
-        this.renderScheduled = true;
-        queueMicrotask(() => {
-            this.renderScheduled = false;
-            if (!this.isDisposed) {
-                this.render();
-            }
-        });
-    }
-    /**
-     * Render the chat box with cursor tracking and background.
-     *
-     * Always uses renderPersistentInput for consistent display:
-     * - Dark background to denote user typing area
-     * - Block cursor that tracks actual cursor position
-     * - Multi-line support with proper vertical layout
-     */
-    render() {
-        if (!this.state.isVisible || !this.supportsRendering())
-            return;
-        // Always use persistent input renderer for consistent cursor and background
-        this.renderPersistentInput();
-    }
-    /**
-     * Clear the pinned area
-     */
-    clear() {
-        if (!this.supportsRendering())
-            return;
-        // If we rendered a multi-line box, move up and clear it
-        if (this._lastRenderedHeight > 1) {
-            this.safeWrite(ANSI.MOVE_UP(this._lastRenderedHeight - 1));
-        }
-        this.safeWrite(`\r${ANSI.CLEAR_TO_END}`);
-        this._lastRenderedHeight = 0;
-    }
-    /**
-     * Show the chat box
-     */
-    show() {
-        if (this.isDisposed)
-            return;
-        this.state.isVisible = true;
-        this.render();
-    }
-    /**
-     * Hide the chat box
-     */
-    hide() {
-        if (this.isDisposed)
-            return;
-        this.state.isVisible = false;
-        this.clear();
-    }
-    /**
-     * Get current state
-     */
-    getState() {
-        return { ...this.state };
-    }
-    /**
-     * Handle terminal resize - update scroll region if active
-     */
-    handleResize() {
-        // Invalidate render state to force re-render with new dimensions
-        this.invalidateRenderedState();
-        const wasActive = this.scrollRegionActive;
-        if (wasActive) {
-            // Reset scroll region before recalculating dimensions
-            this.safeWrite(ANSI.RESET_SCROLL_REGION);
-            this.scrollRegionActive = false;
-        }
-        // Recompute reserved lines for the new terminal size
-        this.updateReservedLinesForContent();
-        if (wasActive) {
-            // Re-enable scroll region with the updated height
-            this.enableScrollRegion();
-        }
-        this.scheduleRender();
-    }
-    /**
-     * Get number of reserved lines at bottom
-     */
-    getReservedLines() {
-        return this.reservedLines;
-    }
-    /**
-     * Get last rendered height (for layout calculations)
-     */
-    getLastRenderedHeight() {
-        return this._lastRenderedHeight;
-    }
-    /**
-     * Dispose and cleanup
-     */
-    dispose() {
-        if (this.isDisposed)
-            return;
-        // Clean up pending render timeout
-        if (this.pendingAfterWriteRender) {
-            clearTimeout(this.pendingAfterWriteRender);
-            this.pendingAfterWriteRender = null;
-        }
-        // Clean up output interceptor registration
-        if (this.outputInterceptorCleanup) {
-            this.outputInterceptorCleanup();
-            this.outputInterceptorCleanup = undefined;
-        }
-        try {
-            this.clear();
-        }
-        catch {
-            // Ignore errors during cleanup
-        }
-        this.isDisposed = true;
-        this.isEnabled = false;
-        this.inputBuffer = '';
-        this.state.queuedCommands = [];
-        this.onCommandQueued = undefined;
-        this.onInputSubmit = undefined;
-    }
-    /**
-     * Check if disposed
-     */
-    isActive() {
-        return !this.isDisposed && this.isEnabled;
-    }
-    /**
-     * 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();
-    }
-    /**
-     * Reset state to clean defaults
-     */
-    reset() {
-        if (this.isDisposed)
-            return;
-        this.inputBuffer = '';
-        this.cursorPosition = 0;
-        this.state = {
-            isProcessing: false,
-            queuedCommands: [],
-            currentInput: '',
-            contextUsage: 0,
-            statusMessage: null,
-            isVisible: true,
-        };
-        this.invalidateRenderedState();
-        this.scheduleRender();
-    }
-}
-//# sourceMappingURL=persistentPrompt.js.map