erosolar-cli 1.7.429 → 1.7.430

package/dist/shell/terminalInput.js

@@ -1,2699 +0,0 @@
-/**
- * TerminalInput - Clean, unified terminal input handling
- *
- * Design principles:
- * - Single source of truth for input state
- * - Hybrid floating/scroll approach:
- *   - Initially: chat box floats below content
- *   - When terminal fills: scroll region activates, chat box pins to bottom
- * - Native bracketed paste support (no heuristics)
- * - Clean cursor model with render-time wrapping
- * - State machine for different input modes
- * - No readline dependency for display
- * - Text selection enabled: mouse tracking disabled by default to preserve
- *   native terminal text selection and copy/paste functionality
- * - Scrollback navigation via keyboard: PageUp/PageDown, Ctrl+Home/End
- */
-import { EventEmitter } from 'node:events';
-import { isMultilinePaste } from '../core/multilinePasteHandler.js';
-import { writeLock } from '../ui/writeLock.js';
-import { renderDivider, renderStatusLine, renderStatusLines } from '../ui/unified/layout.js';
-import { isStreamingMode } from '../ui/globalWriteLock.js';
-import { formatThinking } from '../ui/toolDisplay.js';
-import { theme } from '../ui/theme.js';
-import { formatEditModeIndicator } from '../ui/shortcutsHelp.js';
-// ANSI escape codes
-const ESC = {
-    // Cursor control
-    SAVE: '\x1b7',
-    RESTORE: '\x1b8',
-    HIDE: '\x1b[?25l',
-    SHOW: '\x1b[?25h',
-    TO: (row, col) => `\x1b[${row};${col}H`,
-    TO_COL: (col) => `\x1b[${col}G`,
-    // Line control
-    CLEAR_LINE: '\x1b[2K',
-    CLEAR_TO_END: '\x1b[0J',
-    // Screen control
-    HOME: '\x1b[H',
-    CLEAR_SCREEN: '\x1b[2J',
-    // Alternate screen buffer (like vim/tmux)
-    ENTER_ALT_SCREEN: '\x1b[?1049h',
-    EXIT_ALT_SCREEN: '\x1b[?1049l',
-    // Scroll region
-    SET_SCROLL: (top, bottom) => `\x1b[${top};${bottom}r`,
-    RESET_SCROLL: '\x1b[r',
-    // Style
-    RESET: '\x1b[0m',
-    DIM: '\x1b[2m',
-    REVERSE: '\x1b[7m',
-    BOLD: '\x1b[1m',
-    BG_DARK: '\x1b[48;5;236m', // Dark gray background
-    // Bracketed paste mode
-    PASTE_ENABLE: '\x1b[?2004h',
-    PASTE_DISABLE: '\x1b[?2004l',
-    PASTE_START: '\x1b[200~',
-    PASTE_END: '\x1b[201~',
-    // Mouse tracking - Button events only (allows Shift+drag for text selection)
-    // Mode 1000: Track button presses/releases (wheel events included)
-    // Mode 1006: SGR extended format for better coordinate handling
-    // Note: NOT using mode 1003 (all motion) to preserve terminal text selection
-    MOUSE_ENABLE: '\x1b[?1000h\x1b[?1006h', // Enable button tracking + SGR mode
-    MOUSE_DISABLE: '\x1b[?1006l\x1b[?1000l', // Disable mouse tracking
-};
-/**
- * Unified terminal input handler
- */
-export class TerminalInput extends EventEmitter {
-    out;
-    config;
-    // Core state
-    buffer = '';
-    cursor = 0;
-    mode = 'idle';
-    // Paste accumulation
-    pasteBuffer = '';
-    isPasting = false;
-    pastePlaceholders = [];
-    pasteCounter = 0;
-    // History
-    history = [];
-    historyIndex = -1;
-    tempInput = '';
-    maxHistory = 100;
-    // Queue for streaming mode
-    queue = [];
-    queueIdCounter = 0;
-    // Display state
-    statusMessage = null;
-    overrideStatusMessage = null; // Secondary status (warnings, etc.)
-    streamingLabel = null; // Streaming progress indicator
-    metaElapsedSeconds = null; // Optional elapsed time for header line
-    metaTokensUsed = null; // Optional token usage
-    metaTokenLimit = null; // Optional token window
-    metaThinkingMs = null; // Optional thinking duration
-    metaThinkingHasContent = false; // Whether collapsed thinking content exists
-    lastRenderContent = '';
-    lastRenderCursor = -1;
-    renderDirty = false;
-    isRendering = false;
-    // Lifecycle
-    disposed = false;
-    enabled = true;
-    contextUsage = null;
-    contextAutoCompactThreshold = 90;
-    // Track current content row (starts at top, moves down)
-    contentRow = 1;
-    // Track if scroll region is currently active
-    scrollRegionActive = false;
-    thinkingModeLabel = null;
-    // Scrollback buffer
-    scrollbackBuffer = [];
-    maxScrollbackLines = 10000;
-    scrollbackOffset = 0; // 0 = at bottom (live), > 0 = scrolled up
-    isInScrollbackMode = false;
-    scrollIndicatorFrame = 0; // For animated scroll indicator
-    // Alternate screen state
-    alternateScreenActive = false;
-    editMode = 'display-edits';
-    verificationEnabled = false;
-    autoContinueEnabled = false;
-    verificationHotkey = 'ctrl+shift+v';
-    autoContinueHotkey = 'ctrl+shift+c';
-    thinkingHotkey = 'tab';
-    modelLabel = null;
-    providerLabel = null;
-    // Streaming render throttle
-    lastStreamingRender = 0;
-    streamingRenderInterval = 250; // ms between renders during streaming
-    streamingRenderTimer = null;
-    // Command autocomplete state
-    commandSuggestions = [];
-    showingSuggestions = false;
-    selectedSuggestionIndex = 0;
-    maxVisibleSuggestions = 10;
-    suggestionRenderState = null;
-    lastSuggestionStartRow = null;
-    lastChatBoxStartRow = null;
-    lastChatBoxHeight = 0;
-    displayInterceptorDispose = null;
-    constructor(writeStream = process.stdout, config = {}) {
-        super();
-        this.out = writeStream;
-        this.config = {
-            maxLines: config.maxLines ?? 1000,
-            maxLength: config.maxLength ?? 10000,
-            maxQueueSize: config.maxQueueSize ?? 100,
-            promptChar: config.promptChar ?? '> ',
-            continuationChar: config.continuationChar ?? '│ ',
-        };
-    }
-    // ===========================================================================
-    // PUBLIC API
-    // ===========================================================================
-    /**
-     * Enable bracketed paste mode in terminal
-     */
-    enableBracketedPaste() {
-        if (this.isTTY()) {
-            this.write(ESC.PASTE_ENABLE);
-        }
-    }
-    /**
-     * Disable bracketed paste mode
-     */
-    disableBracketedPaste() {
-        if (this.isTTY()) {
-            this.write(ESC.PASTE_DISABLE);
-        }
-    }
-    /**
-     * Enable mouse tracking in terminal
-     */
-    enableMouseTracking() {
-        if (this.isTTY()) {
-            this.write(ESC.MOUSE_ENABLE);
-        }
-    }
-    /**
-     * Disable mouse tracking
-     */
-    disableMouseTracking() {
-        if (this.isTTY()) {
-            this.write(ESC.MOUSE_DISABLE);
-        }
-    }
-    /**
-     * Process raw terminal data (handles bracketed paste sequences and mouse events)
-     * Returns true if the data was consumed (paste sequence)
-     */
-    processRawData(data) {
-        // Handle ALL mouse events in the data (SGR mode: \x1b[<button;x;yM or m)
-        // Process repeatedly until no more mouse events
-        const mousePattern = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
-        let remaining = data;
-        let hadMouseEvents = false;
-        // Remove all mouse escape sequences from the data
-        let match;
-        while ((match = mousePattern.exec(data)) !== null) {
-            const button = parseInt(match[1], 10);
-            const x = parseInt(match[2], 10);
-            const y = parseInt(match[3], 10);
-            this.handleMouseEvent(button, x, y, match[4]);
-            hadMouseEvents = true;
-        }
-        if (hadMouseEvents) {
-            // Strip all mouse sequences from the data
-            remaining = data.replace(/\x1b\[<\d+;\d+;\d+[Mm]/g, '');
-            if (!remaining) {
-                return { consumed: true, passthrough: '' };
-            }
-            // If there's remaining content, continue processing it
-        }
-        // Check for paste start
-        if (remaining.includes(ESC.PASTE_START)) {
-            this.isPasting = true;
-            this.pasteBuffer = '';
-            // Extract content after paste start
-            const startIdx = remaining.indexOf(ESC.PASTE_START) + ESC.PASTE_START.length;
-            const afterStart = remaining.slice(startIdx);
-            // Check if paste end is also in this chunk
-            if (afterStart.includes(ESC.PASTE_END)) {
-                const endIdx = afterStart.indexOf(ESC.PASTE_END);
-                this.pasteBuffer = afterStart.slice(0, endIdx);
-                this.finishPaste();
-                return { consumed: true, passthrough: afterStart.slice(endIdx + ESC.PASTE_END.length) };
-            }
-            this.pasteBuffer = afterStart;
-            return { consumed: true, passthrough: '' };
-        }
-        // Accumulating paste
-        if (this.isPasting) {
-            if (remaining.includes(ESC.PASTE_END)) {
-                const endIdx = remaining.indexOf(ESC.PASTE_END);
-                this.pasteBuffer += remaining.slice(0, endIdx);
-                this.finishPaste();
-                return { consumed: true, passthrough: remaining.slice(endIdx + ESC.PASTE_END.length) };
-            }
-            this.pasteBuffer += remaining;
-            return { consumed: true, passthrough: '' };
-        }
-        // If we processed mouse events but have remaining text, return it as passthrough
-        if (hadMouseEvents && remaining) {
-            return { consumed: true, passthrough: remaining };
-        }
-        return { consumed: false, passthrough: remaining };
-    }
-    /**
-     * Handle mouse events (button, x, y coordinates, action)
-     */
-    handleMouseEvent(button, x, y, action) {
-        // Mouse wheel events: button 64 = scroll up, button 65 = scroll down
-        if (button === 64) {
-            // Scroll up (3 lines per wheel tick)
-            this.scrollUp(3);
-            return;
-        }
-        if (button === 65) {
-            // Scroll down (3 lines per wheel tick)
-            this.scrollDown(3);
-            return;
-        }
-        // Left-click selection inside the command suggestions menu
-        if (button === 0 && action === 'M') {
-            if (this.handleSuggestionClick(y)) {
-                return;
-            }
-            // No other left-click handling needed; fall through to consume silently
-        }
-        // Left button (0), middle button (1), right button (2)
-        // These are captured by SGR mouse tracking but we don't need to handle them
-        // Just consume silently - the escape sequence has already been processed
-        // The 'M' action is press, 'm' is release
-        if (button <= 2) {
-            // Silently consume click events to prevent artifacts
-            // Left clicks (button=0) in the input area could focus the input
-            // but terminal apps typically handle this natively
-            return;
-        }
-        // Button with motion flag (button + 32) - drag events
-        if (button >= 32 && button <= 34) {
-            // Drag events - consume silently
-            return;
-        }
-        // Any other unrecognized button - log for debugging in dev mode
-        // but don't output anything to prevent artifacts
-    }
-    /**
-     * Handle a keypress event
-     */
-    handleKeypress(str, key) {
-        if (this.disposed || !this.enabled)
-            return;
-        const normalizedName = key?.name ??
-            this.getArrowKeyName(key?.sequence ?? str) ??
-            this.getFallbackKeyName(str);
-        const effectiveKey = normalizedName ? { ...key, name: normalizedName } : key;
-        const safeStr = (this.isArrowEscapeFragment(str) || this.isBackspaceChar(str)) ? undefined : str;
-        let handled = false;
-        // Handle control keys
-        if (effectiveKey?.ctrl) {
-            handled = this.handleCtrlKey(effectiveKey);
-            if (handled) {
-                return;
-            }
-        }
-        // Handle meta/alt keys
-        if (effectiveKey?.meta) {
-            this.handleMetaKey(effectiveKey);
-            return;
-        }
-        // Handle special keys
-        if (effectiveKey?.name) {
-            const handled = this.handleSpecialKey(safeStr, effectiveKey);
-            if (handled)
-                return;
-        }
-        // Ignore orphaned escape fragments that sometimes leak through (e.g., "[D" from arrow keys)
-        if (safeStr && this.isOrphanedEscapeSequence(safeStr, effectiveKey)) {
-            return;
-        }
-        // Ignore stray control characters that weren't mapped to a key
-        if (safeStr && this.isStandaloneControlChar(safeStr)) {
-            return;
-        }
-        // Insert printable characters
-        if (safeStr && !effectiveKey?.ctrl && !effectiveKey?.meta) {
-            this.insertText(safeStr);
-        }
-    }
-    /**
-     * Set the input mode
-     *
-     * Content flows naturally - no scroll region pinning.
-     */
-    setMode(mode) {
-        const prevMode = this.mode;
-        this.mode = mode;
-        if (mode === 'streaming' && prevMode !== 'streaming') {
-            this.resetStreamingRenderThrottle();
-            this.renderDirty = true;
-            this.render();
-        }
-        else if (mode !== 'streaming' && prevMode === 'streaming') {
-            this.resetStreamingRenderThrottle();
-            this.renderDirty = true;
-            this.render();
-        }
-    }
-    /**
-     * Legacy method - no longer used (content flows naturally).
-     * @deprecated Use setContentRow instead
-     */
-    setPinnedHeaderLines(_count) {
-        // No-op: scroll region pinning removed
-    }
-    /**
-     * Get current mode
-     */
-    getMode() {
-        return this.mode;
-    }
-    /**
-     * Get the current buffer content (may contain placeholders for pasted text)
-     */
-    getBuffer() {
-        return this.buffer;
-    }
-    /**
-     * Get the actual text with paste placeholders expanded
-     */
-    getText() {
-        return this.assembleText();
-    }
-    /**
-     * Set buffer content
-     */
-    setBuffer(text, cursorPos) {
-        this.pastePlaceholders = [];
-        const clean = this.sanitize(text).slice(0, this.config.maxLength);
-        this.buffer = clean;
-        this.cursor = cursorPos ?? this.buffer.length;
-        this.clampCursor();
-        this.scheduleRender();
-    }
-    /**
-     * Clear the buffer
-     */
-    clear() {
-        this.buffer = '';
-        this.cursor = 0;
-        this.historyIndex = -1;
-        this.tempInput = '';
-        this.pastePlaceholders = [];
-        this.showingSuggestions = false;
-        this.selectedSuggestionIndex = 0;
-        this.scheduleRender();
-    }
-    /**
-     * Get queued inputs
-     */
-    getQueue() {
-        return [...this.queue];
-    }
-    /**
-     * Dequeue next input
-     */
-    dequeue() {
-        const item = this.queue.shift();
-        this.scheduleRender();
-        return item;
-    }
-    /**
-     * Clear the queue
-     */
-    clearQueue() {
-        this.queue = [];
-        this.scheduleRender();
-    }
-    // ===========================================================================
-    // COMMAND AUTOCOMPLETE
-    // ===========================================================================
-    /**
-     * Set available commands for autocomplete.
-     * Call this once during initialization with all slash commands.
-     */
-    setAvailableCommands(commands) {
-        this.commandSuggestions = commands;
-    }
-    /**
-     * Check if command suggestions are currently being shown
-     */
-    isShowingSuggestions() {
-        return this.showingSuggestions;
-    }
-    /**
-     * Get filtered commands based on current input
-     */
-    getFilteredCommands() {
-        const input = this.buffer.trim().toLowerCase();
-        // Only show suggestions if buffer starts with "/"
-        if (!input.startsWith('/')) {
-            return [];
-        }
-        // If just "/", show all commands
-        if (input === '/') {
-            return this.commandSuggestions;
-        }
-        // Filter commands that match the typed prefix
-        return this.commandSuggestions.filter(cmd => cmd.command.toLowerCase().startsWith(input));
-    }
-    /**
-     * Update suggestion visibility based on current buffer
-     */
-    updateSuggestionVisibility() {
-        const filtered = this.getFilteredCommands();
-        const shouldShow = filtered.length > 0 && this.buffer.startsWith('/');
-        if (shouldShow !== this.showingSuggestions) {
-            this.showingSuggestions = shouldShow;
-            this.selectedSuggestionIndex = 0;
-            this.scheduleRender();
-        }
-        else if (shouldShow) {
-            // Clamp selection index
-            this.selectedSuggestionIndex = Math.min(this.selectedSuggestionIndex, Math.max(0, filtered.length - 1));
-        }
-    }
-    /**
-     * Handle selecting a suggestion (Enter key or click)
-     */
-    selectSuggestion(options = {}) {
-        const { submit = false } = options;
-        if (!this.showingSuggestions)
-            return false;
-        const filtered = this.getFilteredCommands();
-        if (filtered.length === 0)
-            return false;
-        const selected = filtered[this.selectedSuggestionIndex];
-        if (!selected)
-            return false;
-        // Replace buffer with selected command
-        const nextBuffer = submit ? selected.command : `${selected.command} `;
-        this.buffer = nextBuffer;
-        this.cursor = this.buffer.length;
-        this.showingSuggestions = false;
-        this.scheduleRender();
-        if (submit) {
-            this.submit();
-        }
-        return true;
-    }
-    /**
-     * Move selection up in suggestions list
-     */
-    moveSuggestionUp() {
-        if (!this.showingSuggestions)
-            return false;
-        const filtered = this.getFilteredCommands();
-        if (filtered.length === 0)
-            return false;
-        this.selectedSuggestionIndex = Math.max(0, this.selectedSuggestionIndex - 1);
-        this.scheduleRender();
-        return true;
-    }
-    /**
-     * Move selection down in suggestions list
-     */
-    moveSuggestionDown() {
-        if (!this.showingSuggestions)
-            return false;
-        const filtered = this.getFilteredCommands();
-        if (filtered.length === 0)
-            return false;
-        this.selectedSuggestionIndex = Math.min(filtered.length - 1, this.selectedSuggestionIndex + 1);
-        this.scheduleRender();
-        return true;
-    }
-    /**
-     * Handle mouse selection inside the suggestions list.
-     * Returns true if the click selected a command.
-     */
-    handleSuggestionClick(clickRow) {
-        if (!this.showingSuggestions || !this.suggestionRenderState)
-            return false;
-        if (this.lastSuggestionStartRow === null)
-            return false;
-        // First line is the header; suggestions start on the next row
-        const relativeRow = clickRow - this.lastSuggestionStartRow - 1;
-        if (relativeRow < 0)
-            return false;
-        const { startIdx, visibleCount } = this.suggestionRenderState;
-        if (relativeRow >= visibleCount)
-            return false;
-        this.selectedSuggestionIndex = startIdx + relativeRow;
-        this.selectSuggestion();
-        return true;
-    }
-    /**
-     * Cancel suggestion display (Escape)
-     */
-    cancelSuggestions() {
-        if (!this.showingSuggestions)
-            return false;
-        this.showingSuggestions = false;
-        this.scheduleRender();
-        return true;
-    }
-    /**
-     * Build command suggestion display lines
-     */
-    buildSuggestionLines(width) {
-        this.suggestionRenderState = null;
-        if (!this.showingSuggestions)
-            return [];
-        const filtered = this.getFilteredCommands();
-        if (filtered.length === 0)
-            return [];
-        const lines = [];
-        const maxDisplay = Math.min(filtered.length, this.maxVisibleSuggestions);
-        // Calculate scroll window for long lists
-        let startIdx = 0;
-        if (filtered.length > maxDisplay) {
-            // Keep selected item in view with some context
-            const padding = Math.floor(maxDisplay / 3);
-            startIdx = Math.max(0, this.selectedSuggestionIndex - padding);
-            startIdx = Math.min(startIdx, filtered.length - maxDisplay);
-        }
-        this.suggestionRenderState = {
-            startIdx,
-            visibleCount: Math.min(maxDisplay, Math.max(0, filtered.length - startIdx))
-        };
-        // Header with navigation hint - keep it short
-        lines.push(theme.ui.muted(`Commands (↑↓ Enter to run · Tab to fill)`));
-        // Render visible suggestions
-        for (let i = 0; i < maxDisplay; i++) {
-            const idx = startIdx + i;
-            if (idx >= filtered.length)
-                break;
-            const cmd = filtered[idx];
-            const isSelected = idx === this.selectedSuggestionIndex;
-            // Format: [indicator] /command  description
-            const indicator = isSelected ? theme.accent('▸') : ' ';
-            // Command name - use available space wisely
-            const cmdWidth = Math.min(20, Math.max(12, Math.floor(width * 0.3)));
-            const cmdText = isSelected
-                ? theme.accent(cmd.command.padEnd(cmdWidth))
-                : theme.primary(cmd.command.padEnd(cmdWidth));
-            // Description - use remaining space
-            const descMaxLen = Math.max(20, width - cmdWidth - 4);
-            const desc = cmd.description.length > descMaxLen
-                ? cmd.description.slice(0, descMaxLen - 1) + '…'
-                : cmd.description;
-            const descText = isSelected
-                ? theme.info(desc)
-                : theme.ui.muted(desc);
-            lines.push(`${indicator}${cmdText} ${descText}`);
-        }
-        // Show scroll indicator if needed
-        if (filtered.length > maxDisplay) {
-            const position = startIdx + 1;
-            const endPos = Math.min(startIdx + maxDisplay, filtered.length);
-            lines.push(theme.ui.muted(`  [${position}-${endPos} of ${filtered.length}]`));
-        }
-        return lines;
-    }
-    /**
-     * Update the inline status message shown before the prompt (e.g., streaming heartbeat).
-     */
-    setStatusMessage(message) {
-        const normalized = message ? message.replace(/\s+/g, ' ').trim() : null;
-        const maxLen = 48;
-        const next = normalized && normalized.length > maxLen
-            ? `${normalized.slice(0, maxLen - 3)}...`
-            : normalized;
-        if (this.statusMessage === next) {
-            return;
-        }
-        this.statusMessage = next;
-        // Schedule render - throttling during streaming is handled in render()
-        this.scheduleRender();
-    }
-    /**
-     * Set an override status message (warnings, errors) that shows alongside the main status.
-     * Both streaming label and override can be displayed simultaneously.
-     */
-    setOverrideStatus(message) {
-        const normalized = message ? message.replace(/\s+/g, ' ').trim() : null;
-        const maxLen = 32;
-        const next = normalized && normalized.length > maxLen
-            ? `${normalized.slice(0, maxLen - 3)}...`
-            : normalized;
-        if (this.overrideStatusMessage === next) {
-            return;
-        }
-        this.overrideStatusMessage = next;
-        this.scheduleRender();
-    }
-    /**
-     * Set the streaming label (e.g., "Streaming response...").
-     * Can be shown alongside override status messages.
-     */
-    setStreamingLabel(label) {
-        const normalized = label ? label.replace(/\s+/g, ' ').trim() : null;
-        const maxLen = 24;
-        const next = normalized && normalized.length > maxLen
-            ? `${normalized.slice(0, maxLen - 3)}...`
-            : normalized;
-        if (this.streamingLabel === next) {
-            return;
-        }
-        this.streamingLabel = next;
-        this.scheduleRender();
-    }
-    /**
-     * Surface meta status just above the divider (e.g., elapsed time or token usage).
-     */
-    setMetaStatus(meta) {
-        const nextElapsed = typeof meta.elapsedSeconds === 'number' && Number.isFinite(meta.elapsedSeconds) && meta.elapsedSeconds >= 0
-            ? Math.floor(meta.elapsedSeconds)
-            : null;
-        const nextTokens = typeof meta.tokensUsed === 'number' && Number.isFinite(meta.tokensUsed) && meta.tokensUsed >= 0
-            ? Math.floor(meta.tokensUsed)
-            : null;
-        const nextLimit = typeof meta.tokenLimit === 'number' && Number.isFinite(meta.tokenLimit) && meta.tokenLimit > 0
-            ? Math.floor(meta.tokenLimit)
-            : null;
-        const nextThinking = typeof meta.thinkingMs === 'number' && Number.isFinite(meta.thinkingMs) && meta.thinkingMs >= 0
-            ? Math.floor(meta.thinkingMs)
-            : null;
-        const nextThinkingHasContent = !!meta.thinkingHasContent;
-        if (this.metaElapsedSeconds === nextElapsed &&
-            this.metaTokensUsed === nextTokens &&
-            this.metaTokenLimit === nextLimit &&
-            this.metaThinkingMs === nextThinking &&
-            this.metaThinkingHasContent === nextThinkingHasContent) {
-            return;
-        }
-        this.metaElapsedSeconds = nextElapsed;
-        this.metaTokensUsed = nextTokens;
-        this.metaTokenLimit = nextLimit;
-        this.metaThinkingMs = nextThinking;
-        this.metaThinkingHasContent = nextThinkingHasContent;
-        this.scheduleRender();
-    }
-    /**
-     * Keep mode toggles (verification/auto-continue) visible in the control bar.
-     * Hotkey labels remain stable so the bar looks the same before/during streaming.
-     */
-    setModeToggles(options) {
-        const nextVerification = !!options.verificationEnabled;
-        const nextAutoContinue = !!options.autoContinueEnabled;
-        const nextVerifyHotkey = options.verificationHotkey ?? this.verificationHotkey;
-        const nextAutoHotkey = options.autoContinueHotkey ?? this.autoContinueHotkey;
-        const nextThinkingHotkey = options.thinkingHotkey ?? this.thinkingHotkey;
-        const nextThinkingLabel = options.thinkingModeLabel === undefined ? this.thinkingModeLabel : (options.thinkingModeLabel || null);
-        if (this.verificationEnabled === nextVerification &&
-            this.autoContinueEnabled === nextAutoContinue &&
-            this.verificationHotkey === nextVerifyHotkey &&
-            this.autoContinueHotkey === nextAutoHotkey &&
-            this.thinkingHotkey === nextThinkingHotkey &&
-            this.thinkingModeLabel === nextThinkingLabel) {
-            return;
-        }
-        this.verificationEnabled = nextVerification;
-        this.autoContinueEnabled = nextAutoContinue;
-        this.verificationHotkey = nextVerifyHotkey;
-        this.autoContinueHotkey = nextAutoHotkey;
-        this.thinkingHotkey = nextThinkingHotkey;
-        this.thinkingModeLabel = nextThinkingLabel;
-        this.scheduleRender();
-    }
-    /**
-     * Clear all status messages at once (convenience method).
-     */
-    clearAllStatus() {
-        this.statusMessage = null;
-        this.overrideStatusMessage = null;
-        this.streamingLabel = null;
-        this.scheduleRender();
-    }
-    /**
-     * Surface model/provider context in the controls bar.
-     */
-    setModelContext(options) {
-        const nextModel = options.model?.trim() || null;
-        const nextProvider = options.provider?.trim() || null;
-        if (this.modelLabel === nextModel && this.providerLabel === nextProvider) {
-            return;
-        }
-        this.modelLabel = nextModel;
-        this.providerLabel = nextProvider;
-        this.scheduleRender();
-    }
-    /**
-     * Render the floating input area at contentRow.
-     *
-     * The chat box "floats" - it renders right below the last streamed content.
-     * As content is added, contentRow advances, and the chat box moves down.
-     * No scroll regions - pure floating behavior.
-     */
-    render() {
-        if (!this.canRender())
-            return;
-        if (this.isRendering)
-            return;
-        const streamingActive = this.mode === 'streaming' || isStreamingMode();
-        const bufferChanged = this.buffer !== this.lastRenderContent || this.cursor !== this.lastRenderCursor;
-        // During streaming, throttle re-renders unless the buffer actually changed
-        // (e.g., typing slash commands while streaming should update immediately).
-        const shouldThrottle = streamingActive &&
-            this.lastStreamingRender > 0 &&
-            !this.renderDirty &&
-            !bufferChanged &&
-            !this.showingSuggestions;
-        if (shouldThrottle) {
-            const elapsed = Date.now() - this.lastStreamingRender;
-            const waitMs = Math.max(0, this.streamingRenderInterval - elapsed);
-            if (waitMs > 0) {
-                this.renderDirty = true;
-                this.scheduleStreamingRender(waitMs);
-                return;
-            }
-        }
-        const shouldSkip = !this.renderDirty && !bufferChanged;
-        this.renderDirty = false;
-        if (shouldSkip) {
-            return;
-        }
-        if (writeLock.isLocked()) {
-            writeLock.safeWrite(() => this.render());
-            return;
-        }
-        this.renderPinnedChatBox();
-    }
-    /**
-     * Unified scroll region renderer.
-     * Chat box is ALWAYS pinned at the bottom of the terminal.
-     * Content scrolls in the region above the chat box.
-     */
-    renderPinnedChatBox() {
-        const { rows, cols } = this.getSize();
-        const maxWidth = Math.max(8, cols - 4);
-        const streamingActive = this.mode === 'streaming' || isStreamingMode();
-        const prevChatBoxStart = this.lastChatBoxStartRow;
-        const prevChatBoxHeight = this.lastChatBoxHeight;
-        // Wrap buffer into display lines
-        const { lines, cursorLine, cursorCol } = this.wrapBuffer(maxWidth);
-        const maxVisible = Math.max(1, Math.min(this.config.maxLines, rows - 3));
-        const displayLines = Math.min(lines.length, maxVisible);
-        const metaLines = this.buildMetaLines(cols - 2);
-        // Calculate display window (keep cursor visible)
-        let startLine = 0;
-        if (lines.length > displayLines) {
-            startLine = Math.max(0, cursorLine - displayLines + 1);
-            startLine = Math.min(startLine, lines.length - displayLines);
-        }
-        const visibleLines = lines.slice(startLine, startLine + displayLines);
-        const adjustedCursorLine = cursorLine - startLine;
-        // Chat box height
-        const chatBoxHeight = this.getChatBoxHeight();
-        // ALWAYS pin chat box at absolute bottom
-        const chatBoxStartRow = Math.max(1, rows - chatBoxHeight + 1);
-        const scrollEnd = chatBoxStartRow - 1;
-        this.lastChatBoxStartRow = chatBoxStartRow;
-        this.lastChatBoxHeight = chatBoxHeight;
-        this.lastSuggestionStartRow = null;
-        writeLock.lock('terminalInput.renderPinned');
-        this.isRendering = true;
-        try {
-            // Ensure content stays above the expanded chat/menu area when idle
-            if (!streamingActive && !this.scrollRegionActive) {
-                this.ensureContentAboveChatBox(chatBoxStartRow, rows);
-            }
-            this.write(ESC.SAVE);
-            this.write(ESC.HIDE);
-            // Temporarily reset scroll region to write chat box cleanly
-            if (this.scrollRegionActive) {
-                this.write(ESC.RESET_SCROLL);
-            }
-            // Clear the current and previous chat box footprint to avoid ghost text when the height shrinks
-            const prevHeight = prevChatBoxStart !== null ? Math.max(1, prevChatBoxHeight) : chatBoxHeight;
-            const prevStart = prevChatBoxStart ?? chatBoxStartRow;
-            const prevEnd = prevStart + prevHeight - 1;
-            const newEnd = chatBoxStartRow + chatBoxHeight - 1;
-            const clearStart = Math.max(1, Math.min(prevStart, chatBoxStartRow));
-            const clearEnd = Math.min(rows, Math.max(prevEnd, newEnd));
-            for (let row = clearStart; row <= clearEnd; row++) {
-                this.write(ESC.TO(row, 1));
-                this.write(ESC.CLEAR_LINE);
-            }
-            let currentRow = chatBoxStartRow;
-            // Render scroll/status indicator on the left (Claude Code style)
-            const scrollIndicator = this.buildScrollIndicator();
-            // Meta/status header with scroll indicator
-            for (const metaLine of metaLines) {
-                this.write(ESC.TO(currentRow, 1));
-                this.write(metaLine);
-                currentRow += 1;
-            }
-            // Separator line with scroll status
-            this.write(ESC.TO(currentRow, 1));
-            const dividerLabel = scrollIndicator || undefined;
-            this.write(renderDivider(cols - 2, dividerLabel));
-            currentRow += 1;
-            // Render input lines
-            let finalRow = currentRow;
-            let finalCol = 3;
-            for (let i = 0; i < visibleLines.length; i++) {
-                const rowNum = currentRow + i;
-                this.write(ESC.TO(rowNum, 1));
-                const line = visibleLines[i] ?? '';
-                const isFirstLine = (startLine + i) === 0;
-                const isCursorLine = i === adjustedCursorLine;
-                const col = isCursorLine ? Math.max(0, Math.min(cursorCol, line.length)) : 0;
-                this.write(ESC.BG_DARK);
-                this.write(ESC.DIM);
-                this.write(isFirstLine ? this.config.promptChar : this.config.continuationChar);
-                this.write(ESC.RESET);
-                this.write(ESC.BG_DARK);
-                if (isCursorLine) {
-                    const before = line.slice(0, col);
-                    const at = line.charAt(col) || ' ';
-                    const after = col < line.length ? line.slice(col + 1) : '';
-                    this.write(before);
-                    this.write(ESC.REVERSE + ESC.BOLD);
-                    this.write(at);
-                    this.write(ESC.RESET + ESC.BG_DARK);
-                    this.write(after);
-                    finalRow = rowNum;
-                    finalCol = this.config.promptChar.length + col + 1;
-                }
-                else {
-                    this.write(line);
-                }
-                // Pad to edge
-                const lineLen = this.config.promptChar.length +
-                    line.length +
-                    (isCursorLine && col >= line.length ? 1 : 0);
-                const padding = Math.max(0, cols - lineLen - 1);
-                if (padding > 0)
-                    this.write(' '.repeat(padding));
-                this.write(ESC.RESET);
-            }
-            // Command suggestions (shown above controls when "/" is typed)
-            const suggestionLines = this.buildSuggestionLines(cols - 2);
-            let suggestionRow = currentRow + visibleLines.length;
-            if (suggestionLines.length > 0) {
-                this.lastSuggestionStartRow = suggestionRow;
-            }
-            for (const suggestionLine of suggestionLines) {
-                this.write(ESC.TO(suggestionRow, 1));
-                this.write('  '); // Indent to match input
-                this.write(suggestionLine);
-                suggestionRow += 1;
-            }
-            // Mode controls lines with all keyboard shortcuts
-            // Can be multiple lines during streaming (status + toggles)
-            const controlLines = this.buildModeControls(cols);
-            let controlRow = suggestionRow;
-            for (const controlLine of controlLines) {
-                this.write(ESC.TO(controlRow, 1));
-                this.write(controlLine);
-                controlRow += 1;
-            }
-            // Restore scroll region and cursor
-            if (this.scrollRegionActive) {
-                // Restore scroll region
-                this.write(ESC.SET_SCROLL(1, scrollEnd));
-                // Restore cursor to where it was before rendering (preserves column position)
-                this.write(ESC.RESTORE);
-            }
-            else {
-                // Not streaming - position cursor in input box
-                this.write(ESC.RESTORE);
-                this.write(ESC.TO(finalRow, Math.min(finalCol, cols)));
-            }
-            this.write(ESC.SHOW);
-            // Update state
-            this.lastRenderContent = this.buffer;
-            this.lastRenderCursor = this.cursor;
-            this.lastStreamingRender = streamingActive ? Date.now() : 0;
-            if (this.streamingRenderTimer) {
-                clearTimeout(this.streamingRenderTimer);
-                this.streamingRenderTimer = null;
-            }
-        }
-        finally {
-            writeLock.unlock();
-            this.isRendering = false;
-        }
-    }
-    /**
-     * Keep assistant/user content above the chat box when it expands (e.g., slash menu).
-     * Scrolls just enough to free space without moving the cursor.
-     */
-    ensureContentAboveChatBox(chatBoxStartRow, rows) {
-        const contentMaxRow = Math.max(1, chatBoxStartRow - 1);
-        if (this.contentRow < contentMaxRow)
-            return;
-        const overflow = (this.contentRow - contentMaxRow) + 1;
-        const scrollLines = Math.min(overflow, rows);
-        this.write(ESC.SAVE);
-        this.write(ESC.TO(rows, 1));
-        this.write('\n'.repeat(scrollLines));
-        this.write(ESC.RESTORE);
-        this.contentRow = contentMaxRow;
-    }
-    /**
-     * Track output written directly by the display (system/assistant messages) so
-     * it is captured in scrollback and accounted for when re-rendering the chat box.
-     */
-    trackExternalOutput(content) {
-        if (!content)
-            return;
-        // Normalize and capture in scrollback for history
-        const normalized = content.replace(/\r/g, '\n');
-        this.addToScrollback(normalized);
-        // Advance content row based on rendered height (accounts for wrapping)
-        const rowsUsed = this.countRenderedRows(normalized);
-        if (rowsUsed > 0) {
-            this.contentRow += rowsUsed;
-            if (!this.scrollRegionActive) {
-                this.scheduleRender();
-            }
-        }
-    }
-    /**
-     * Estimate how many terminal rows the provided content will consume.
-     * Considers ANSI-stripped visible length and terminal width so wrapped lines
-     * correctly advance the tracked cursor position.
-     */
-    countRenderedRows(content) {
-        if (!content)
-            return 0;
-        const width = Math.max(1, this.getSize().cols);
-        const normalized = content.replace(/\r\n/g, '\n');
-        const lines = normalized.split('\n');
-        let rows = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = this.normalizeCarriageReturnLine(lines[i] ?? '');
-            const visibleLen = this.visibleLength(line);
-            if (visibleLen > 0) {
-                const wraps = Math.ceil(visibleLen / width);
-                if (wraps > 1) {
-                    rows += wraps - 1;
-                }
-            }
-            // Each newline moves the cursor to the start of the next row
-            if (i < lines.length - 1) {
-                rows += 1;
-            }
-        }
-        return rows;
-    }
-    /**
-     * Treat carriage returns as line rewrites rather than newlines for row estimates.
-     * If a CR is followed by text, only the text after the last CR is visible.
-     * If the line ends with a CR, the existing text stays visible.
-     */
-    normalizeCarriageReturnLine(line) {
-        if (!line.includes('\r')) {
-            return line;
-        }
-        const lastCr = line.lastIndexOf('\r');
-        const after = line.slice(lastCr + 1);
-        if (after.length > 0) {
-            return after;
-        }
-        return line.slice(0, lastCr);
-    }
-    /**
-     * Build compact meta line above the divider.
-     * Shows model/provider and key metrics in a single line.
-     */
-    buildMetaLines(width) {
-        if (!this.shouldShowMetaLine()) {
-            return [];
-        }
-        const leftParts = [];
-        const rightParts = [];
-        // Model/provider info (left side)
-        if (this.modelLabel) {
-            const modelText = this.providerLabel
-                ? `${this.modelLabel} @ ${this.providerLabel}`
-                : this.modelLabel;
-            leftParts.push({ text: modelText, tone: 'info' });
-        }
-        // Elapsed time (right side)
-        if (this.metaElapsedSeconds !== null) {
-            rightParts.push({ text: `⏱ ${this.formatElapsedLabel(this.metaElapsedSeconds)}`, tone: 'muted' });
-        }
-        // Token usage (right side)
-        if (this.metaTokensUsed !== null) {
-            const formattedUsed = this.formatTokenCount(this.metaTokensUsed);
-            const formattedLimit = this.metaTokenLimit ? `/${this.formatTokenCount(this.metaTokenLimit)}` : '';
-            rightParts.push({ text: `⊛ ${formattedUsed}${formattedLimit}`, tone: 'muted' });
-        }
-        // Context remaining warning
-        const tokensRemaining = this.computeTokensRemaining();
-        if (tokensRemaining !== null) {
-            const contextPct = this.contextUsage !== null ? `${100 - this.contextUsage}%` : '';
-            rightParts.push({ text: `↓${tokensRemaining} ${contextPct}`, tone: this.contextUsage && this.contextUsage > 80 ? 'warn' : 'muted' });
-        }
-        // Thinking indicator
-        if (this.metaThinkingMs !== null) {
-            leftParts.push({ text: formatThinking(this.metaThinkingMs, this.metaThinkingHasContent), tone: 'info' });
-        }
-        if (!leftParts.length && !rightParts.length) {
-            return [];
-        }
-        // Render left and right aligned
-        if (!rightParts.length || width < 50) {
-            return [renderStatusLine([...leftParts, ...rightParts], width)];
-        }
-        const leftWidth = Math.max(12, Math.floor(width * 0.5));
-        const rightWidth = Math.max(14, width - leftWidth - 1);
-        const leftText = renderStatusLine(leftParts, leftWidth);
-        const rightText = renderStatusLine(rightParts, rightWidth);
-        const spacing = Math.max(1, width - this.visibleLength(leftText) - this.visibleLength(rightText));
-        return [`${leftText}${' '.repeat(spacing)}${rightText}`];
-    }
-    /**
-     * Build mode controls lines with all keyboard shortcuts.
-     * Shows status, all toggles, and contextual information.
-     * Enhanced with comprehensive feature status display.
-     *
-     * Returns multiple lines to ensure all context is visible during streaming:
-     * - Line 1 (during streaming): Status/spinner + interrupt shortcut
-     * - Line 2: Mode toggles (edit, verify, auto-continue, thinking)
-     *
-     * Format: [Key] Label:status · [Key] Label:status · context% · model
-     */
-    buildModeControls(cols) {
-        const width = Math.max(8, cols - 2);
-        const streamingActive = this.mode === 'streaming' || this.scrollRegionActive;
-        // === LINE 1: STATUS LINE (streaming status + interrupt) ===
-        const statusParts = [];
-        // Streaming indicator with animated spinner
-        if (this.streamingLabel) {
-            statusParts.push({ text: `◐ ${this.streamingLabel}`, tone: 'info' });
-        }
-        // Override status (warnings, errors)
-        if (this.overrideStatusMessage) {
-            statusParts.push({ text: `⚠ ${this.overrideStatusMessage}`, tone: 'warn' });
-        }
-        // Main status message
-        if (this.statusMessage) {
-            statusParts.push({ text: this.statusMessage, tone: this.streamingLabel ? 'muted' : 'info' });
-        }
-        // Interrupt shortcut (during streaming)
-        // Queued commands
-        if (this.queue.length > 0) {
-            const queueIcon = streamingActive ? '⏳' : '▸';
-            statusParts.push({ text: `${queueIcon}${this.queue.length} queued`, tone: 'info' });
-        }
-        // === LINE 2: MODE TOGGLES (always visible, same as before streaming) ===
-        const toggleParts = [];
-        // Claude Code style mode indicator: "⏵⏵ accept edits on (shift+tab to cycle)"
-        const editModeLabel = this.editMode === 'display-edits' ? 'auto' :
-            this.editMode === 'ask-permission' ? 'ask' : 'plan';
-        toggleParts.push({ text: formatEditModeIndicator(editModeLabel), tone: editModeLabel === 'plan' ? 'info' : undefined });
-        // Context usage (show percentage remaining)
-        if (this.contextUsage !== null) {
-            const remaining = 100 - this.contextUsage;
-            const contextTone = this.contextUsage > 80 ? 'warn' : this.contextUsage > 60 ? 'info' : 'muted';
-            toggleParts.push({ text: `ctx:${remaining}%`, tone: contextTone });
-        }
-        const verifyHotkey = this.formatHotkey(this.verificationHotkey);
-        const verifyStatus = this.verificationEnabled ? 'Verify on' : 'Verify off';
-        toggleParts.push({
-            text: `${verifyHotkey} ${verifyStatus}`,
-            tone: this.verificationEnabled ? 'success' : 'muted'
-        });
-        const autoHotkey = this.formatHotkey(this.autoContinueHotkey);
-        const autoStatus = this.autoContinueEnabled ? 'Auto-continue on' : 'Auto-continue off';
-        toggleParts.push({
-            text: `${autoHotkey} ${autoStatus}`,
-            tone: this.autoContinueEnabled ? 'info' : 'muted'
-        });
-        // Thinking mode toggle
-        if (this.thinkingModeLabel) {
-            const shortThinking = this.thinkingModeLabel.length > 10
-                ? this.thinkingModeLabel.slice(0, 8) + '..'
-                : this.thinkingModeLabel;
-            const thinkingHotkey = this.formatHotkey(this.thinkingHotkey);
-            toggleParts.push({ text: `${thinkingHotkey} Thinking ${shortThinking}`, tone: 'info' });
-        }
-        // Navigation shortcuts - always show these
-        toggleParts.push({ text: 'PgUp/Dn:scroll', tone: 'muted' });
-        toggleParts.push({ text: '/help', tone: 'muted' });
-        // Multi-line indicator
-        if (this.buffer.includes('\n')) {
-            const lineCount = this.buffer.split('\n').length;
-            toggleParts.push({ text: `${lineCount}L`, tone: 'muted' });
-        }
-        // Paste indicator
-        if (this.pastePlaceholders.length > 0) {
-            const latest = this.pastePlaceholders[this.pastePlaceholders.length - 1];
-            toggleParts.push({
-                text: `📋${latest.lineCount}L`,
-                tone: 'info',
-            });
-        }
-        // Build the output lines - use wrapping to never truncate
-        const lines = [];
-        // During streaming: show status line first, then toggles (wrapped as needed)
-        // Not streaming: show combined or just toggles (wrapped as needed)
-        if (streamingActive && statusParts.length > 0) {
-            // Status line (usually fits on one line)
-            lines.push(renderStatusLine(statusParts, width));
-            // Toggle parts - wrap to multiple lines if needed
-            lines.push(...renderStatusLines(toggleParts, width));
-        }
-        else if (statusParts.length > 0) {
-            // Not streaming but have status - use wrapping for all parts
-            const combined = [...statusParts, ...toggleParts];
-            lines.push(...renderStatusLines(combined, width));
-        }
-        else {
-            // No streaming, no status - just show toggles (wrapped as needed)
-            lines.push(...renderStatusLines(toggleParts, width));
-        }
-        // Ensure at least one line is returned
-        if (lines.length === 0) {
-            lines.push('');
-        }
-        return lines;
-    }
-    /**
-     * Render a mini context usage bar (5 chars)
-     */
-    renderMiniContextBar(percentRemaining) {
-        const bars = 5;
-        const filled = Math.round((percentRemaining / 100) * bars);
-        const empty = bars - filled;
-        return '█'.repeat(filled) + '░'.repeat(empty);
-    }
-    formatHotkey(hotkey) {
-        const normalized = hotkey.trim().toLowerCase();
-        if (!normalized)
-            return hotkey;
-        const parts = normalized.split('+').filter(Boolean);
-        const map = {
-            shift: 'Shift',
-            sh: 'Shift',
-            alt: 'Alt',
-            option: 'Alt',
-            opt: 'Alt',
-            ctrl: 'Ctrl',
-            control: 'Ctrl',
-            cmd: 'Cmd',
-            meta: 'Cmd',
-        };
-        const formatted = parts
-            .map((part) => {
-            const symbol = map[part];
-            if (symbol)
-                return symbol;
-            if (part.startsWith('/'))
-                return part;
-            if (part.length === 1)
-                return part.toUpperCase();
-            return part.charAt(0).toUpperCase() + part.slice(1);
-        })
-            .join('+');
-        return formatted || hotkey;
-    }
-    computeContextRemaining() {
-        if (this.contextUsage === null) {
-            return null;
-        }
-        return Math.max(0, this.contextAutoCompactThreshold - this.contextUsage);
-    }
-    computeTokensRemaining() {
-        if (this.metaTokensUsed === null || this.metaTokenLimit === null) {
-            return null;
-        }
-        const remaining = Math.max(0, this.metaTokenLimit - this.metaTokensUsed);
-        return this.formatTokenCount(remaining);
-    }
-    formatElapsedLabel(seconds) {
-        if (seconds < 60) {
-            return `${seconds}s`;
-        }
-        const mins = Math.floor(seconds / 60);
-        const secs = seconds % 60;
-        return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
-    }
-    formatTokenCount(value) {
-        if (!Number.isFinite(value)) {
-            return `${value}`;
-        }
-        if (value >= 1_000_000) {
-            return `${(value / 1_000_000).toFixed(1)}M`;
-        }
-        if (value >= 1_000) {
-            return `${(value / 1_000).toFixed(1)}k`;
-        }
-        return `${Math.round(value)}`;
-    }
-    shouldShowMetaLine() {
-        return (this.metaElapsedSeconds !== null ||
-            this.metaTokensUsed !== null ||
-            this.metaThinkingMs !== null);
-    }
-    clearChatBoxArea(rows, chatBoxHeight) {
-        const start = Math.max(1, rows - chatBoxHeight + 1);
-        writeLock.lock('clearChatBoxArea');
-        try {
-            for (let row = start; row <= rows; row++) {
-                this.write(ESC.TO(row, 1));
-                this.write(ESC.CLEAR_LINE);
-            }
-        }
-        finally {
-            writeLock.unlock();
-        }
-    }
-    visibleLength(value) {
-        const ansiPattern = /\u001B\[[0-?]*[ -/]*[@-~]/g;
-        return value.replace(ansiPattern, '').length;
-    }
-    /**
-     * Debug-only snapshot used by tests to assert rendered strings without
-     * needing a TTY. Not used by production code.
-     */
-    getDebugUiSnapshot(width) {
-        const cols = Math.max(8, width ?? this.getSize().cols);
-        return {
-            meta: this.buildMetaLines(cols - 2),
-            controls: this.buildModeControls(cols),
-        };
-    }
-    /**
-     * Force a re-render
-     */
-    forceRender() {
-        this.lastRenderContent = '';
-        this.lastRenderCursor = -1;
-        this.renderDirty = true;
-        this.render();
-    }
-    /**
-     * Enable/disable input
-     */
-    setEnabled(enabled) {
-        this.enabled = enabled;
-    }
-    /**
-     * Handle terminal resize
-     */
-    handleResize() {
-        this.lastRenderContent = '';
-        this.lastRenderCursor = -1;
-        this.resetStreamingRenderThrottle();
-        // If in scrollback mode, re-render the scrollback view with new dimensions
-        if (this.isInScrollbackMode) {
-            this.renderScrollbackView();
-        }
-        else {
-            this.scheduleRender();
-        }
-    }
-    /**
-     * Enter streaming mode with scroll region.
-     * Sets up terminal scroll region to exclude chat box.
-     */
-    enterStreamingScrollRegion(options) {
-        const { rows } = this.getSize();
-        const chatBoxHeight = this.getChatBoxHeight();
-        const scrollEnd = Math.max(1, rows - chatBoxHeight);
-        // Clear any previously rendered chat box so only the streaming layout remains.
-        this.clearChatBoxArea(rows, chatBoxHeight);
-        this.lastChatBoxStartRow = null;
-        this.lastChatBoxHeight = 0;
-        writeLock.lock('enterStreamingScrollRegion');
-        try {
-            // Set scroll region for content area (above chat box)
-            this.write(ESC.SET_SCROLL(1, scrollEnd));
-            // Position cursor at current content row
-            this.contentRow = 1;
-            this.write(ESC.TO(this.contentRow, 1));
-            this.scrollRegionActive = true;
-            if (options?.statusMessage !== undefined) {
-                this.setStatusMessage(options.statusMessage);
-            }
-        }
-        finally {
-            writeLock.unlock();
-        }
-        // Render pinned chat box at bottom
-        this.forceRender();
-    }
-    /**
-     * Exit streaming mode and restore normal operation.
-     * Clears the old pinned chat box area to prevent duplication.
-     */
-    exitStreamingScrollRegion(options) {
-        const renderPrompt = options?.renderPrompt ?? true;
-        const statusMessage = options?.statusMessage !== undefined
-            ? options.statusMessage
-            : renderPrompt
-                ? 'Ready for prompts'
-                : null;
-        const { rows } = this.getSize();
-        const chatBoxHeight = this.getChatBoxHeight();
-        writeLock.lock('exitStreamingScrollRegion');
-        try {
-            // Reset scroll region to full terminal
-            this.write(ESC.RESET_SCROLL);
-            // Clear the old pinned chat box area to prevent duplication
-            // The old chat box was rendered at fixed bottom positions
-            const oldChatBoxStart = Math.max(1, rows - chatBoxHeight + 1);
-            for (let i = 0; i < chatBoxHeight; i++) {
-                const row = oldChatBoxStart + i;
-                if (row <= rows) {
-                    this.write(ESC.TO(row, 1));
-                    this.write(ESC.CLEAR_LINE);
-                }
-            }
-            // Move cursor back up to where content should continue
-            this.write(ESC.TO(oldChatBoxStart, 1));
-            this.scrollRegionActive = false;
-            // Only update the status message when requested
-            if (statusMessage !== undefined) {
-                this.setStatusMessage(statusMessage);
-            }
-        }
-        finally {
-            writeLock.unlock();
-        }
-        // Flag for re-render; caller controls whether to render immediately
-        if (renderPrompt) {
-            this.forceRender();
-        }
-        else {
-            this.renderDirty = true;
-        }
-    }
-    /**
-     * Stream content within the scroll region.
-     * Content is written directly and scrolls naturally.
-     */
-    streamContent(content) {
-        if (!content)
-            return;
-        // Capture content in scrollback buffer
-        this.addToScrollback(content);
-        writeLock.lock('streamContent');
-        try {
-            // Write content - scroll region handles scrolling
-            this.write(content);
-            // Track rendered rows (handles wrapping)
-            const rowsUsed = this.countRenderedRows(content);
-            this.contentRow += rowsUsed;
-        }
-        finally {
-            writeLock.unlock();
-        }
-        // Throttle chat box updates only when a re-render is needed.
-        // In streaming mode the chat box stays pinned, so skip redundant redraws.
-        const needsRender = !this.scrollRegionActive || this.renderDirty;
-        if (needsRender) {
-            if (!this.scrollRegionActive) {
-                // Content moved; force a render so the chat box follows.
-                this.renderDirty = true;
-            }
-            this.scheduleStreamingRender(200);
-        }
-    }
-    isScrollRegionActive() {
-        return this.scrollRegionActive;
-    }
-    /**
-     * Disable scroll region and restore full-screen layout (used on dispose).
-     */
-    disableScrollRegion() {
-        if (!this.scrollRegionActive)
-            return;
-        const { rows } = this.getSize();
-        const chatBoxHeight = this.getChatBoxHeight();
-        writeLock.withLock(() => {
-            this.write(ESC.RESET_SCROLL);
-            // Clear the chat box footprint
-            this.clearChatBoxArea(rows, chatBoxHeight);
-            this.scrollRegionActive = false;
-        }, 'disableScrollRegion');
-    }
-    /**
-     * Calculate chat box height dynamically.
-     * Accounts for:
-     * - Meta lines (model, elapsed, tokens)
-     * - Divider
-     * - Input line(s) - expands for multi-line/wrapped input
-     * - Command suggestions (when showing)
-     * - Control lines (wraps as needed to fit all toggles)
-     * - Buffer
-     */
-    getChatBoxHeight() {
-        const { rows, cols } = this.getSize();
-        // Calculate actual input lines needed (wrapped buffer)
-        const maxWidth = Math.max(1, cols - 4); // Account for prompt and padding
-        const { lines: wrappedLines } = this.wrapBuffer(maxWidth);
-        // Allow the chat box to grow with the prompt while respecting any explicit limit
-        const inputLines = Math.max(1, Math.min(wrappedLines.length, this.config.maxLines));
-        // Calculate actual control lines (they wrap as needed)
-        const controlLines = this.buildModeControls(cols);
-        const controlLineCount = Math.max(1, controlLines.length);
-        // Meta line only if we have model/elapsed info
-        const metaLines = this.shouldShowMetaLine() ? 1 : 0;
-        // Command suggestion lines (when showing)
-        let suggestionLines = 0;
-        if (this.showingSuggestions) {
-            const filtered = this.getFilteredCommands();
-            suggestionLines = Math.min(filtered.length, this.maxVisibleSuggestions) + 1; // +1 for header
-        }
-        // Total: meta + divider + input lines + suggestions + controls + buffer
-        // Leave a small buffer so streamed content still has space above the chat box
-        const totalHeight = metaLines + 1 + inputLines + suggestionLines + controlLineCount + 1;
-        const minContentRows = 2;
-        const maxHeight = Math.max(4, rows - minContentRows);
-        return Math.min(totalHeight, maxHeight);
-    }
-    /**
-     * @deprecated Use streamContent() instead
-     * Register with display's output interceptor - kept for backwards compatibility
-     */
-    registerOutputInterceptor(_display) {
-        const display = _display;
-        if (!display?.registerOutputInterceptor)
-            return;
-        // Remove prior hook if present
-        if (this.displayInterceptorDispose) {
-            this.displayInterceptorDispose();
-            this.displayInterceptorDispose = null;
-        }
-        this.displayInterceptorDispose = display.registerOutputInterceptor({
-            afterWrite: (content) => {
-                if (!content)
-                    return;
-                this.trackExternalOutput(content);
-            },
-        });
-    }
-    /**
-     * Write content above the floating chat box.
-     * Works both during streaming and when idle.
-     */
-    writeToScrollRegion(content) {
-        if (!content)
-            return;
-        // Capture content in scrollback buffer
-        this.addToScrollback(content);
-        writeLock.lock('writeToScrollRegion');
-        try {
-            // Position cursor at content row and write
-            this.write(ESC.TO(this.contentRow, 1));
-            this.write(content);
-            // Track rendered rows (handles wrapping)
-            const rowsUsed = this.countRenderedRows(content);
-            this.contentRow += rowsUsed;
-        }
-        finally {
-            writeLock.unlock();
-        }
-        // Re-render chat box below new content (only when not streaming)
-        if (!this.scrollRegionActive) {
-            this.forceRender();
-        }
-    }
-    /**
-     * Enter alternate screen buffer.
-     * DISABLED: Using terminal-native mode for proper scrollback and text selection.
-     */
-    enterAlternateScreen() {
-        // Disabled - using terminal-native mode
-        this.contentRow = 1;
-    }
-    /**
-     * Exit alternate screen buffer.
-     * DISABLED: Using terminal-native mode.
-     */
-    exitAlternateScreen() {
-        // Disabled - using terminal-native mode
-    }
-    /**
-     * Check if alternate screen buffer is currently active.
-     * Always returns false - using terminal-native mode.
-     */
-    isAlternateScreenActive() {
-        return false;
-    }
-    /**
-     * Get a snapshot of the scrollback buffer (for display on exit).
-     */
-    getScrollbackSnapshot() {
-        return [...this.scrollbackBuffer];
-    }
-    /**
-     * Clear the visible terminal area and reset content position.
-     * In terminal-native mode, this just adds newlines to scroll past content
-     * rather than clearing history (preserving scrollback).
-     */
-    clearScreen() {
-        writeLock.lock('clearScreen');
-        try {
-            // In native mode, scroll past existing content rather than clearing
-            const { rows } = this.getSize();
-            this.write('\n'.repeat(rows));
-            this.write(ESC.HOME);
-            this.contentRow = 1;
-        }
-        finally {
-            writeLock.unlock();
-        }
-    }
-    /**
-     * Reset content position to row 1.
-     * Does NOT clear the terminal - content starts from current position.
-     */
-    resetContentPosition() {
-        this.contentRow = 1;
-    }
-    /**
-     * Set the content row explicitly (used after banner is written).
-     * This tells the input where content should start flowing from.
-     */
-    setContentRow(row) {
-        this.contentRow = Math.max(1, row);
-    }
-    /**
-     * Get the current content row position.
-     */
-    getContentRow() {
-        return this.contentRow;
-    }
-    /**
-     * Dispose and clean up
-     */
-    dispose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        this.enabled = false;
-        if (this.displayInterceptorDispose) {
-            this.displayInterceptorDispose();
-            this.displayInterceptorDispose = null;
-        }
-        this.disableScrollRegion();
-        this.resetStreamingRenderThrottle();
-        this.disableBracketedPaste();
-        this.buffer = '';
-        this.queue = [];
-        this.removeAllListeners();
-    }
-    // ===========================================================================
-    // INPUT HANDLING
-    // ===========================================================================
-    handleCtrlKey(key) {
-        switch (key.name) {
-            case 'c':
-                if (this.buffer.length > 0) {
-                    this.clear();
-                }
-                else {
-                    this.emit('interrupt');
-                }
-                return true;
-            case 'a': // Home
-                this.moveCursorToLineStart();
-                return true;
-            case 'e': // End
-                if (key.shift) {
-                    this.toggleEditMode();
-                    this.emit('toggleEditMode');
-                    return true;
-                }
-                this.moveCursorToLineEnd();
-                return true;
-            case 'u': // Delete to start
-                this.deleteToStart();
-                return true;
-            case 'k': // Delete to end
-                this.deleteToEnd();
-                return true;
-            case 'w': // Delete word
-                this.deleteWord();
-                return true;
-            case 'left': // Word left
-                this.moveCursorWordLeft();
-                return true;
-            case 'right': // Word right
-                this.moveCursorWordRight();
-                return true;
-            case 'return': // Ctrl+Enter => newline instead of submit
-                this.insertNewline();
-                return true;
-            case 'v':
-                if (key.shift) {
-                    this.emit('toggleVerify');
-                    return true;
-                }
-                break;
-            case 'c':
-                if (key.shift) {
-                    this.emit('toggleAutoContinue');
-                    return true;
-                }
-                break;
-            case 't':
-                if (key.shift) {
-                    this.emit('toggleThinking');
-                    return true;
-                }
-                break;
-            case 'x':
-                if (key.shift) {
-                    this.emit('clearContext');
-                    return true;
-                }
-                break;
-            case 's':
-                if (key.shift) {
-                    this.toggleScrollbackMode();
-                    return true;
-                }
-                break;
-        }
-        return false;
-    }
-    /**
-     * Handle Alt/Meta key combinations for mode toggles and navigation.
-     * Ctrl-based shortcuts are primary; Alt/Meta remains as a compatibility fallback.
-     */
-    handleMetaKey(key) {
-        switch (key.name) {
-            // === CURSOR MOVEMENT ===
-            case 'left':
-            case 'b':
-                this.moveCursorWordLeft();
-                break;
-            case 'right':
-            case 'f':
-                this.moveCursorWordRight();
-                break;
-            case 'backspace':
-                this.deleteWord();
-                break;
-            case 'return':
-                this.insertNewline();
-                break;
-            // === MODE TOGGLES ===
-            case 'v':
-                // Alt+V: Toggle verification mode (auto-tests after edits)
-                this.emit('toggleVerify');
-                break;
-            case 'c':
-                // Alt+C: Toggle auto-continue mode
-                this.emit('toggleAutoContinue');
-                break;
-            case 't':
-                // Alt+T: Toggle/cycle thinking mode
-                this.emit('toggleThinking');
-                break;
-            case 'e':
-                // Alt+E: Toggle edit permission mode (ask/auto)
-                this.toggleEditMode();
-                this.emit('toggleEditMode');
-                break;
-            case 'x':
-                // Alt+X: Clear/compact context
-                this.emit('clearContext');
-                break;
-            // === SCROLLBACK NAVIGATION ===
-            case 's':
-                // Alt+S: Toggle scrollback mode
-                this.toggleScrollbackMode();
-                break;
-            case 'up':
-                // Alt+Up: Quick scroll up into history
-                if (!this.isInScrollbackMode) {
-                    this.scrollUp(10);
-                }
-                else {
-                    this.scrollUp(1);
-                }
-                break;
-            case 'down':
-                // Alt+Down: Quick scroll down
-                if (this.isInScrollbackMode) {
-                    this.scrollDown(1);
-                }
-                break;
-            case 'pageup':
-                // Alt+PageUp: Page up in scrollback
-                this.scrollUp(this.getPageSize());
-                break;
-            case 'pagedown':
-                // Alt+PageDown: Page down in scrollback
-                this.scrollDown(this.getPageSize());
-                break;
-            case 'home':
-                // Alt+Home: Jump to top of scrollback
-                this.scrollToTop();
-                break;
-            case 'end':
-                // Alt+End: Jump to bottom (live)
-                this.scrollToBottom();
-                break;
-        }
-    }
-    /**
-     * Get page size for scrollback navigation.
-     */
-    getPageSize() {
-        const { rows } = this.getSize();
-        const chatBoxHeight = this.getChatBoxHeight();
-        return Math.max(5, rows - chatBoxHeight - 2);
-    }
-    /**
-     * Build scroll indicator for the divider line.
-     * Scrollback navigation is disabled in alternate screen mode.
-     * This returns null - no scroll indicator is shown.
-     */
-    buildScrollIndicator() {
-        // Scrollback navigation disabled - no indicator needed
-        return null;
-    }
-    handleSpecialKey(_str, key) {
-        switch (key.name) {
-            case 'return':
-                if (key.shift || key.meta || key.ctrl) {
-                    this.insertNewline();
-                }
-                else if (this.showingSuggestions) {
-                    // Select highlighted suggestion and submit immediately
-                    this.selectSuggestion({ submit: true });
-                }
-                else {
-                    this.submit();
-                }
-                return true;
-            case 'escape':
-                // Cancel suggestions first, or emit interrupt
-                if (this.cancelSuggestions()) {
-                    return true;
-                }
-                this.emit('interrupt');
-                return true;
-            case 'backspace':
-                this.deleteBackward();
-                return true;
-            case 'delete':
-                this.deleteForward();
-                return true;
-            case 'left':
-                // Cancel suggestions on cursor movement
-                if (this.showingSuggestions) {
-                    this.cancelSuggestions();
-                }
-                this.moveCursorLeft();
-                return true;
-            case 'right':
-                // Cancel suggestions on cursor movement
-                if (this.showingSuggestions) {
-                    this.cancelSuggestions();
-                }
-                this.moveCursorRight();
-                return true;
-            case 'up':
-                // When showing suggestions, navigate up
-                if (this.showingSuggestions) {
-                    this.moveSuggestionUp();
-                    return true;
-                }
-                // Ctrl+Shift+Up or Shift+Up: Quick scroll up in scrollback
-                if ((key.ctrl && key.shift) || key.shift) {
-                    this.scrollUp(5);
-                }
-                else {
-                    this.handleUp();
-                }
-                return true;
-            case 'down':
-                // When showing suggestions, navigate down
-                if (this.showingSuggestions) {
-                    this.moveSuggestionDown();
-                    return true;
-                }
-                // Ctrl+Shift+Down or Shift+Down: Quick scroll down in scrollback
-                if ((key.ctrl && key.shift) || key.shift) {
-                    this.scrollDown(5);
-                }
-                else {
-                    this.handleDown();
-                }
-                return true;
-            case 'home':
-                // Ctrl+Home or in scrollback mode: scroll to top
-                if (key.ctrl || this.isInScrollbackMode) {
-                    this.scrollToTop();
-                }
-                else {
-                    this.moveCursorToLineStart();
-                }
-                return true;
-            case 'end':
-                // Ctrl+End or in scrollback mode: scroll to bottom (live mode)
-                if (key.ctrl || this.isInScrollbackMode) {
-                    this.scrollToBottom();
-                }
-                else {
-                    this.moveCursorToLineEnd();
-                }
-                return true;
-            case 'pageup':
-                // Scrollback disabled in alternate screen mode
-                // Users should use terminal's native scrollback if available
-                return true;
-            case 'pagedown':
-                // Scrollback disabled in alternate screen mode
-                return true;
-            case 'tab':
-                // Tab can select suggestion too without submitting
-                if (this.showingSuggestions && !key.shift) {
-                    this.selectSuggestion();
-                    return true;
-                }
-                if (key.shift) {
-                    this.toggleEditMode();
-                    return true;
-                }
-                this.emit('toggleThinking');
-                return true;
-        }
-        return false;
-    }
-    insertText(text) {
-        const clean = this.sanitize(text);
-        if (!clean)
-            return;
-        const available = this.config.maxLength - this.getComposedLength();
-        if (available <= 0)
-            return;
-        const chunk = clean.slice(0, available);
-        const placeholder = this.findPlaceholderAt(this.cursor);
-        const insertPos = placeholder && this.cursor > placeholder.start ? placeholder.end : this.cursor;
-        this.insertPlainText(chunk, insertPos);
-        this.cursor = insertPos + chunk.length;
-        this.emit('change', this.buffer);
-        // Update command autocomplete visibility
-        this.updateSuggestionVisibility();
-        this.scheduleRender();
-    }
-    insertNewline() {
-        if (this.getComposedLength() >= this.config.maxLength)
-            return;
-        const placeholder = this.findPlaceholderAt(this.cursor);
-        const insertPos = placeholder && this.cursor > placeholder.start ? placeholder.end : this.cursor;
-        this.insertPlainText('\n', insertPos);
-        this.cursor = insertPos + 1;
-        this.emit('change', this.buffer);
-        this.scheduleRender();
-    }
-    deleteBackward() {
-        if (this.cursor === 0)
-            return;
-        const placeholder = this.findPlaceholderAt(this.cursor - 1);
-        if (placeholder) {
-            this.deletePlaceholder(placeholder);
-        }
-        else {
-            this.removeRange(this.cursor - 1, this.cursor);
-            this.cursor = Math.max(0, this.cursor - 1);
-        }
-        this.emit('change', this.buffer);
-        this.updateSuggestionVisibility();
-        this.scheduleRender();
-    }
-    deleteForward() {
-        if (this.cursor >= this.buffer.length)
-            return;
-        const placeholder = this.findPlaceholderAt(this.cursor);
-        if (placeholder) {
-            this.deletePlaceholder(placeholder);
-        }
-        else {
-            this.removeRange(this.cursor, this.cursor + 1);
-        }
-        this.emit('change', this.buffer);
-        this.updateSuggestionVisibility();
-        this.scheduleRender();
-    }
-    deleteToStart() {
-        if (this.cursor === 0)
-            return;
-        this.removeRange(0, this.cursor);
-        this.cursor = 0;
-        this.emit('change', this.buffer);
-        this.updateSuggestionVisibility();
-        this.scheduleRender();
-    }
-    deleteToEnd() {
-        if (this.cursor >= this.buffer.length)
-            return;
-        this.removeRange(this.cursor, this.buffer.length);
-        this.emit('change', this.buffer);
-        this.updateSuggestionVisibility();
-        this.scheduleRender();
-    }
-    deleteWord() {
-        if (this.cursor === 0)
-            return;
-        const placeholder = this.findPlaceholderAt(this.cursor - 1);
-        if (placeholder) {
-            this.deletePlaceholder(placeholder);
-            this.emit('change', this.buffer);
-            this.scheduleRender();
-            return;
-        }
-        let pos = this.cursor;
-        // Skip whitespace
-        while (pos > 0 && this.isWhitespace(this.buffer[pos - 1]))
-            pos--;
-        // Skip word
-        while (pos > 0 && !this.isWhitespace(this.buffer[pos - 1]))
-            pos--;
-        this.buffer = this.buffer.slice(0, pos) + this.buffer.slice(this.cursor);
-        this.cursor = pos;
-        this.emit('change', this.buffer);
-        this.scheduleRender();
-    }
-    moveCursorLeft() {
-        if (this.cursor > 0) {
-            this.cursor--;
-            this.scheduleRender();
-        }
-    }
-    moveCursorRight() {
-        if (this.cursor < this.buffer.length) {
-            this.cursor++;
-            this.scheduleRender();
-        }
-    }
-    moveCursorWordLeft() {
-        let pos = this.cursor;
-        while (pos > 0 && this.isWhitespace(this.buffer[pos - 1]))
-            pos--;
-        while (pos > 0 && !this.isWhitespace(this.buffer[pos - 1]))
-            pos--;
-        this.cursor = pos;
-        this.scheduleRender();
-    }
-    moveCursorWordRight() {
-        let pos = this.cursor;
-        while (pos < this.buffer.length && !this.isWhitespace(this.buffer[pos]))
-            pos++;
-        while (pos < this.buffer.length && this.isWhitespace(this.buffer[pos]))
-            pos++;
-        this.cursor = pos;
-        this.scheduleRender();
-    }
-    moveCursorToLineStart() {
-        // Find start of current line
-        let pos = this.cursor;
-        while (pos > 0 && this.buffer[pos - 1] !== '\n')
-            pos--;
-        this.cursor = pos;
-        this.scheduleRender();
-    }
-    moveCursorToLineEnd() {
-        // Find end of current line
-        let pos = this.cursor;
-        while (pos < this.buffer.length && this.buffer[pos] !== '\n')
-            pos++;
-        this.cursor = pos;
-        this.scheduleRender();
-    }
-    handleUp() {
-        // Check if we can move up within buffer (multi-line)
-        const { cursorLine } = this.getCursorPosition();
-        if (cursorLine > 0) {
-            this.moveCursorUp();
-            return;
-        }
-        // Otherwise navigate history
-        if (this.history.length === 0)
-            return;
-        if (this.historyIndex === -1) {
-            this.tempInput = this.buffer;
-        }
-        if (this.historyIndex < this.history.length - 1) {
-            this.historyIndex++;
-            this.buffer = this.history[this.history.length - 1 - this.historyIndex] ?? '';
-            this.cursor = this.buffer.length;
-            this.scheduleRender();
-        }
-    }
-    handleDown() {
-        // Check if we can move down within buffer
-        const { cursorLine, totalLines } = this.getCursorPosition();
-        if (cursorLine < totalLines - 1) {
-            this.moveCursorDown();
-            return;
-        }
-        // Otherwise navigate history
-        if (this.historyIndex > 0) {
-            this.historyIndex--;
-            this.buffer = this.history[this.history.length - 1 - this.historyIndex] ?? '';
-            this.cursor = this.buffer.length;
-            this.scheduleRender();
-        }
-        else if (this.historyIndex === 0) {
-            this.historyIndex = -1;
-            this.buffer = this.tempInput;
-            this.cursor = this.buffer.length;
-            this.scheduleRender();
-        }
-    }
-    moveCursorUp() {
-        const lines = this.buffer.split('\n');
-        let lineStart = 0;
-        let lineIdx = 0;
-        // Find current line
-        for (let i = 0; i < lines.length; i++) {
-            const lineEnd = lineStart + (lines[i]?.length ?? 0);
-            if (this.cursor <= lineEnd) {
-                lineIdx = i;
-                break;
-            }
-            lineStart = lineEnd + 1; // +1 for newline
-        }
-        if (lineIdx === 0)
-            return;
-        // Calculate column in current line
-        const colInLine = this.cursor - lineStart;
-        // Move to previous line
-        const prevLineStart = lineStart - 1 - (lines[lineIdx - 1]?.length ?? 0);
-        const prevLineLen = lines[lineIdx - 1]?.length ?? 0;
-        this.cursor = prevLineStart + Math.min(colInLine, prevLineLen);
-        this.scheduleRender();
-    }
-    moveCursorDown() {
-        const lines = this.buffer.split('\n');
-        let lineStart = 0;
-        let lineIdx = 0;
-        // Find current line
-        for (let i = 0; i < lines.length; i++) {
-            const lineEnd = lineStart + (lines[i]?.length ?? 0);
-            if (this.cursor <= lineEnd) {
-                lineIdx = i;
-                break;
-            }
-            lineStart = lineEnd + 1;
-        }
-        if (lineIdx >= lines.length - 1)
-            return;
-        const colInLine = this.cursor - lineStart;
-        const nextLineStart = lineStart + (lines[lineIdx]?.length ?? 0) + 1;
-        const nextLineLen = lines[lineIdx + 1]?.length ?? 0;
-        this.cursor = nextLineStart + Math.min(colInLine, nextLineLen);
-        this.scheduleRender();
-    }
-    getCursorPosition() {
-        const lines = this.buffer.split('\n');
-        let pos = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const lineLen = lines[i]?.length ?? 0;
-            if (this.cursor <= pos + lineLen) {
-                return {
-                    cursorLine: i,
-                    cursorCol: this.cursor - pos,
-                    totalLines: lines.length,
-                };
-            }
-            pos += lineLen + 1;
-        }
-        return {
-            cursorLine: lines.length - 1,
-            cursorCol: lines[lines.length - 1]?.length ?? 0,
-            totalLines: lines.length,
-        };
-    }
-    submit() {
-        const text = this.assembleText();
-        if (!text.trim())
-            return;
-        const submission = text;
-        // Add to history
-        if (this.history[this.history.length - 1] !== submission) {
-            this.history.push(submission);
-            if (this.history.length > this.maxHistory) {
-                this.history.shift();
-            }
-        }
-        this.historyIndex = -1;
-        this.tempInput = '';
-        // Queue or submit based on mode
-        if (this.mode === 'streaming') {
-            if (this.queue.length >= this.config.maxQueueSize) {
-                return; // Queue full
-            }
-            this.queue.push({
-                id: ++this.queueIdCounter,
-                text: submission,
-                timestamp: Date.now(),
-            });
-            this.emit('queue', submission);
-            this.clear(); // Clear immediately for queued input
-        }
-        else {
-            // In idle mode, clear the input first, then emit submit.
-            // The prompt will be logged as a visible message by the caller.
-            this.clear();
-            this.emit('submit', submission);
-        }
-    }
-    finishPaste() {
-        const content = this.pasteBuffer;
-        this.pasteBuffer = '';
-        this.isPasting = false;
-        if (!content)
-            return;
-        const clean = this.sanitize(content);
-        if (!clean)
-            return;
-        const available = this.config.maxLength - this.getComposedLength();
-        if (available <= 0)
-            return;
-        const chunk = clean.slice(0, available);
-        const isMultiline = isMultilinePaste(chunk);
-        const isShortMultiline = isMultiline && this.shouldInlineMultiline(chunk);
-        if (isMultiline && !isShortMultiline) {
-            this.insertPastePlaceholder(chunk);
-        }
-        else {
-            const placeholder = this.findPlaceholderAt(this.cursor);
-            const insertPos = placeholder && this.cursor > placeholder.start ? placeholder.end : this.cursor;
-            this.insertPlainText(chunk, insertPos);
-            this.cursor = insertPos + chunk.length;
-        }
-        this.emit('change', this.buffer);
-        this.scheduleRender();
-    }
-    // ===========================================================================
-    // BUFFER WRAPPING
-    // ===========================================================================
-    wrapBuffer(maxWidth) {
-        const width = Math.max(1, maxWidth);
-        const lines = [];
-        let cursorLine = 0;
-        let cursorCol = 0;
-        let charIndex = 0;
-        if (this.buffer.length === 0) {
-            return { lines: [''], cursorLine: 0, cursorCol: 0 };
-        }
-        const rawLines = this.buffer.split('\n');
-        for (let i = 0; i < rawLines.length; i++) {
-            const raw = rawLines[i] ?? '';
-            if (raw.length === 0) {
-                // Empty line from newline
-                if (this.cursor === charIndex) {
-                    cursorLine = lines.length;
-                    cursorCol = 0;
-                }
-                lines.push('');
-            }
-            else {
-                // Wrap long lines
-                for (let start = 0; start < raw.length; start += width) {
-                    const segment = raw.slice(start, start + width);
-                    const segmentStart = charIndex + start;
-                    const segmentEnd = segmentStart + segment.length;
-                    if (this.cursor >= segmentStart && this.cursor <= segmentEnd) {
-                        cursorLine = lines.length;
-                        cursorCol = this.cursor - segmentStart;
-                    }
-                    lines.push(segment);
-                }
-            }
-            charIndex += raw.length;
-            // Account for newline between raw lines
-            if (i < rawLines.length - 1) {
-                if (this.cursor === charIndex) {
-                    cursorLine = lines.length;
-                    cursorCol = 0;
-                }
-                charIndex++;
-            }
-        }
-        // Safety: clamp values
-        cursorLine = Math.max(0, Math.min(cursorLine, lines.length - 1));
-        cursorCol = Math.max(0, Math.min(cursorCol, lines[cursorLine]?.length ?? 0));
-        return { lines, cursorLine, cursorCol };
-    }
-    // ===========================================================================
-    // SCROLLBACK BUFFER
-    // ===========================================================================
-    /**
-     * Add content to the scrollback buffer for history retention
-     */
-    addToScrollback(content) {
-        if (!content)
-            return;
-        // Split content into lines and add to buffer
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (line !== undefined) {
-                // Only add non-empty lines or preserve newlines between content
-                if (i < lines.length - 1 || line.length > 0) {
-                    this.scrollbackBuffer.push(line);
-                }
-            }
-        }
-        // Trim buffer if it exceeds max size
-        while (this.scrollbackBuffer.length > this.maxScrollbackLines) {
-            this.scrollbackBuffer.shift();
-        }
-        // If we're in live mode (not scrolled up), keep offset at 0
-        if (this.scrollbackOffset === 0) {
-            this.isInScrollbackMode = false;
-        }
-    }
-    /**
-     * Scroll up by a number of lines (PageUp)
-     * Note: Scrollback is disabled in alternate screen mode to avoid display corruption.
-     * Users should use their terminal's native scrollback or copy/paste features.
-     */
-    scrollUp(_lines = 10) {
-        // Scrollback disabled - alternate screen buffer doesn't support it well
-        // The scrollback buffer is still maintained for potential future use
-        // Users can select and copy text normally since mouse tracking is off
-    }
-    /**
-     * Scroll down by a number of lines (PageDown)
-     * Note: Scrollback disabled - see scrollUp comment
-     */
-    scrollDown(_lines = 10) {
-        // Scrollback disabled
-    }
-    /**
-     * Jump to the top of scrollback buffer
-     * DISABLED: Scrollback navigation causes display corruption in alternate screen mode.
-     * The scrollback buffer is maintained but cannot be rendered properly.
-     */
-    scrollToTop() {
-        // Disabled - causes display corruption in alternate screen buffer
-    }
-    /**
-     * Jump to the bottom (live mode)
-     * DISABLED: Scrollback navigation causes display corruption.
-     */
-    scrollToBottom() {
-        // Reset scrollback state in case it was somehow enabled
-        this.scrollbackOffset = 0;
-        this.isInScrollbackMode = false;
-    }
-    /**
-     * Toggle scrollback mode on/off (Ctrl+Shift+S hotkey; Alt+S legacy)
-     * DISABLED: Scrollback navigation causes display corruption in alternate screen mode.
-     */
-    toggleScrollbackMode() {
-        // Disabled - alternate screen buffer doesn't support manual scrollback rendering
-    }
-    /**
-     * Render the scrollback buffer view.
-     * DISABLED: This causes display corruption in alternate screen mode.
-     * The alternate screen buffer has its own rendering model that conflicts with
-     * manual scroll region manipulation.
-     */
-    renderScrollbackView() {
-        // Disabled - causes display corruption
-    }
-    /**
-     * Build scrollback header with navigation hints
-     */
-    buildScrollbackHeader(cols, totalLines, startIdx, endIdx) {
-        const percentage = Math.round((endIdx / totalLines) * 100);
-        // Animated scroll indicator
-        const scrollFrames = ['◆', '◇', '◆', '◈'];
-        this.scrollIndicatorFrame = (this.scrollIndicatorFrame + 1) % scrollFrames.length;
-        const indicator = scrollFrames[this.scrollIndicatorFrame];
-        // Build header parts
-        const leftPart = theme.info(`${indicator} SCROLLBACK`) +
-            theme.ui.muted(` [${startIdx + 1}-${endIdx} of ${totalLines}]`);
-        const progressBar = this.buildProgressBar(percentage, 15);
-        const rightPart = progressBar +
-            theme.ui.muted(` ${percentage}%`) +
-            theme.ui.muted(' │ ') +
-            theme.primary('PgUp') + theme.ui.muted('/') + theme.primary('PgDn') +
-            theme.ui.muted(' scroll · ') +
-            theme.primary('End') + theme.ui.muted(' exit');
-        const leftLen = this.visibleLength(leftPart);
-        const rightLen = this.visibleLength(rightPart);
-        const padding = Math.max(1, cols - leftLen - rightLen - 2);
-        return `${leftPart}${' '.repeat(padding)}${rightPart}`;
-    }
-    /**
-     * Render visual scroll track on the right side
-     */
-    renderScrollTrack(cols, contentHeight, totalLines, startIdx, endIdx) {
-        if (totalLines <= contentHeight || cols < 40)
-            return;
-        const trackHeight = contentHeight - 1; // Exclude header
-        const viewportRatio = (endIdx - startIdx) / totalLines;
-        const positionRatio = startIdx / Math.max(1, totalLines - (endIdx - startIdx));
-        // Calculate thumb size and position
-        const thumbSize = Math.max(1, Math.round(viewportRatio * trackHeight));
-        const thumbStart = Math.round(positionRatio * (trackHeight - thumbSize));
-        // Render track on right edge
-        for (let i = 0; i < trackHeight; i++) {
-            const row = 2 + i; // Start after header
-            this.write(ESC.TO(row, cols));
-            if (i >= thumbStart && i < thumbStart + thumbSize) {
-                // Thumb (viewport indicator)
-                this.write(theme.accent('█'));
-            }
-            else {
-                // Track background
-                this.write(theme.ui.muted('░'));
-            }
-        }
-    }
-    /**
-     * Build a visual progress bar
-     */
-    buildProgressBar(percentage, width = 10) {
-        const filled = Math.round((percentage / 100) * width);
-        const empty = width - filled;
-        const bar = theme.accent('█'.repeat(filled)) +
-            theme.ui.muted('░'.repeat(empty));
-        return `${theme.ui.muted('[')}${bar}${theme.ui.muted(']')}`;
-    }
-    /**
-     * Get scrollback buffer content (for persistence)
-     */
-    getScrollbackBuffer() {
-        return [...this.scrollbackBuffer];
-    }
-    /**
-     * Load scrollback buffer (for restoration)
-     */
-    loadScrollbackBuffer(lines) {
-        this.scrollbackBuffer = [...lines];
-        // Trim if necessary
-        while (this.scrollbackBuffer.length > this.maxScrollbackLines) {
-            this.scrollbackBuffer.shift();
-        }
-    }
-    /**
-     * Clear scrollback buffer
-     */
-    clearScrollbackBuffer() {
-        this.scrollbackBuffer = [];
-        this.scrollbackOffset = 0;
-        this.isInScrollbackMode = false;
-    }
-    // ===========================================================================
-    // UTILITIES
-    // ===========================================================================
-    getComposedLength() {
-        if (this.pastePlaceholders.length === 0) {
-            return this.buffer.length;
-        }
-        const sorted = [...this.pastePlaceholders].sort((a, b) => a.start - b.start);
-        let composed = 0;
-        let cursor = 0;
-        for (const placeholder of sorted) {
-            composed += Math.max(0, placeholder.start - cursor);
-            composed += placeholder.content.length;
-            cursor = placeholder.end;
-        }
-        composed += Math.max(0, this.buffer.length - cursor);
-        return composed;
-    }
-    assembleText() {
-        if (this.pastePlaceholders.length === 0) {
-            return this.buffer;
-        }
-        const sorted = [...this.pastePlaceholders].sort((a, b) => a.start - b.start);
-        let result = '';
-        let cursor = 0;
-        for (const placeholder of sorted) {
-            result += this.buffer.slice(cursor, placeholder.start);
-            result += placeholder.content;
-            cursor = placeholder.end;
-        }
-        result += this.buffer.slice(cursor);
-        return result;
-    }
-    shiftPlaceholders(start, delta, excludeId) {
-        if (delta === 0)
-            return;
-        for (const placeholder of this.pastePlaceholders) {
-            if (excludeId && placeholder.id === excludeId)
-                continue;
-            if (placeholder.start >= start) {
-                placeholder.start += delta;
-                placeholder.end += delta;
-            }
-        }
-    }
-    removeRange(start, end) {
-        // Expand deletion to cover any placeholder that overlaps the range
-        let adjustedStart = start;
-        let adjustedEnd = end;
-        for (const ph of this.pastePlaceholders) {
-            if (ph.start < adjustedEnd && ph.end > adjustedStart) {
-                adjustedStart = Math.min(adjustedStart, ph.start);
-                adjustedEnd = Math.max(adjustedEnd, ph.end);
-            }
-        }
-        const length = Math.max(0, adjustedEnd - adjustedStart);
-        if (length === 0)
-            return;
-        this.buffer = this.buffer.slice(0, adjustedStart) + this.buffer.slice(adjustedEnd);
-        // Remove any placeholders that were within the deleted range
-        this.pastePlaceholders = this.pastePlaceholders.filter((ph) => {
-            return ph.end <= adjustedStart || ph.start >= adjustedEnd;
-        });
-        // Shift remaining placeholders that were after the deleted range
-        this.shiftPlaceholders(adjustedEnd, -length);
-        this.clampCursor();
-    }
-    insertPlainText(text, position) {
-        if (!text)
-            return;
-        this.shiftPlaceholders(position, text.length);
-        this.buffer = this.buffer.slice(0, position) + text + this.buffer.slice(position);
-    }
-    shouldInlineMultiline(content) {
-        const lines = content.split('\n').length;
-        const maxInlineLines = 4;
-        const maxInlineChars = 240;
-        return lines <= maxInlineLines && content.length <= maxInlineChars;
-    }
-    findPlaceholderAt(position) {
-        return this.pastePlaceholders.find((ph) => position >= ph.start && position < ph.end) ?? null;
-    }
-    buildPlaceholder(lineCount) {
-        const id = ++this.pasteCounter;
-        const plural = lineCount === 1 ? '' : 's';
-        const placeholder = `[Pasted text #${id} +${lineCount} line${plural}]`;
-        return { id, placeholder };
-    }
-    insertPastePlaceholder(content) {
-        const available = this.config.maxLength - this.getComposedLength();
-        if (available <= 0)
-            return;
-        const cleanContent = content.slice(0, available);
-        const lineCount = cleanContent.split('\n').length;
-        const { id, placeholder } = this.buildPlaceholder(lineCount);
-        const insertPos = this.cursor;
-        this.shiftPlaceholders(insertPos, placeholder.length);
-        this.pastePlaceholders.push({
-            id,
-            content: cleanContent,
-            lineCount,
-            placeholder,
-            start: insertPos,
-            end: insertPos + placeholder.length,
-        });
-        this.buffer = this.buffer.slice(0, insertPos) + placeholder + this.buffer.slice(insertPos);
-        this.cursor = insertPos + placeholder.length;
-    }
-    deletePlaceholder(placeholder) {
-        const length = placeholder.end - placeholder.start;
-        this.buffer = this.buffer.slice(0, placeholder.start) + this.buffer.slice(placeholder.end);
-        this.pastePlaceholders = this.pastePlaceholders.filter((ph) => ph.id !== placeholder.id);
-        this.shiftPlaceholders(placeholder.end, -length, placeholder.id);
-        this.cursor = placeholder.start;
-    }
-    updateContextUsage(value, autoCompactThreshold) {
-        if (typeof autoCompactThreshold === 'number' && Number.isFinite(autoCompactThreshold)) {
-            const boundedThreshold = Math.max(1, Math.min(100, Math.round(autoCompactThreshold)));
-            this.contextAutoCompactThreshold = boundedThreshold;
-        }
-        if (value === null || !Number.isFinite(value)) {
-            this.contextUsage = null;
-        }
-        else {
-            const bounded = Math.max(0, Math.min(100, Math.round(value)));
-            this.contextUsage = bounded;
-        }
-        this.scheduleRender();
-    }
-    getEditMode() {
-        return this.editMode;
-    }
-    applyEditMode(mode) {
-        this.setEditMode(mode);
-    }
-    setEditMode(mode) {
-        if (this.editMode === mode)
-            return;
-        this.editMode = mode;
-        this.emit('mode-change', this.editMode);
-        this.scheduleRender();
-    }
-    toggleEditMode() {
-        // Cycle through: display-edits → ask-permission → plan → display-edits
-        const cycle = ['display-edits', 'ask-permission', 'plan'];
-        const currentIndex = cycle.indexOf(this.editMode);
-        const nextIndex = (currentIndex + 1) % cycle.length;
-        this.setEditMode(cycle[nextIndex]);
-    }
-    scheduleStreamingRender(delayMs) {
-        if (this.streamingRenderTimer)
-            return;
-        const wait = Math.max(16, delayMs);
-        this.streamingRenderTimer = setTimeout(() => {
-            this.streamingRenderTimer = null;
-            // During streaming, only update chat box (not full render)
-            if (this.scrollRegionActive) {
-                this.renderStreamingFrame();
-            }
-            else {
-                this.render();
-            }
-        }, wait);
-    }
-    /**
-     * Render the pinned chat box during streaming only when we actually have
-     * pending UI changes. Prevents meta/header lines from being echoed into the
-     * streamed log when nothing changed.
-     */
-    renderStreamingFrame() {
-        if (!this.canRender())
-            return;
-        if (this.isRendering)
-            return;
-        const shouldSkip = !this.renderDirty &&
-            this.buffer === this.lastRenderContent &&
-            this.cursor === this.lastRenderCursor;
-        // Clear the dirty flag even when skipping to avoid runaway retries.
-        this.renderDirty = false;
-        if (shouldSkip) {
-            return;
-        }
-        if (writeLock.isLocked()) {
-            writeLock.safeWrite(() => this.renderStreamingFrame());
-            return;
-        }
-        this.renderPinnedChatBox();
-    }
-    resetStreamingRenderThrottle() {
-        if (this.streamingRenderTimer) {
-            clearTimeout(this.streamingRenderTimer);
-            this.streamingRenderTimer = null;
-        }
-        this.lastStreamingRender = 0;
-    }
-    scheduleRender() {
-        if (!this.canRender())
-            return;
-        this.renderDirty = true;
-        queueMicrotask(() => this.render());
-    }
-    canRender() {
-        return !this.disposed && this.enabled && this.isTTY();
-    }
-    isTTY() {
-        return !!this.out.isTTY && this.out.writable !== false;
-    }
-    getSize() {
-        return {
-            rows: this.out.rows ?? 24,
-            cols: this.out.columns ?? 80,
-        };
-    }
-    write(data) {
-        try {
-            if (this.out.writable) {
-                this.out.write(data);
-            }
-        }
-        catch {
-            // Ignore write errors
-        }
-    }
-    sanitize(text) {
-        if (!text)
-            return '';
-        // Remove ANSI codes and control chars (except newlines)
-        return text
-            .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '') // OSC sequences
-            .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '') // CSI sequences
-            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '') // Control chars except \n and \r
-            .replace(/\r\n?/g, '\n'); // Normalize line endings
-    }
-    getArrowKeyName(sequence) {
-        if (!sequence)
-            return null;
-        const match = sequence.match(/\x1b(?:\[[0-9;]*|O)([ABCD])$/) ||
-            sequence.match(/^\[?[0-9;]*([ABCD])$/);
-        if (!match)
-            return null;
-        switch (match[1]) {
-            case 'A':
-                return 'up';
-            case 'B':
-                return 'down';
-            case 'C':
-                return 'right';
-            case 'D':
-                return 'left';
-            default:
-                return null;
-        }
-    }
-    getFallbackKeyName(str) {
-        if (!str)
-            return null;
-        if (this.isBackspaceChar(str)) {
-            return 'backspace';
-        }
-        return null;
-    }
-    isArrowEscapeFragment(text) {
-        if (!text)
-            return false;
-        if (text.length > 8)
-            return false;
-        return (/^\x1b?(?:\[[0-9;]*|O)[ABCD]$/.test(text) ||
-            (/^\[?[0-9;]*[ABCD]$/.test(text) && text.length <= 6));
-    }
-    isOrphanedEscapeSequence(text, key) {
-        if (!text || key?.name)
-            return false;
-        // If sanitizing leaves printable content, treat it as user input.
-        const sanitized = this.sanitize(text);
-        if (sanitized.length > 0) {
-            return false;
-        }
-        if (text.includes('\x1b'))
-            return true;
-        // Common stray fragments when terminals partially echo arrow sequences (e.g., "[D")
-        return text.length <= 5 && (/^[\[O][0-9;]*[A-Za-z]$/.test(text));
-    }
-    isWhitespace(char) {
-        return char === ' ' || char === '\t' || char === '\n';
-    }
-    isBackspaceChar(text) {
-        if (!text)
-            return false;
-        return text === '\b' || text === '\x7f';
-    }
-    isStandaloneControlChar(text) {
-        if (text.length !== 1) {
-            return false;
-        }
-        const code = text.charCodeAt(0);
-        return (code <= 0x1f || code === 0x7f);
-    }
-    clampCursor() {
-        this.cursor = Math.max(0, Math.min(this.cursor, this.buffer.length));
-    }
-}
-//# sourceMappingURL=terminalInput.js.map