erosolar-cli 1.7.189 → 1.7.191

package/dist/shell/interactiveShell.js

@@ -1,4 +1,3 @@
-import readline from 'node:readline';
 import { stdin as input, stdout as output, exit } from 'node:process';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -8,8 +7,6 @@ import { getContextWindowTokens } from '../core/contextWindow.js';
 import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue, listSecretDefinitions, maskSecret, setSecretValue, } from '../core/secretStore.js';
 import { saveActiveProfilePreference, saveModelPreference, loadToolSettings, saveToolSettings, clearToolSettings, clearActiveProfilePreference, loadSessionPreferences, saveSessionPreferences, } from '../core/preferences.js';
 import { buildEnabledToolSet, evaluateToolPermissions, getToolToggleOptions, } from '../capabilities/toolRegistry.js';
-import { BracketedPasteManager } from './bracketedPasteManager.js';
-import { ComposableMessageBuilder } from './composableMessage.js';
 import { detectApiKeyError } from '../core/errors/apiKeyErrors.js';
 import { buildWorkspaceContext } from '../workspace.js';
 import { buildInteractiveSystemPrompt } from './systemPrompt.js';
@@ -21,12 +18,10 @@ import { buildCustomCommandPrompt, loadCustomSlashCommands, } from '../core/cust
 import { SkillRepository } from '../skills/skillRepository.js';
 import { createSkillTools } from '../tools/skillTools.js';
 import { FileChangeTracker } from './fileChangeTracker.js';
-import { PersistentPrompt, PinnedChatBox } from '../ui/persistentPrompt.js';
 import { formatShortcutsHelp } from '../ui/shortcutsHelp.js';
 import { MetricsTracker } from '../alpha-zero/index.js';
 import { listAvailablePlugins } from '../plugins/index.js';
-import { getClaudeCodeStreamHandler } from './claudeCodeStreamHandler.js';
-import { getUnifiedChatBox } from './unifiedChatBox.js';
+import { TerminalInputAdapter } from './terminalInputAdapter.js';
 const execAsync = promisify(exec);
 const DROPDOWN_COLORS = [
     theme.primary,
@@ -54,9 +49,6 @@ const BASE_SLASH_COMMANDS = getSlashCommands().map((cmd) => ({
 // Load PROVIDER_LABELS from centralized schema
 const PROVIDER_LABELS = Object.fromEntries(getProviders().map((provider) => [provider.id, provider.label]));
 // Allow enough time for paste detection to kick in before flushing buffered lines
-const MULTILINE_INPUT_FLUSH_DELAY_MS = 120;
-const BRACKETED_PASTE_ENABLE = '\u001b[?2004h';
-const BRACKETED_PASTE_DISABLE = '\u001b[?2004l';
 const CONTEXT_USAGE_THRESHOLD = 0.9;
 const CONTEXT_RECENT_MESSAGE_COUNT = 12;
 const CONTEXT_CLEANUP_CHARS_PER_CHUNK = 6000;
@@ -68,7 +60,6 @@ const CONTEXT_CLEANUP_SYSTEM_PROMPT = `You condense earlier IDE collaboration lo
 - Keep the response under roughly 200 words, prefer short bullet lists.
 - Never call tools or run shell commands; respond with plain Markdown text only.`;
 export class InteractiveShell {
-    rl;
     agent = null;
     profile;
     profileLabel;
@@ -78,18 +69,14 @@ export class InteractiveShell {
     workspaceOptions;
     sessionState;
     isProcessing = false;
+    shuttingDown = false;
     pendingInteraction = null;
     pendingSecretRetry = null;
-    bufferedInputLines = [];
-    bufferedInputTimer = null;
-    bracketedPaste;
-    bracketedPasteEnabled = false;
-    composableMessage = new ComposableMessageBuilder();
+    terminalInput;
+    currentInput = '';
     pendingCleanup = null;
     cleanupInProgress = false;
     slashPreviewVisible = false;
-    keypressHandler = null;
-    rawDataHandler = null;
     skillRepository;
     skillToolHandlers = new Map();
     thinkingMode = 'balanced';
@@ -99,7 +86,6 @@ export class InteractiveShell {
     statusTracker;
     uiAdapter;
     _fileChangeTracker = new FileChangeTracker(); // Reserved for future file tracking features
-    persistentPrompt;
     alphaZeroMetrics; // Alpha Zero 2 performance tracking
     statusSubscription = null;
     followUpQueue = [];
@@ -117,11 +103,6 @@ export class InteractiveShell {
     customCommandMap;
     sessionRestoreConfig;
     _enabledPlugins;
-    pinnedChatBox;
-    readlineOutputSuppressed = false;
-    originalStdoutWrite = null;
-    streamHandler;
-    unifiedChatBox;
     // Cached provider status for unified status bar display after streaming
     cachedProviderStatus = [];
     // Auto-test tracking
@@ -180,19 +161,10 @@ export class InteractiveShell {
         // Set up file change tracking callback
         this.uiAdapter.setFileChangeCallback((path, type, additions, removals) => {
             this._fileChangeTracker.recordChange(path, type, additions, removals);
-            // Update persistent prompt status bar with file changes
-            this.updatePersistentPromptFileChanges();
         });
-        // Set up tool status callback to update pinned chat box during tool execution
+        // Set up tool status callback to update status during tool execution
         this.uiAdapter.setToolStatusCallback((status) => {
-            if (status) {
-                this.pinnedChatBox.setStatusMessage(status);
-            }
-            else {
-                // Clear status but keep processing indicator if still processing
-                this.pinnedChatBox.setStatusMessage(null);
-            }
-            this.pinnedChatBox.forceRender();
+            this.updateStatusMessage(status ?? null);
         });
         this.skillRepository = new SkillRepository({
             workingDir: this.workingDir,
@@ -201,62 +173,18 @@ export class InteractiveShell {
         for (const definition of createSkillTools({ repository: this.skillRepository })) {
             this.skillToolHandlers.set(definition.name, definition.handler);
         }
-        this.rl = readline.createInterface({
-            input,
-            output,
-            // Use '> ' as the standard prompt prefix
-            prompt: formatUserPrompt(this.profileLabel || this.profile),
-            terminal: true,
-            historySize: 100, // Enable native readline history
-        });
-        // Wrap prompt() so we always re-arm stdin before showing it
-        const originalPrompt = this.rl.prompt.bind(this.rl);
-        this.rl.prompt = (preserveCursor) => {
-            this.ensureReadlineReady();
-            originalPrompt(preserveCursor);
-        };
-        // Initialize persistent prompt (Claude Code style)
-        this.persistentPrompt = new PersistentPrompt(output, formatUserPrompt(this.profileLabel || this.profile));
-        // Initialize pinned chat box for always-visible input during AI processing
-        // Note: Pass empty string for promptText since render() adds its own '> ' prefix
-        this.pinnedChatBox = new PinnedChatBox(output, '', // Don't pass formatUserPrompt - the render method adds '> ' prefix
-        {
-            onCommandQueued: (cmd) => {
-                // Bridge to existing follow-up queue system
-                this.followUpQueue.push({
-                    type: cmd.type === 'slash' ? 'request' : cmd.type,
-                    text: cmd.text,
-                });
-                this.refreshQueueIndicators();
-            },
-            onInputSubmit: (input) => {
-                // Process the input through the normal flow
-                this.processInputBlock(input).catch((err) => {
-                    display.showError(err instanceof Error ? err.message : String(err), err);
-                });
-            },
+        // Initialize unified terminal input handler
+        this.terminalInput = new TerminalInputAdapter(input, output, {
+            onSubmit: (text) => this.processInput(text),
+            onQueue: (text) => this.handleQueuedInput(text),
+            onInterrupt: () => this.handleInterrupt(),
+            onChange: (text) => this.handleInputChange(text),
         });
-        // Register pinned chat box with display's output interceptor system
-        // This ensures the pinned area is cleared before output and re-rendered after,
-        // preventing ghost lines when the terminal scrolls
-        this.pinnedChatBox.registerOutputInterceptor(display);
-        // Initialize Claude Code style stream handler for natural output flow
-        // Key insight: No cursor manipulation during streaming - output just appends
-        this.streamHandler = getClaudeCodeStreamHandler();
-        this.streamHandler.attachToReadline(this.rl);
-        // Initialize UnifiedChatBox - Claude Code exact style
-        // The chat box is always at the bottom naturally through readline
-        // During streaming: output flows up, typed input queued invisibly
-        // After streaming: new prompt appears at bottom naturally
-        this.unifiedChatBox = getUnifiedChatBox();
-        this.unifiedChatBox.attachToReadline(this.rl);
-        this.unifiedChatBox.setPrompt(formatUserPrompt(this.profileLabel || this.profile));
         // Initialize Alpha Zero 2 metrics tracking
         this.alphaZeroMetrics = new MetricsTracker(`${this.profile}-${Date.now()}`);
         this.setupStatusTracking();
         this.refreshContextGauge();
-        this.bracketedPasteEnabled = this.enableBracketedPasteMode();
-        this.bracketedPaste = new BracketedPasteManager(this.bracketedPasteEnabled);
+        this.terminalInput.start();
         this.rebuildAgent();
         this.setupHandlers();
         this.refreshBannerSessionInfo();
@@ -303,17 +231,88 @@ export class InteractiveShell {
         this.sessionResumeNotice = null;
     }
     async start(initialPrompt) {
-        // Claude Code style: Just use readline's prompt
-        // The prompt naturally appears at the bottom
-        // No complex UI rendering needed - terminal handles it naturally
         if (initialPrompt) {
             display.newLine();
             console.log(`${formatUserPrompt(this.profileLabel || this.profile)}${initialPrompt}`);
             await this.processInputBlock(initialPrompt);
             return;
         }
-        // Show readline prompt - naturally at bottom of terminal
-        this.rl.prompt();
+        // Ensure the terminal input is visible
+        this.terminalInput.render();
+    }
+    /**
+     * TerminalInputAdapter submit handler
+     */
+    processInput(text) {
+        this.handleInputChange('');
+        void this.processInputBlock(text).catch((err) => {
+            display.showError(err instanceof Error ? err.message : String(err), err);
+        });
+    }
+    /**
+     * TerminalInputAdapter queue handler (streaming mode)
+     */
+    handleQueuedInput(text) {
+        // Keep adapter queue trimmed so hints stay accurate
+        this.terminalInput.dequeue();
+        this.followUpQueue.push({ type: 'request', text });
+        display.showInfo(`Queued: "${text}"`);
+        this.refreshQueueIndicators();
+        this.scheduleQueueProcessing();
+        this.handleInputChange('');
+    }
+    /**
+     * TerminalInputAdapter change handler
+     */
+    handleInputChange(text) {
+        this.currentInput = text;
+        this.handleSlashCommandPreviewChange();
+    }
+    /**
+     * TerminalInputAdapter interrupt handler (Ctrl+C with empty buffer)
+     */
+    handleInterrupt() {
+        if (this.isProcessing && this.agent) {
+            this.agent.requestCancellation();
+            display.showWarning('Cancelling current operation... (Ctrl+C again to force quit)');
+            return;
+        }
+        this.shutdown();
+    }
+    /**
+     * Gracefully tear down the shell and exit
+     */
+    shutdown() {
+        if (this.shuttingDown) {
+            return;
+        }
+        this.shuttingDown = true;
+        // Stop any active spinner to prevent process hang
+        display.stopThinking(false);
+        this.teardownStatusTracking();
+        // Clear any pending cleanup to prevent hanging
+        this.pendingCleanup = null;
+        // Dispose terminal input handler
+        this.terminalInput.dispose();
+        // Dispose unified UI adapter
+        this.uiAdapter.dispose();
+        display.newLine();
+        const highlightedEmail = theme.info('support@ero.solar');
+        const infoMessage = [
+            'Thank you to Anthropic for allowing me to use Claude Code to build erosolar-cli.',
+            '',
+            `Email ${highlightedEmail} with any bugs or feedback`,
+            'GitHub: https://github.com/ErosolarAI/erosolar-by-bo',
+            'npm: https://www.npmjs.com/package/erosolar-cli',
+        ].join('\n');
+        display.showInfo(infoMessage);
+        exit(0);
+    }
+    /**
+     * Update status bar message
+     */
+    updateStatusMessage(_message) {
+        this.terminalInput.render();
     }
     async handleToolSettingsInput(input) {
         const pending = this.pendingInteraction;
@@ -323,26 +322,26 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number, "save", "defaults", or "cancel".');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const normalized = trimmed.toLowerCase();
         if (normalized === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Tool selection cancelled.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         if (normalized === 'defaults') {
             pending.selection = buildEnabledToolSet(null);
             this.renderToolMenu(pending);
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         if (normalized === 'save') {
             await this.persistToolSelection(pending);
             this.pendingInteraction = null;
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
@@ -360,11 +359,11 @@ export class InteractiveShell {
                 }
                 this.renderToolMenu(pending);
             }
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         display.showWarning('Enter a number, "save", "defaults", or "cancel".');
-        this.rl.prompt();
+        this.terminalInput.render();
     }
     async persistToolSelection(interaction) {
         if (setsEqual(interaction.selection, interaction.initialSelection)) {
@@ -391,36 +390,36 @@ export class InteractiveShell {
         if (!this.agentMenu) {
             this.pendingInteraction = null;
             display.showWarning('Agent selection is unavailable in this CLI.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number or type "cancel".');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Agent selection cancelled.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
             display.showWarning('Please enter a valid number.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const option = pending.options[choice - 1];
         if (!option) {
             display.showWarning('That option is not available.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         await this.persistAgentSelection(option.name);
         this.pendingInteraction = null;
-        this.rl.prompt();
+        this.terminalInput.render();
     }
     async persistAgentSelection(profileName) {
         if (!this.agentMenu) {
@@ -442,342 +441,12 @@ export class InteractiveShell {
         display.showInfo(`${this.agentMenuLabel(profileName)} will load the next time you start the CLI. Restart to switch now.`);
     }
     setupHandlers() {
-        // Set up raw data interception for bracketed paste
-        this.setupRawPasteHandler();
-        this.rl.on('line', (line) => {
-            // If we're capturing raw paste data, ignore readline line events
-            // (they've already been handled by the raw data handler)
-            if (this.bracketedPaste.isCapturingRaw()) {
-                this.resetBufferedInputLines();
-                // Clear the line that readline just echoed - move up and clear
-                output.write('\x1b[A\r\x1b[K');
-                // Show paste progress (this will update in place)
-                this.showMultiLinePastePreview(this.bracketedPaste.getRawBufferLineCount(), this.bracketedPaste.getRawBufferPreview());
-                return;
-            }
-            // If a paste was just captured via raw handler, ignore readline's line events
-            // (readline still emits line events after we've already captured the paste)
-            if (this.bracketedPaste.shouldIgnoreLineEvent()) {
-                this.resetBufferedInputLines();
-                // Clear the echoed line that readline wrote
-                output.write('\x1b[A\r\x1b[K');
-                return;
-            }
-            const normalized = this.bracketedPaste.process(line);
-            if (normalized.handled) {
-                // Clear any partially buffered lines so we don't auto-submit the first line of a paste
-                this.resetBufferedInputLines();
-                // If still accumulating multi-line paste, show preview
-                if (normalized.isPending) {
-                    // Clear the line that readline just echoed - move up and clear
-                    output.write('\x1b[A\r\x1b[K');
-                    this.showMultiLinePastePreview(normalized.lineCount || 0, normalized.preview);
-                    return;
-                }
-                // Paste complete, store or submit the full content
-                if (typeof normalized.result === 'string') {
-                    this.clearMultiLinePastePreview();
-                    const lineCount = normalized.lineCount ?? normalized.result.split('\n').length;
-                    // All pastes (single or multi-line) are captured for confirmation before submit
-                    void this.capturePaste(normalized.result, lineCount);
-                    return;
-                }
-                return;
-            }
-            this.enqueueUserInput(line);
-            // Clear input in persistent prompt after submission
-            this.persistentPrompt.updateInput('', 0);
-        });
-        this.rl.on('close', () => {
-            // Stop any active spinner to prevent process hang
-            display.stopThinking(false);
-            this.disableBracketedPasteMode();
-            this.teardownStatusTracking();
-            // Remove keypress listener to prevent memory leaks
-            const inputStream = input;
-            if (inputStream && this.keypressHandler) {
-                inputStream.off('keypress', this.keypressHandler);
-                this.keypressHandler = null;
-            }
-            // Restore original stdin emit (cleanup from paste interception)
-            if (this.rawDataHandler) {
-                this.rawDataHandler(); // This restores the original emit function
-                this.rawDataHandler = null;
-            }
-            // Clear any pending cleanup to prevent hanging
-            this.pendingCleanup = null;
-            // Dispose persistent prompt
-            this.persistentPrompt.dispose();
-            // Dispose Claude Code stream handler
-            this.streamHandler.dispose();
-            // Dispose unified chat box
-            this.unifiedChatBox.dispose();
-            // Dispose unified UI adapter
-            this.uiAdapter.dispose();
-            display.newLine();
-            const highlightedEmail = theme.info('support@ero.solar');
-            const infoMessage = [
-                'Thank you to Anthropic for allowing me to use Claude Code to build erosolar-cli.',
-                '',
-                `Email ${highlightedEmail} with any bugs or feedback`,
-                'GitHub: https://github.com/ErosolarAI/erosolar-by-bo',
-                'npm: https://www.npmjs.com/package/erosolar-cli',
-            ].join('\n');
-            display.showInfo(infoMessage);
-            exit(0);
-        });
         // Handle terminal resize
         output.on('resize', () => {
-            this.persistentPrompt.handleResize();
-            this.pinnedChatBox.handleResize();
-        });
-        this.setupSlashCommandPreviewHandler();
-        // Show initial persistent prompt
-        this.persistentPrompt.show();
-    }
-    /**
-     * Set up raw stdin data interception for bracketed paste mode.
-     * This intercepts data before readline processes it, allowing us to
-     * capture complete multi-line pastes without readline splitting them.
-     */
-    setupRawPasteHandler() {
-        if (!this.bracketedPasteEnabled) {
-            return;
-        }
-        const inputStream = input;
-        if (!inputStream || !inputStream.isTTY) {
-            return;
-        }
-        // Set up callback for when a complete paste is captured
-        this.bracketedPaste.setRawPasteCallback((content) => {
-            this.clearMultiLinePastePreview();
-            const lines = content.split('\n');
-            const lineCount = lines.length;
-            // When streaming, route pastes into the pinned chat box instead of readline
-            if (this.isProcessing) {
-                this.pinnedChatBox.handlePaste(content);
-                this.pinnedChatBox.updatePersistentInput();
-                return;
-            }
-            // All pastes (single or multi-line) are captured for confirmation before submit
-            void this.capturePaste(content, lineCount);
+            this.terminalInput.handleResize();
         });
-        // Set up raw data interception to catch bracketed paste before readline processes it.
-        // We need to actually PREVENT readline from seeing the paste content to avoid echo.
-        // Strategy: Replace stdin's 'data' event emission during paste capture.
-        const originalEmit = inputStream.emit.bind(inputStream);
-        inputStream.emit = (event, ...args) => {
-            if (event === 'data' && args[0]) {
-                const data = args[0];
-                const str = typeof data === 'string' ? data : data.toString();
-                const result = this.bracketedPaste.processRawData(str);
-                if (result.consumed) {
-                    // Data was consumed by paste handler - don't pass to readline
-                    // If there's passThrough data, emit that instead
-                    if (result.passThrough) {
-                        return originalEmit('data', Buffer.from(result.passThrough));
-                    }
-                    return true; // Event "handled" but not passed to other listeners
-                }
-            }
-            // Pass through all other events and non-paste data normally
-            return originalEmit(event, ...args);
-        };
-        // Store reference for cleanup
-        this.rawDataHandler = () => {
-            inputStream.emit = originalEmit;
-        };
-    }
-    setupSlashCommandPreviewHandler() {
-        const inputStream = input;
-        if (!inputStream || typeof inputStream.on !== 'function' || !inputStream.isTTY) {
-            return;
-        }
-        if (inputStream.listenerCount('keypress') === 0) {
-            readline.emitKeypressEvents(inputStream, this.rl);
-        }
-        // Ensure raw mode for keypress events
-        if (inputStream.setRawMode && !inputStream.isRaw) {
-            inputStream.setRawMode(true);
-        }
-        this.keypressHandler = (_str, key) => {
-            // Handle special keys
-            if (key) {
-                // Shift+Tab: Cycle paste preview options if paste blocks exist, otherwise profile switching
-                if (key.name === 'tab' && key.shift) {
-                    // Check if there are paste blocks to cycle through
-                    const pasteBlockCount = this.composableMessage.getPasteBlockCount();
-                    if (pasteBlockCount > 0) {
-                        this.cyclePastePreview();
-                        return;
-                    }
-                    // Fall through to profile switching if no paste blocks
-                    if (this.agentMenu) {
-                        this.showProfileSwitcher();
-                        return;
-                    }
-                }
-                // Tab: Autocomplete slash commands
-                if (key.name === 'tab' && !key.shift && !key.ctrl) {
-                    this.handleTabCompletion();
-                    return;
-                }
-                // Escape: Cancel current operation if agent is running
-                if (key.name === 'escape') {
-                    if (this.isProcessing && this.agent) {
-                        this.agent.requestCancellation();
-                        output.write('\n');
-                        display.showWarning('Cancelling current operation... (waiting for safe stop point)');
-                        return;
-                    }
-                    // If not processing, clear any queued follow-ups
-                    if (this.followUpQueue.length > 0) {
-                        const cleared = this.followUpQueue.length;
-                        this.followUpQueue.length = 0;
-                        this.refreshQueueIndicators();
-                        output.write('\n');
-                        display.showInfo(`Cleared ${cleared} queued follow-up${cleared === 1 ? '' : 's'}.`);
-                        this.rl.prompt();
-                        return;
-                    }
-                }
-                // Ctrl+C: Clear input first, then cancel operation if no input
-                if (key.ctrl && key.name === 'c') {
-                    // During processing, check pinnedChatBox input first
-                    if (this.isProcessing) {
-                        const chatBoxInput = this.pinnedChatBox.getInput();
-                        if (chatBoxInput.length > 0) {
-                            // Clear the chat box input instead of cancelling
-                            this.pinnedChatBox.clearPastedBlockState();
-                            this.pinnedChatBox.updatePersistentInput();
-                            return;
-                        }
-                        // No text in chat box, cancel the agent
-                        if (this.agent) {
-                            this.agent.requestCancellation();
-                            output.write('\n');
-                            display.showWarning('Cancelling current operation... (Ctrl+C again to force quit)');
-                            return;
-                        }
-                    }
-                    // Not processing - check readline input
-                    const currentLine = this.rl.line || '';
-                    if (currentLine.length > 0) {
-                        // Clear the input buffer instead of exiting
-                        this.rl.line = '';
-                        this.rl.cursor = 0;
-                        this.persistentPrompt.updateInput('', 0);
-                        this.pinnedChatBox.setInput('');
-                        this.pinnedChatBox.clearPastedBlockState();
-                        // Clear the displayed line and show fresh prompt
-                        output.write('\r\x1b[K'); // Clear current line
-                        output.write('^C\n'); // Show ^C indicator
-                        this.rl.prompt(); // Re-show prompt
-                        return;
-                    }
-                    // If no text in buffer, let default Ctrl+C behavior exit
-                }
-                // Ctrl+G: Edit pasted content blocks
-                if (key.ctrl && key.name === 'g') {
-                    this.showPasteBlockEditor();
-                    return;
-                }
-            }
-            // Claude Code approach: During processing, route input to PinnedChatBox
-            // - User can type and see their input in the visible chat box at bottom
-            // - Input is queued until streaming ends
-            // - After each keystroke, we re-render the bottom area to show the input
-            if (this.isProcessing) {
-                // Handle paste: if _str contains newlines, it's a paste - don't auto-submit
-                const isPaste = typeof _str === 'string' && (_str.length > 1 || _str.includes('\n'));
-                if (key) {
-                    if (key.name === 'backspace') {
-                        this.pinnedChatBox.handleBackspace();
-                    }
-                    else if (key.name === 'delete') {
-                        this.pinnedChatBox.handleDelete();
-                    }
-                    else if (key.name === 'left') {
-                        if (key.meta || key.alt) {
-                            this.pinnedChatBox.handleWordLeft();
-                        }
-                        else {
-                            this.pinnedChatBox.handleCursorLeft();
-                        }
-                    }
-                    else if (key.name === 'right') {
-                        if (key.meta || key.alt) {
-                            this.pinnedChatBox.handleWordRight();
-                        }
-                        else {
-                            this.pinnedChatBox.handleCursorRight();
-                        }
-                    }
-                    else if (key.name === 'up') {
-                        this.pinnedChatBox.handleHistoryUp();
-                    }
-                    else if (key.name === 'down') {
-                        this.pinnedChatBox.handleHistoryDown();
-                    }
-                    else if (key.name === 'home' || (key.ctrl && key.name === 'a')) {
-                        this.pinnedChatBox.handleHome();
-                    }
-                    else if (key.name === 'end' || (key.ctrl && key.name === 'e')) {
-                        this.pinnedChatBox.handleEnd();
-                    }
-                    else if (key.ctrl && key.name === 'u') {
-                        this.pinnedChatBox.handleDeleteToStart();
-                    }
-                    else if (key.ctrl && key.name === 'k') {
-                        this.pinnedChatBox.handleDeleteToEnd();
-                    }
-                    else if (key.ctrl && key.name === 'w') {
-                        this.pinnedChatBox.handleDeleteWord();
-                    }
-                    else if (key.name === 'return' && (key.shift || key.meta || key.ctrl)) {
-                        // Shift+Enter or Option+Enter: Insert newline for multi-line input
-                        this.pinnedChatBox.handleNewline();
-                    }
-                    else if (key.name === 'return' && !isPaste) {
-                        // Queue the command - but NOT if this is part of a paste
-                        const result = this.pinnedChatBox.handleSubmit();
-                        if (result) {
-                            const preview = result.replace(/\s+/g, ' ').trim();
-                            const displayText = preview.length > 50 ? `${preview.slice(0, 47)}...` : preview;
-                            display.showInfo(`📝 Queued: "${displayText}"`);
-                        }
-                    }
-                    else if (_str && !key.ctrl && !key.meta) {
-                        // Route raw input (including multi-line paste) to the pinned chat box
-                        this.pinnedChatBox.handleInput(_str, { allowNewlines: true, isPaste });
-                    }
-                }
-                else if (_str) {
-                    // String without key info (paste) - pass through for summary handling
-                    this.pinnedChatBox.handleInput(_str, { allowNewlines: true, isPaste: true });
-                }
-                // Re-render the bottom chat box to show the updated input
-                this.pinnedChatBox.updatePersistentInput();
-                return;
-            }
-            // Readline handles all keyboard input natively (history, shortcuts, etc.)
-            // We just sync the current state to our display components
-            // Use setImmediate to get the updated line after readline processes the key
-            setImmediate(() => {
-                const currentLine = this.rl.line || '';
-                const cursorPos = this.rl.cursor || 0;
-                this.persistentPrompt.updateInput(currentLine, cursorPos);
-                // Sync to pinned chat box for display only
-                this.pinnedChatBox.setInput(currentLine, cursorPos);
-                if (this.composableMessage.hasContent()) {
-                    this.composableMessage.setDraft(currentLine);
-                    this.updateComposeStatusSummary();
-                }
-                this.handleSlashCommandPreviewChange();
-            });
-        };
-        // Use prependListener to handle before readline
-        inputStream.prependListener('keypress', this.keypressHandler);
+        // Show initial input UI
+        this.terminalInput.render();
     }
     setupStatusTracking() {
         this.statusSubscription = this.statusTracker.subscribe((_state) => {
@@ -835,14 +504,10 @@ export class InteractiveShell {
         if (!shouldShow && this.slashPreviewVisible) {
             this.slashPreviewVisible = false;
             this.uiAdapter.hideSlashCommandPreview();
-            // Show persistent prompt again after hiding overlay
-            if (!this.isProcessing) {
-                this.persistentPrompt.show();
-            }
         }
     }
     shouldShowSlashCommandPreview() {
-        const line = this.rl.line ?? '';
+        const line = this.currentInput ?? '';
         if (!line.trim()) {
             return false;
         }
@@ -851,642 +516,28 @@ export class InteractiveShell {
     }
     showSlashCommandPreview() {
         // Filter commands based on current input
-        const line = this.rl.line ?? '';
+        const line = this.currentInput ?? '';
         const trimmed = line.trimStart();
         // Filter commands that match the current input
         const filtered = this.slashCommands.filter(cmd => cmd.command.startsWith(trimmed) || trimmed === '/');
-        // Hide persistent prompt to avoid conflicts with overlay
-        this.persistentPrompt.hide();
         // Show in the unified UI with dynamic overlay
         this.uiAdapter.showSlashCommandPreview(filtered);
         // Don't reprompt - this causes flickering
     }
-    showProfileSwitcher() {
-        if (!this.agentMenu) {
-            return;
-        }
-        // Build profile options with current/next indicators
-        const profiles = this.agentMenu.options.map((option, index) => {
-            const badges = [];
-            const nextProfile = this.agentMenu.persistedProfile ?? this.agentMenu.defaultProfile;
-            if (option.name === this.profile) {
-                badges.push('current');
-            }
-            if (option.name === nextProfile && option.name !== this.profile) {
-                badges.push('next');
-            }
-            const badgeText = badges.length > 0 ? ` (${badges.join(', ')})` : '';
-            return {
-                command: `${index + 1}. ${option.label}${badgeText}`,
-                description: `${this.providerLabel(option.defaultProvider)} • ${option.defaultModel}`,
-            };
-        });
-        // Show profile switcher overlay
-        this.uiAdapter.showProfileSwitcher(profiles, this.profileLabel);
-    }
     /**
-     * Ensure stdin is ready for interactive input before showing the prompt.
-     * This recovers from cases where a nested readline/prompt or partial paste
-     * left the stream paused, raw mode disabled, or keypress listeners detached.
+     * Ensure the terminal input is ready for interactive input.
      */
     ensureReadlineReady() {
-        // Clear any stuck bracketed paste state so new input isn't dropped
-        this.bracketedPaste.reset();
-        // Always ensure the pinned chat box is visible when readline is ready
-        this.pinnedChatBox.show();
-        this.pinnedChatBox.forceRender();
-        const inputStream = input;
-        if (!inputStream) {
-            return;
-        }
-        // Resume stdin if another consumer paused it
-        if (typeof inputStream.isPaused === 'function' && inputStream.isPaused()) {
-            inputStream.resume();
-        }
-        else if (inputStream.readableFlowing === false) {
-            inputStream.resume();
-        }
-        // Restore raw mode if a nested readline turned it off
-        if (inputStream.isTTY && typeof inputStream.isRaw === 'boolean') {
-            const ttyStream = inputStream;
-            if (!ttyStream.isRaw) {
-                ttyStream.setRawMode(true);
-            }
-        }
-        // Reattach keypress handler if it was removed
-        if (this.keypressHandler) {
-            const listeners = inputStream.listeners('keypress');
-            const hasHandler = listeners.includes(this.keypressHandler);
-            if (!hasHandler) {
-                if (inputStream.listenerCount('keypress') === 0) {
-                    readline.emitKeypressEvents(inputStream, this.rl);
-                }
-                inputStream.on('keypress', this.keypressHandler);
-            }
-        }
-        // Restore readline output if it was suppressed
-        // Note: Stream handler manages its own state, this is for legacy compatibility
-        if (!this.streamHandler.isStreaming()) {
-            this.restoreReadlineOutput();
-        }
-    }
-    /**
-     * Suppress readline's character echo during streaming.
-     * Characters typed will be captured but not echoed to the main output.
-     * Instead, they appear only in the persistent input box at the bottom.
-     *
-     * @deprecated Use streamHandler.startStreaming() instead - kept for backwards compatibility
-     * @internal Kept for legacy code paths that may still reference this method
-     */
-    // @ts-expect-error - Legacy method kept for backwards compatibility, unused in favor of streamHandler
-    suppressReadlineOutput() {
-        // Delegate to stream handler if it's not already streaming
-        if (this.streamHandler.isStreaming()) {
-            return;
-        }
-        if (this.readlineOutputSuppressed || !output.isTTY) {
-            return;
-        }
-        this.originalStdoutWrite = output.write.bind(output);
-        const self = this;
-        // Replace stdout.write to filter readline echo
-        // Readline writes single characters for echo - we filter those out
-        // but allow multi-character writes (actual output) through
-        output.write = function (chunk, encodingOrCallback, callback) {
-            if (!self.originalStdoutWrite) {
-                return true;
-            }
-            const str = typeof chunk === 'string' ? chunk : chunk.toString();
-            // Filter out readline echo patterns:
-            // - Single printable characters (user typing)
-            // - Cursor movement sequences for single chars
-            // - Backspace sequences
-            // - Prompt redraws
-            // But allow through:
-            // - Multi-character content (actual AI output)
-            // - Newlines and control sequences for formatting
-            // If it's a single printable char, suppress it (user typing)
-            if (str.length === 1 && str.charCodeAt(0) >= 32 && str.charCodeAt(0) < 127) {
-                return true;
-            }
-            // Suppress backspace sequences (readline's delete char)
-            if (str === '\b \b' || str === '\x1b[D \x1b[D' || str === '\b' || str === '\x7f') {
-                return true;
-            }
-            // Suppress cursor movement sequences (readline cursor positioning)
-            if (/^\x1b\[\d*[ABCD]$/.test(str)) {
-                return true;
-            }
-            // Suppress readline prompt redraw patterns (starts with \r or cursor home)
-            if (/^\r/.test(str) && str.length < 20 && /^[\r\x1b\[\dGK> ]+$/.test(str)) {
-                return true;
-            }
-            // Suppress clear line + prompt patterns from readline
-            if (/^\x1b\[\d*[GK]/.test(str) && str.length < 15) {
-                return true;
-            }
-            // Suppress short sequences that look like readline control (not AI content)
-            // AI content is typically longer or contains actual text
-            if (str.length <= 3 && /^[\x1b\[\]\d;GKJ]+$/.test(str)) {
-                return true;
-            }
-            // Allow everything else through (actual AI output)
-            if (typeof encodingOrCallback === 'function') {
-                return self.originalStdoutWrite(chunk, encodingOrCallback);
-            }
-            return self.originalStdoutWrite(chunk, encodingOrCallback, callback);
-        };
-        this.readlineOutputSuppressed = true;
-    }
-    /**
-     * Restore normal readline output after streaming completes.
-     *
-     * @deprecated Use streamHandler.endStreaming() instead
-     */
-    restoreReadlineOutput() {
-        if (!this.readlineOutputSuppressed || !this.originalStdoutWrite) {
-            return;
-        }
-        output.write = this.originalStdoutWrite;
-        this.originalStdoutWrite = null;
-        this.readlineOutputSuppressed = false;
-    }
-    enqueueUserInput(line, flushImmediately = false) {
-        this.bufferedInputLines.push(line);
-        if (flushImmediately) {
-            if (this.bufferedInputTimer) {
-                clearTimeout(this.bufferedInputTimer);
-                this.bufferedInputTimer = null;
-            }
-            void this.flushBufferedInput();
-            return;
-        }
-        if (this.bufferedInputTimer) {
-            clearTimeout(this.bufferedInputTimer);
-        }
-        this.bufferedInputTimer = setTimeout(() => {
-            void this.flushBufferedInput();
-        }, MULTILINE_INPUT_FLUSH_DELAY_MS);
-    }
-    /**
-     * Clear any buffered input lines and pending flush timers.
-     * Prevents partial multi-line pastes from being auto-submitted.
-     */
-    resetBufferedInputLines() {
-        if (this.bufferedInputTimer) {
-            clearTimeout(this.bufferedInputTimer);
-            this.bufferedInputTimer = null;
-        }
-        if (this.bufferedInputLines.length) {
-            this.bufferedInputLines = [];
-        }
-    }
-    /** Track paste preview state to properly clear/update display */
-    lastPastePreviewLineCount = 0;
-    inPasteCapture = false;
-    /**
-     * Show a preview indicator while accumulating multi-line paste.
-     * The line handler has already cleared readline's echoed line, so we just
-     * write our preview in place using carriage return.
-     */
-    showMultiLinePastePreview(lineCount, preview) {
-        // Only update if we're actually accumulating (avoid spam during rapid paste)
-        if (lineCount === 0 && !preview) {
-            return;
-        }
-        // Mark that we're in paste capture mode
-        this.inPasteCapture = true;
-        // Throttle updates - only update if line count changed to avoid flicker
-        if (lineCount === this.lastPastePreviewLineCount) {
-            return;
-        }
-        this.lastPastePreviewLineCount = lineCount;
-        // Clear current line and write preview (the line handler already moved cursor up)
-        output.write('\r\x1b[K');
-        const statusText = preview
-            ? `${theme.ui.muted('📋 Pasting:')} ${theme.ui.muted(preview.slice(0, 50))}${preview.length > 50 ? '...' : ''}`
-            : `${theme.ui.muted(`📋 Pasting ${lineCount} line${lineCount !== 1 ? 's' : ''}...`)}`;
-        output.write(statusText);
-    }
-    /**
-     * Clear the multi-line paste preview
-     */
-    clearMultiLinePastePreview() {
-        if (!this.inPasteCapture) {
-            return;
-        }
-        // Clear current line
-        output.write('\r\x1b[K');
-        // Reset tracking state
-        this.lastPastePreviewLineCount = 0;
-        this.inPasteCapture = false;
-    }
-    /**
-     * Capture any paste (single or multi-line) without immediately submitting it.
-     * - Short pastes (1-2 lines) are displayed inline like normal typed text
-     * - Longer pastes (3+ lines) show as collapsed block chips
-     * Supports multiple pastes - user can paste multiple times before submitting.
-     */
-    async capturePaste(content, lineCount) {
-        this.resetBufferedInputLines();
-        // Short pastes (1-2 lines) display inline like normal text
-        const isShortPaste = lineCount <= 2;
-        if (isShortPaste) {
-            // For short pastes, display inline like normal typed text
-            // No composableMessage storage - just treat as typed input
-            // For 2-line pastes, join with a visual newline indicator
-            const displayContent = lineCount === 1
-                ? content
-                : content.replace(/\n/g, ' ↵ '); // Visual newline indicator for 2-line pastes
-            // Clear any echoed content first
-            output.write('\r\x1b[K');
-            // Get current readline content and append paste
-            const currentLine = this.rl.line || '';
-            const cursorPos = this.rl.cursor || 0;
-            // Insert paste at cursor position
-            const before = currentLine.slice(0, cursorPos);
-            const after = currentLine.slice(cursorPos);
-            const newLine = before + displayContent + after;
-            const newCursor = cursorPos + displayContent.length;
-            // Update readline buffer - write directly without storing in composableMessage
-            // This allows short pastes to flow through as normal typed text
-            this.rl.write(null, { ctrl: true, name: 'u' }); // Clear line
-            this.rl.write(newLine); // Write new content
-            // Update persistent prompt display
-            this.persistentPrompt.updateInput(newLine, newCursor);
-            // NOTE: Don't clear pasteJustCaptured here - the counter-based logic in shouldIgnoreLineEvent()
-            // will decrement for each readline line event and auto-clear when all are processed.
-            // Clearing prematurely causes the remaining readline-echoed lines to pass through.
-            // Re-prompt to show the inline content
-            this.rl.prompt(true);
-            return;
-        }
-        // For longer pastes (3+ lines), store as a composable block
-        // Check size limits first
-        const { ComposableMessageBuilder } = await import('./composableMessage.js');
-        const sizeCheck = ComposableMessageBuilder.checkPasteSize(content);
-        if (!sizeCheck.ok) {
-            // Paste rejected - show error and abort
-            display.showError(sizeCheck.error || 'Paste rejected due to size limits');
-            this.rl.prompt();
-            return;
-        }
-        // Show warning for large (but acceptable) pastes
-        if (sizeCheck.warning) {
-            display.showWarning(`⚠️ ${sizeCheck.warning}`);
-        }
-        const pasteId = this.composableMessage.addPaste(content);
-        if (!pasteId) {
-            // Should not happen since we checked above, but handle defensively
-            display.showError('Failed to store paste block');
-            this.rl.prompt();
-            return;
-        }
-        // Clear remaining echoed lines from terminal
-        output.write('\r\x1b[K');
-        // Build the paste chips to show inline with prompt
-        // Format: [Pasted text #1 +104 lines] [Pasted text #2 +50 lines]
-        const pasteChips = this.composableMessage.formatPasteChips();
-        // Update status bar - minimal hint, no confirmation required
-        this.persistentPrompt.updateStatusBar({
-            message: 'Press Enter to send',
-        });
-        // Set the prompt to show paste chips, then position cursor after them
-        // The user can type additional text after the chips
-        this.persistentPrompt.updateInput(pasteChips + ' ', pasteChips.length + 1);
-        // Update readline's line buffer to include the chips as prefix
-        // This ensures typed text appears after the chips
-        if (this.rl.line !== undefined) {
-            this.rl.line = pasteChips + ' ';
-            this.rl.cursor = pasteChips.length + 1;
-        }
-        // NOTE: Don't clear pasteJustCaptured here - the counter-based logic in shouldIgnoreLineEvent()
-        // will decrement for each readline line event (one per pasted line) and auto-clear when done.
-        // Clearing prematurely causes remaining readline-echoed lines to pass through and get displayed.
-        this.rl.prompt(true); // preserveCursor=true to keep position after chips
-    }
-    /**
-     * Update the status bar to reflect any pending composed message parts
-     */
-    updateComposeStatusSummary() {
-        if (this.composableMessage.hasContent()) {
-            // Chips are shown inline - minimal status hint
-            this.persistentPrompt.updateStatusBar({
-                message: 'Press Enter to send',
-            });
-        }
-        else {
-            this.persistentPrompt.updateStatusBar({ message: undefined });
-        }
-    }
-    /**
-     * Show paste block editor (Ctrl+G)
-     * Allows viewing and editing captured paste blocks before sending
-     *
-     * Features:
-     * - View block content with line numbers
-     * - Edit blocks inline (replace content)
-     * - Remove individual blocks
-     * - Undo/redo paste operations
-     * - Clear all blocks
-     */
-    showPasteBlockEditor() {
-        const state = this.composableMessage.getState();
-        const pasteBlocks = state.parts.filter((p) => p.type === 'paste');
-        if (pasteBlocks.length === 0) {
-            display.showInfo('No pasted content blocks to edit. Paste some content first.');
-            this.rl.prompt();
-            return;
-        }
-        output.write('\n');
-        display.showSystemMessage('📋 Paste Block Editor');
-        output.write('\n');
-        // Display each paste block with preview
-        pasteBlocks.forEach((block, index) => {
-            const lines = block.content.split('\n');
-            const preview = lines.slice(0, 3).map((l) => `  ${l.slice(0, 60)}${l.length > 60 ? '...' : ''}`).join('\n');
-            const moreLines = lines.length > 3 ? `\n  ... +${lines.length - 3} more lines` : '';
-            const editedFlag = block.edited ? theme.warning(' [edited]') : '';
-            output.write(theme.ui.muted(`[${index + 1}] `) + theme.info(`${block.lineCount} lines, ${block.content.length} chars`) + editedFlag + '\n');
-            output.write(theme.secondary(preview + moreLines) + '\n\n');
-        });
-        // Show undo/redo status
-        const canUndo = this.composableMessage.canUndo();
-        const canRedo = this.composableMessage.canRedo();
-        if (canUndo || canRedo) {
-            const undoStatus = canUndo ? theme.success('undo available') : theme.ui.muted('undo unavailable');
-            const redoStatus = canRedo ? theme.success('redo available') : theme.ui.muted('redo unavailable');
-            output.write(theme.ui.muted('History: ') + undoStatus + theme.ui.muted(' │ ') + redoStatus + '\n\n');
-        }
-        output.write(theme.ui.muted('Commands: ') + '\n');
-        output.write(theme.ui.muted('  • Enter number to view full block') + '\n');
-        output.write(theme.ui.muted('  • "edit N" to replace block N content') + '\n');
-        output.write(theme.ui.muted('  • "remove N" to remove block N') + '\n');
-        output.write(theme.ui.muted('  • "undo" / "redo" to undo/redo changes') + '\n');
-        output.write(theme.ui.muted('  • "clear" to remove all blocks') + '\n');
-        output.write(theme.ui.muted('  • Enter to return to prompt') + '\n');
-        output.write('\n');
-        // Set up interaction mode for paste editing
-        this.pendingInteraction = { type: 'paste-edit' };
-        this.rl.prompt();
-    }
-    /**
-     * Handle paste block editor input
-     */
-    async handlePasteEditInput(trimmedInput) {
-        const trimmed = trimmedInput.toLowerCase();
-        const state = this.composableMessage.getState();
-        const pasteBlocks = state.parts.filter((p) => p.type === 'paste');
-        if (!trimmed) {
-            // Exit paste edit mode
-            this.pendingInteraction = null;
-            display.showInfo('Returned to prompt.');
-            this.rl.prompt();
-            return;
-        }
-        // Handle undo command
-        if (trimmed === 'undo') {
-            if (this.composableMessage.undo()) {
-                this.updateComposeStatusSummary();
-                this.refreshPasteChipsDisplay();
-                display.showInfo('Undone.');
-                // Refresh the paste block view
-                this.showPasteBlockEditor();
-            }
-            else {
-                display.showWarning('Nothing to undo.');
-                this.rl.prompt();
-            }
-            return;
-        }
-        // Handle redo command
-        if (trimmed === 'redo') {
-            if (this.composableMessage.redo()) {
-                this.updateComposeStatusSummary();
-                this.refreshPasteChipsDisplay();
-                display.showInfo('Redone.');
-                // Refresh the paste block view
-                this.showPasteBlockEditor();
-            }
-            else {
-                display.showWarning('Nothing to redo.');
-                this.rl.prompt();
-            }
-            return;
-        }
-        if (trimmed === 'clear') {
-            this.composableMessage.clear();
-            this.updateComposeStatusSummary();
-            this.persistentPrompt.updateInput('', 0);
-            this.rl.line = '';
-            this.rl.cursor = 0;
-            this.pendingInteraction = null;
-            display.showInfo('Cleared all paste blocks.');
-            this.rl.prompt();
-            return;
-        }
-        // Handle "edit N" command - start inline editing mode
-        const editMatch = trimmed.match(/^edit\s+(\d+)$/);
-        if (editMatch) {
-            const blockNum = parseInt(editMatch[1], 10);
-            if (blockNum >= 1 && blockNum <= pasteBlocks.length) {
-                const block = pasteBlocks[blockNum - 1];
-                if (block) {
-                    // Enter edit mode for this block
-                    this.pendingInteraction = { type: 'paste-edit-block', blockId: block.id, blockNum };
-                    output.write('\n');
-                    display.showSystemMessage(`Editing Block ${blockNum}:`);
-                    output.write(theme.ui.muted('Paste or type new content. Press Enter twice to finish, or "cancel" to abort.\n'));
-                    output.write('\n');
-                    // Show current content as reference
-                    const preview = block.content.split('\n').slice(0, 5).map((l) => theme.ui.muted(`  ${l.slice(0, 60)}`)).join('\n');
-                    output.write(theme.ui.muted('Current content (first 5 lines):\n') + preview + '\n\n');
-                }
-            }
-            else {
-                display.showWarning(`Invalid block number. Use 1-${pasteBlocks.length}.`);
-            }
-            this.rl.prompt();
-            return;
-        }
-        // Handle "remove N" command
-        const removeMatch = trimmed.match(/^remove\s+(\d+)$/);
-        if (removeMatch) {
-            const blockNum = parseInt(removeMatch[1], 10);
-            if (blockNum >= 1 && blockNum <= pasteBlocks.length) {
-                const block = pasteBlocks[blockNum - 1];
-                if (block) {
-                    this.composableMessage.removePart(block.id);
-                    this.updateComposeStatusSummary();
-                    this.refreshPasteChipsDisplay();
-                    display.showInfo(`Removed block ${blockNum}.`);
-                    // Check if any blocks remain
-                    const remaining = this.composableMessage.getState().parts.filter(p => p.type === 'paste');
-                    if (remaining.length === 0) {
-                        this.pendingInteraction = null;
-                        display.showInfo('No more paste blocks.');
-                    }
-                }
-            }
-            else {
-                display.showWarning(`Invalid block number. Use 1-${pasteBlocks.length}.`);
-            }
-            this.rl.prompt();
-            return;
-        }
-        // Handle viewing a block by number
-        const blockNum = parseInt(trimmed, 10);
-        if (!Number.isNaN(blockNum) && blockNum >= 1 && blockNum <= pasteBlocks.length) {
-            const block = pasteBlocks[blockNum - 1];
-            if (block) {
-                output.write('\n');
-                display.showSystemMessage(`Block ${blockNum} Content:`);
-                output.write('\n');
-                // Show full content with line numbers
-                const lines = block.content.split('\n');
-                lines.forEach((line, i) => {
-                    const lineNum = theme.ui.muted(`${String(i + 1).padStart(4)} │ `);
-                    output.write(lineNum + line + '\n');
-                });
-                output.write('\n');
-            }
-            this.rl.prompt();
-            return;
-        }
-        display.showWarning('Enter a block number, "edit N", "remove N", "undo", "redo", "clear", or press Enter to return.');
-        this.rl.prompt();
-    }
-    /**
-     * Handle paste block inline editing mode
-     */
-    editBlockBuffer = [];
-    async handlePasteBlockEditInput(input, blockId, blockNum) {
-        // Check for cancel
-        if (input.toLowerCase() === 'cancel') {
-            this.editBlockBuffer = [];
-            this.pendingInteraction = { type: 'paste-edit' };
-            display.showInfo('Edit cancelled.');
-            this.showPasteBlockEditor();
-            return;
-        }
-        // Empty line - check if this is end of edit (double Enter)
-        if (!input.trim()) {
-            if (this.editBlockBuffer.length > 0) {
-                // Complete the edit
-                const newContent = this.editBlockBuffer.join('\n');
-                this.composableMessage.editPaste(blockId, newContent);
-                this.editBlockBuffer = [];
-                this.updateComposeStatusSummary();
-                this.refreshPasteChipsDisplay();
-                display.showInfo(`Block ${blockNum} updated (${newContent.split('\n').length} lines).`);
-                this.pendingInteraction = { type: 'paste-edit' };
-                this.showPasteBlockEditor();
-                return;
-            }
-            // First empty line with no buffer - just prompt again
-            this.rl.prompt();
-            return;
-        }
-        // Add line to edit buffer
-        this.editBlockBuffer.push(input);
-        this.rl.prompt();
-    }
-    /**
-     * Refresh paste chips display in prompt
-     */
-    refreshPasteChipsDisplay() {
-        const chips = this.composableMessage.formatPasteChips();
-        this.persistentPrompt.updateInput(chips ? chips + ' ' : '', chips ? chips.length + 1 : 0);
-        this.rl.line = chips ? chips + ' ' : '';
-        this.rl.cursor = chips ? chips.length + 1 : 0;
-    }
-    /**
-     * Cycle paste preview mode (Shift+Tab)
-     * Cycles through: collapsed → summary → expanded
-     */
-    pastePreviewMode = 'collapsed';
-    cyclePastePreview() {
-        const state = this.composableMessage.getState();
-        const pasteBlocks = state.parts.filter((p) => p.type === 'paste');
-        if (pasteBlocks.length === 0) {
-            return;
-        }
-        // Cycle through modes
-        const modes = ['collapsed', 'summary', 'expanded'];
-        const currentIndex = modes.indexOf(this.pastePreviewMode);
-        this.pastePreviewMode = modes[(currentIndex + 1) % modes.length];
-        output.write('\n');
-        switch (this.pastePreviewMode) {
-            case 'collapsed':
-                // Show just chips
-                display.showSystemMessage(`📋 Preview: Collapsed (${pasteBlocks.length} block${pasteBlocks.length > 1 ? 's' : ''})`);
-                output.write(theme.ui.muted(this.composableMessage.formatPasteChips()) + '\n');
-                break;
-            case 'summary':
-                // Show blocks with first line preview
-                display.showSystemMessage('📋 Preview: Summary');
-                pasteBlocks.forEach((block, i) => {
-                    const preview = block.summary.length > 60 ? block.summary.slice(0, 57) + '...' : block.summary;
-                    output.write(theme.ui.muted(`[${i + 1}] `) + theme.info(`${block.lineCount}L`) + theme.ui.muted(` ${preview}`) + '\n');
-                });
-                break;
-            case 'expanded':
-                // Show full content (up to 10 lines each)
-                display.showSystemMessage('📋 Preview: Expanded');
-                pasteBlocks.forEach((block, i) => {
-                    output.write(theme.ui.muted(`[${i + 1}] `) + theme.info(`${block.lineCount} lines, ${block.content.length} chars`) + '\n');
-                    const lines = block.content.split('\n').slice(0, 10);
-                    lines.forEach((line, j) => {
-                        const lineNum = theme.ui.muted(`${String(j + 1).padStart(3)} │ `);
-                        output.write(lineNum + line.slice(0, 80) + (line.length > 80 ? '...' : '') + '\n');
-                    });
-                    if (block.lineCount > 10) {
-                        output.write(theme.ui.muted(`    ... +${block.lineCount - 10} more lines\n`));
-                    }
-                    output.write('\n');
-                });
-                break;
-        }
-        output.write(theme.ui.muted('(Shift+Tab to cycle preview modes)') + '\n\n');
-        this.rl.prompt(true);
-    }
-    async flushBufferedInput() {
-        if (!this.bufferedInputLines.length) {
-            this.bufferedInputTimer = null;
-            return;
-        }
-        const lineCount = this.bufferedInputLines.length;
-        const combined = this.bufferedInputLines.join('\n');
-        this.bufferedInputLines = [];
-        this.bufferedInputTimer = null;
-        try {
-            await this.processInputBlock(combined, lineCount > 1);
-        }
-        catch (error) {
-            // Pass full error object for enhanced formatting
-            display.showError(error instanceof Error ? error.message : String(error), error);
-            this.rl.prompt();
-        }
+        this.terminalInput.render();
     }
     refreshQueueIndicators() {
-        const queued = this.followUpQueue.length;
-        // Build status message based on processing state and queue
-        let message;
-        if (this.isProcessing) {
-            const queuePart = queued > 0 ? `${queued} queued · ` : '';
-            // Show helpful hints: Esc to cancel, type to queue
-            message = `⏳ Processing... ${queuePart}[Esc: cancel · Enter: queue follow-up]`;
-        }
-        else if (queued > 0) {
-            message = `${queued} follow-up${queued === 1 ? '' : 's'} queued · [Esc: clear queue]`;
-        }
-        this.persistentPrompt.updateStatusBar({ message });
         if (this.isProcessing) {
             this.setProcessingStatus();
         }
         else {
             this.setIdleStatus();
         }
+        this.terminalInput.render();
     }
     enqueueFollowUpAction(action) {
         this.followUpQueue.push(action);
@@ -1495,23 +546,17 @@ export class InteractiveShell {
         const preview = normalized.length > previewLimit ? `${normalized.slice(0, previewLimit - 3)}...` : normalized;
         const position = this.followUpQueue.length === 1 ? 'to run next' : `#${this.followUpQueue.length} in queue`;
         const label = action.type === 'continuous' ? 'continuous command' : 'follow-up';
-        const queueCount = this.followUpQueue.length;
         // Show immediate acknowledgment with checkmark
-        const queueLabel = queueCount === 1 ? '1 queued' : `${queueCount} queued`;
         if (preview) {
             display.showInfo(`✓ ${theme.info(label)} ${position}: ${theme.ui.muted(preview)}`);
         }
         else {
             display.showInfo(`✓ ${theme.info(label)} queued ${position}.`);
         }
-        // Update status bar to show queue count
-        this.persistentPrompt.updateStatusBar({
-            message: `⏳ Processing... (${queueLabel})`
-        });
         this.refreshQueueIndicators();
         this.scheduleQueueProcessing();
         // Re-show the prompt so user can continue typing more follow-ups
-        this.rl.prompt();
+        this.terminalInput.render();
     }
     scheduleQueueProcessing() {
         if (!this.followUpQueue.length) {
@@ -1523,71 +568,8 @@ export class InteractiveShell {
         });
     }
     /**
-     * Process any inputs that were queued during streaming.
-     * Claude Code style: User can type while streaming, input is stored in queue,
-     * processed after streaming ends.
-     *
-     * @deprecated Use processUnifiedChatBoxQueue() instead
-     */
-    // @ts-expect-error - Legacy method kept for backwards compatibility
-    processQueuedInputs() {
-        if (!this.streamHandler.hasQueuedInput()) {
-            return;
-        }
-        // Transfer queued inputs from stream handler to follow-up queue
-        while (this.streamHandler.hasQueuedInput()) {
-            const input = this.streamHandler.getNextQueuedInput();
-            if (!input) {
-                break;
-            }
-            // Handle interrupts specially
-            if (input.type === 'interrupt') {
-                // Interrupt was already processed during capture
-                continue;
-            }
-            // Add to follow-up queue for processing
-            const actionType = input.type === 'command' ? 'request' : 'request';
-            this.followUpQueue.push({
-                type: actionType,
-                text: input.text,
-            });
-        }
-        // Show queue summary if there are items
-        const summary = this.streamHandler.getQueueSummary();
-        if (summary) {
-            display.showInfo(`📝 ${summary}`);
-        }
-    }
-    /**
-     * Process any inputs that were queued in UnifiedChatBox during streaming.
-     * Claude Code style: User can type while streaming, input is stored invisibly,
-     * processed after streaming ends.
+     * Process queued follow-up actions.
      */
-    processUnifiedChatBoxQueue() {
-        if (!this.unifiedChatBox.hasQueuedInput()) {
-            return;
-        }
-        // Transfer queued inputs from unified chat box to follow-up queue
-        while (this.unifiedChatBox.hasQueuedInput()) {
-            const input = this.unifiedChatBox.dequeue();
-            if (!input) {
-                break;
-            }
-            // Handle interrupts specially - they cancel current operation
-            if (input.type === 'interrupt') {
-                // Request cancellation if agent is running
-                if (this.agent) {
-                    this.agent.requestCancellation();
-                }
-                continue;
-            }
-            // Add to follow-up queue for processing
-            this.followUpQueue.push({
-                type: 'request',
-                text: input.text,
-            });
-        }
-    }
     async processQueuedActions() {
         if (this.isDrainingQueue || this.isProcessing || !this.followUpQueue.length) {
             return;
@@ -1621,85 +603,22 @@ export class InteractiveShell {
         if (await this.handlePendingInteraction(trimmed)) {
             return;
         }
-        // If we have captured multi-line paste blocks, respect control commands before assembling
-        if (this.composableMessage.hasContent()) {
-            // Strip paste chip prefixes from input since actual content is in composableMessage
-            // Chips look like: [Pasted text #1 +X lines] [Pasted text #2 +Y lines]
-            const chipsPrefix = this.composableMessage.formatPasteChips();
-            let userText = trimmed;
-            if (chipsPrefix && trimmed.startsWith(chipsPrefix)) {
-                userText = trimmed.slice(chipsPrefix.length).trim();
-            }
-            const lower = userText.toLowerCase();
-            // Control commands that should NOT consume the captured paste
-            if (lower === '/cancel' || lower === 'cancel') {
-                this.composableMessage.clear();
-                this.updateComposeStatusSummary();
-                this.persistentPrompt.updateInput('', 0);
-                display.showInfo('Discarded captured paste.');
-                this.rl.prompt();
-                return;
-            }
-            if (lower === 'exit' || lower === 'quit') {
-                this.rl.close();
-                return;
-            }
-            if (lower === 'clear') {
-                display.clear();
-                this.rl.prompt();
-                return;
-            }
-            if (lower === 'help') {
-                this.showHelp();
-                this.rl.prompt();
-                return;
-            }
-            // Slash commands operate independently of captured paste
-            if (userText.startsWith('/')) {
-                await this.processSlashCommand(userText);
-                this.updateComposeStatusSummary();
-                return;
-            }
-            // If userText is empty OR it's additional content, assemble and send
-            // Empty enter sends the captured paste; non-empty content is appended first
-            if (userText) {
-                this.composableMessage.setDraft(userText);
-                this.composableMessage.commitDraft();
-            }
-            const assembled = this.composableMessage.assemble();
-            this.composableMessage.clear();
-            this.updateComposeStatusSummary();
-            this.persistentPrompt.updateInput('', 0);
-            if (!assembled) {
-                this.rl.prompt();
-                return;
-            }
-            // Check if assembled content is a continuous command
-            if (this.isContinuousCommand(assembled)) {
-                await this.processContinuousRequest(assembled);
-                this.rl.prompt();
-                return;
-            }
-            await this.processRequest(assembled);
-            this.rl.prompt();
-            return;
-        }
         if (!trimmed) {
-            this.rl.prompt();
             return;
         }
-        if (trimmed.toLowerCase() === 'exit' || trimmed.toLowerCase() === 'quit') {
-            this.rl.close();
+        const lower = trimmed.toLowerCase();
+        if (lower === 'exit' || lower === 'quit') {
+            this.shutdown();
             return;
         }
-        if (trimmed.toLowerCase() === 'clear') {
+        if (lower === 'clear') {
             display.clear();
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
-        if (trimmed.toLowerCase() === 'help') {
+        if (lower === 'help') {
             this.showHelp();
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         if (trimmed.startsWith('/')) {
@@ -1709,12 +628,12 @@ export class InteractiveShell {
         // Check for continuous/infinite loop commands
         if (this.isContinuousCommand(trimmed)) {
             await this.processContinuousRequest(trimmed);
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         // Direct execution for all inputs, including multi-line pastes
         await this.processRequest(trimmed);
-        this.rl.prompt();
+        this.terminalInput.render();
     }
     /**
      * Check if the command is a continuous/infinite loop command
@@ -1766,12 +685,6 @@ export class InteractiveShell {
             case 'agent-selection':
                 await this.handleAgentSelectionInput(input);
                 return true;
-            case 'paste-edit':
-                await this.handlePasteEditInput(input);
-                return true;
-            case 'paste-edit-block':
-                await this.handlePasteBlockEditInput(input, this.pendingInteraction.blockId, this.pendingInteraction.blockNum);
-                return true;
             default:
                 return false;
         }
@@ -1780,7 +693,7 @@ export class InteractiveShell {
         const [command] = input.split(/\s+/);
         if (!command) {
             display.showWarning('Enter a slash command.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         switch (command) {
@@ -1855,7 +768,7 @@ export class InteractiveShell {
                 }
                 break;
         }
-        this.rl.prompt();
+        this.terminalInput.render();
     }
     async tryCustomSlashCommand(command, fullInput) {
         const custom = this.customCommandMap.get(command);
@@ -1889,100 +802,6 @@ export class InteractiveShell {
         ];
         display.showSystemMessage(info.join('\n'));
     }
-    /**
-     * Handle Tab key for slash command autocompletion
-     * Completes partial slash commands like /mo -> /model
-     */
-    handleTabCompletion() {
-        const currentLine = this.rl.line || '';
-        const cursorPos = this.rl.cursor || 0;
-        // Only complete if line starts with /
-        if (!currentLine.startsWith('/')) {
-            return;
-        }
-        // Get the partial command (from / to cursor)
-        const partial = currentLine.slice(0, cursorPos).toLowerCase();
-        // Available slash commands
-        const commands = [
-            '/help',
-            '/model',
-            '/secrets',
-            '/tools',
-            '/doctor',
-            '/clear',
-            '/cancel',
-            '/compact',
-            '/cost',
-            '/status',
-            '/undo',
-            '/redo',
-        ];
-        // Find matching commands
-        const matches = commands.filter(cmd => cmd.startsWith(partial));
-        if (matches.length === 0) {
-            // No matches - beep or do nothing
-            return;
-        }
-        if (matches.length === 1) {
-            // Single match - complete it
-            const completion = matches[0];
-            const suffix = currentLine.slice(cursorPos);
-            const newLine = completion + suffix;
-            const newCursor = completion.length;
-            // Update readline
-            this.rl.line = newLine;
-            this.rl.cursor = newCursor;
-            // Redraw
-            output.write('\r\x1b[K'); // Clear line
-            output.write(formatUserPrompt(this.profileLabel || this.profile));
-            output.write(newLine);
-            // Position cursor
-            if (suffix.length > 0) {
-                output.write(`\x1b[${suffix.length}D`);
-            }
-            // Sync to display components
-            this.persistentPrompt.updateInput(newLine, newCursor);
-            this.pinnedChatBox.setInput(newLine, newCursor);
-        }
-        else {
-            // Multiple matches - show them
-            output.write('\n');
-            output.write(theme.ui.muted('Completions: ') + matches.join('  ') + '\n');
-            this.rl.prompt();
-            // Find common prefix for partial completion
-            const commonPrefix = this.findCommonPrefix(matches);
-            if (commonPrefix.length > partial.length) {
-                const suffix = currentLine.slice(cursorPos);
-                const newLine = commonPrefix + suffix;
-                const newCursor = commonPrefix.length;
-                this.rl.line = newLine;
-                this.rl.cursor = newCursor;
-                this.persistentPrompt.updateInput(newLine, newCursor);
-                this.pinnedChatBox.setInput(newLine, newCursor);
-            }
-        }
-    }
-    /**
-     * Find the longest common prefix among strings
-     */
-    findCommonPrefix(strings) {
-        if (strings.length === 0)
-            return '';
-        if (strings.length === 1)
-            return strings[0];
-        let prefix = strings[0];
-        for (let i = 1; i < strings.length; i++) {
-            const str = strings[i];
-            let j = 0;
-            while (j < prefix.length && j < str.length && prefix[j] === str[j]) {
-                j++;
-            }
-            prefix = prefix.slice(0, j);
-            if (prefix.length === 0)
-                break;
-        }
-        return prefix;
-    }
     runDoctor() {
         const lines = [];
         lines.push(theme.bold('Environment diagnostics'));
@@ -2876,29 +1695,29 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number or type cancel.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Model selection cancelled.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
             display.showWarning('Please enter a valid number.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const option = pending.options[choice - 1];
         if (!option) {
             display.showWarning('That option is not available.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         this.showProviderModels(option);
-        this.rl.prompt();
+        this.terminalInput.render();
     }
     async handleModelSelection(input) {
         const pending = this.pendingInteraction;
@@ -2908,35 +1727,35 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number, type "back", or type "cancel".');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         if (trimmed.toLowerCase() === 'back') {
             this.showModelMenu();
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Model selection cancelled.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
             display.showWarning('Please enter a valid number.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const preset = pending.options[choice - 1];
         if (!preset) {
             display.showWarning('That option is not available.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         this.pendingInteraction = null;
         await this.applyModelPreset(preset);
-        this.rl.prompt();
+        this.terminalInput.render();
     }
     async applyModelPreset(preset) {
         try {
@@ -2969,30 +1788,30 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number or type cancel.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Secret management cancelled.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
             display.showWarning('Please enter a valid number.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         const secret = pending.options[choice - 1];
         if (!secret) {
             display.showWarning('That option is not available.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         display.showSystemMessage(`Enter a new value for ${secret.label} or type "cancel".`);
         this.pendingInteraction = { type: 'secret-input', secret };
-        this.rl.prompt();
+        this.terminalInput.render();
     }
     async handleSecretInput(input) {
         const pending = this.pendingInteraction;
@@ -3002,14 +1821,14 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a value or type cancel.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             this.pendingSecretRetry = null;
             display.showInfo('Secret unchanged.');
-            this.rl.prompt();
+            this.terminalInput.render();
             return;
         }
         try {
@@ -3033,7 +1852,7 @@ export class InteractiveShell {
             this.pendingInteraction = null;
             this.pendingSecretRetry = null;
         }
-        this.rl.prompt();
+        this.terminalInput.render();
     }
     async processRequest(request) {
         if (this.isProcessing) {
@@ -3049,11 +1868,8 @@ export class InteractiveShell {
             return;
         }
         this.isProcessing = true;
+        this.terminalInput.setStreaming(true);
         const requestStartTime = Date.now(); // Alpha Zero 2 timing
-        // Claude Code style: Enable scroll region for fixed chat box at bottom
-        this.pinnedChatBox.setProcessing(true);
-        // Claude Code style: Update status (optional, won't interfere with streaming)
-        this.persistentPrompt.updateStatusBar({ message: '⏳ Processing...' });
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
         try {
@@ -3062,13 +1878,6 @@ export class InteractiveShell {
             // Claude Code style: Show unified streaming header before response
             // This provides visual consistency with the startup Ready bar
             display.showStreamingHeader();
-            // NOTE: Do NOT call showWaitingPrompt() here - the PinnedChatBox scroll region
-            // handles rendering the prompt at the bottom via renderPersistentInput().
-            // Calling showWaitingPrompt() writes to the scroll area instead of the reserved bottom.
-            // Claude Code style: Start streaming mode using UnifiedChatBox
-            // - User input is captured and queued
-            // - After response ends, new prompt appears at bottom
-            this.unifiedChatBox.startStreaming();
             // DISABLED streaming - wait for full response instead
             // This keeps cursor at the > prompt during processing
             await agent.send(request, false);
@@ -3087,30 +1896,20 @@ export class InteractiveShell {
             }
         }
         finally {
-            // Claude Code style: End streaming mode using UnifiedChatBox
-            // This restores readline echo and returns queue info
-            const streamResult = this.unifiedChatBox.endStreaming();
-            // Process any queued inputs that came in during streaming
-            this.processUnifiedChatBoxQueue();
-            // Show queue indicator if there were queued inputs
-            if (streamResult.queuedCount > 0) {
-                this.unifiedChatBox.showQueueIndicator();
-            }
             display.stopThinking(false);
             this.isProcessing = false;
-            this.pinnedChatBox.setProcessing(false); // Disable scroll region
+            this.terminalInput.setStreaming(false);
             this.uiAdapter.endProcessing('Ready for prompts');
             this.setIdleStatus();
             display.newLine();
-            // Clear the processing status
-            this.persistentPrompt.updateStatusBar({ message: undefined });
+            this.updateStatusMessage(null);
             // Claude Code style: Show unified status bar before prompt
             // This creates consistent UI between startup and post-streaming
             this.showUnifiedStatusBar();
             // CRITICAL: Ensure readline prompt is active for user input
             // Claude Code style: New prompt naturally appears at bottom
             this.ensureReadlineReady();
-            this.rl.prompt();
+            this.terminalInput.render();
             this.scheduleQueueProcessing();
             this.refreshQueueIndicators();
         }
@@ -3142,26 +1941,17 @@ export class InteractiveShell {
             return;
         }
         this.isProcessing = true;
+        this.terminalInput.setStreaming(true);
         const overallStartTime = Date.now();
-        // Claude Code style: Enable scroll region for fixed chat box at bottom
-        this.pinnedChatBox.setProcessing(true);
         // Initialize the task completion detector
         const completionDetector = getTaskCompletionDetector();
         completionDetector.reset();
-        // Claude Code style: Update status
-        this.persistentPrompt.updateStatusBar({ message: '🔄 Continuous mode...' });
         display.showSystemMessage(`🔄 Starting continuous execution mode. Press Ctrl+C to stop.`);
         display.showSystemMessage(`📊 Using intelligent task completion detection with AI verification.`);
         this.uiAdapter.startProcessing('Continuous execution mode');
         this.setProcessingStatus();
         // Claude Code style: Show unified streaming header before response
         display.showStreamingHeader();
-        // NOTE: Do NOT call showWaitingPrompt() here - the PinnedChatBox scroll region
-        // handles rendering the prompt at the bottom via renderPersistentInput().
-        // Calling showWaitingPrompt() writes to the scroll area instead of the reserved bottom.
-        // Claude Code style: Start streaming mode using UnifiedChatBox
-        // - User input is captured and queued
-        this.unifiedChatBox.startStreaming();
         let iteration = 0;
         let lastResponse = '';
         let consecutiveNoProgress = 0;
@@ -3187,9 +1977,7 @@ When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
             while (iteration < MAX_ITERATIONS) {
                 iteration++;
                 display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
-                // Update pinned chat box with iteration status instead of spinner
-                this.pinnedChatBox.setStatusMessage(`Working on iteration ${iteration}...`);
-                this.pinnedChatBox.forceRender();
+                this.updateStatusMessage(`Working on iteration ${iteration}...`);
                 try {
                     // Send the request and capture the response (streaming disabled)
                     const response = await agent.send(currentPrompt, false);
@@ -3323,28 +2111,18 @@ What's the next action?`;
             display.showSystemMessage(`\n🏁 Continuous execution completed: ${iteration} iterations, ${minutes}m ${seconds}s total`);
             // Reset completion detector for next task
             resetTaskCompletionDetector();
-            // Claude Code style: End streaming mode using UnifiedChatBox
-            const streamResult = this.unifiedChatBox.endStreaming();
-            // Process any queued inputs that came in during streaming
-            this.processUnifiedChatBoxQueue();
-            // Show queue indicator if there were queued inputs
-            if (streamResult.queuedCount > 0) {
-                this.unifiedChatBox.showQueueIndicator();
-            }
             this.isProcessing = false;
-            this.pinnedChatBox.setProcessing(false); // Disable scroll region
+            this.terminalInput.setStreaming(false);
+            this.updateStatusMessage(null);
             this.uiAdapter.endProcessing('Ready for prompts');
             this.setIdleStatus();
             display.newLine();
-            // Clear the processing status
-            this.persistentPrompt.updateStatusBar({ message: undefined });
             // Claude Code style: Show unified status bar before prompt
             // This creates consistent UI between startup and post-streaming
             this.showUnifiedStatusBar();
             // CRITICAL: Ensure readline prompt is active for user input
             // Claude Code style: New prompt naturally appears at bottom
             this.ensureReadlineReady();
-            this.rl.prompt();
             this.scheduleQueueProcessing();
             this.refreshQueueIndicators();
         }
@@ -3552,8 +2330,7 @@ What's the next action?`;
         this.autoTestInFlight = true;
         const command = 'npm test -- --runInBand';
         display.showSystemMessage(`🧪 Auto-testing recent changes (${trigger}) with "${command}"...`);
-        this.pinnedChatBox.setStatusMessage('Running tests automatically...');
-        this.pinnedChatBox.forceRender();
+        this.updateStatusMessage('Running tests automatically...');
         try {
             const { stdout, stderr } = await execAsync(command, {
                 cwd: this.workingDir,
@@ -3581,8 +2358,7 @@ What's the next action?`;
             });
         }
         finally {
-            this.pinnedChatBox.setStatusMessage(null);
-            this.pinnedChatBox.forceRender();
+            this.updateStatusMessage(null);
             this.autoTestInFlight = false;
         }
     }
@@ -3653,7 +2429,7 @@ What's the next action?`;
                             display.showNarrative(content.trim());
                         }
                         // The isProcessing flag already shows "⏳ Processing..." - no need for duplicate status
-                        this.pinnedChatBox.forceRender();
+                        this.terminalInput.render();
                         return;
                     }
                     const cleanup = this.handleContextTelemetry(metadata, enriched);
@@ -3672,10 +2448,6 @@ What's the next action?`;
                 onContextRecovery: (attempt, maxAttempts, message) => {
                     // Show recovery progress in UI
                     display.showSystemMessage(`⚡ Context Recovery (${attempt}/${maxAttempts}): ${message}`);
-                    // Update persistent prompt to show recovery status
-                    this.persistentPrompt.updateStatusBar({
-                        contextUsage: 100, // Show as full during recovery
-                    });
                 },
                 onContextPruned: (removedCount, stats) => {
                     // Clear squish overlay if active
@@ -3689,30 +2461,28 @@ What's the next action?`;
                     // Update context usage in UI
                     if (typeof percentage === 'number') {
                         this.uiAdapter.updateContextUsage(percentage);
-                        this.persistentPrompt.updateStatusBar({ contextUsage: percentage });
                     }
                     // Ensure prompt remains visible at bottom after context messages
-                    this.pinnedChatBox.forceRender();
+                    this.terminalInput.render();
                 },
                 onContinueAfterRecovery: () => {
                     // Update UI to show we're continuing after context recovery
                     display.showSystemMessage(`🔄 Continuing after context recovery...`);
-                    // Update pinned chat box status instead of spinner
-                    this.pinnedChatBox.setStatusMessage('Retrying with reduced context...');
-                    this.pinnedChatBox.forceRender();
+                    this.updateStatusMessage('Retrying with reduced context...');
+                    this.terminalInput.render();
                 },
                 onAutoContinue: (attempt, maxAttempts, _message) => {
                     // Show auto-continue progress in UI
                     display.showSystemMessage(`🔄 Auto-continue (${attempt}/${maxAttempts}): Model expressed intent, prompting to act...`);
-                    this.pinnedChatBox.setStatusMessage('Auto-continuing...');
-                    this.pinnedChatBox.forceRender();
+                    this.updateStatusMessage('Auto-continuing...');
+                    this.terminalInput.render();
                 },
                 onCancelled: () => {
                     // Update UI to show operation was cancelled
                     display.showWarning('Operation cancelled.');
-                    this.pinnedChatBox.setStatusMessage(null);
-                    this.pinnedChatBox.setProcessing(false);
-                    this.pinnedChatBox.forceRender();
+                    this.updateStatusMessage(null);
+                    this.terminalInput.setStreaming(false);
+                    this.terminalInput.render();
                 },
                 onVerificationNeeded: () => {
                     void this.enforceAutoTests('verification');
@@ -3746,10 +2516,9 @@ What's the next action?`;
      * just like on fresh startup.
      */
     resetChatBoxAfterModelSwap() {
-        this.pinnedChatBox.setStatusMessage(null);
-        this.pinnedChatBox.setProcessing(false);
-        this.pinnedChatBox.show();
-        this.pinnedChatBox.forceRender();
+        this.updateStatusMessage(null);
+        this.terminalInput.setStreaming(false);
+        this.terminalInput.render();
         this.ensureReadlineReady();
     }
     buildSystemPrompt() {
@@ -3816,10 +2585,6 @@ What's the next action?`;
         // Always update context usage in the UI
         const percentUsed = Math.round(usageRatio * 100);
         this.uiAdapter.updateContextUsage(percentUsed);
-        // Update persistent prompt status bar with context usage
-        this.persistentPrompt.updateStatusBar({ contextUsage: percentUsed });
-        // Update pinned chat box with context usage
-        this.pinnedChatBox.setContextUsage(percentUsed);
         if (usageRatio < CONTEXT_USAGE_THRESHOLD) {
             return null;
         }
@@ -3867,8 +2632,6 @@ What's the next action?`;
             const percentUsed = Math.round((totalTokens / windowTokens) * 100);
             // Update context usage in unified UI
             this.uiAdapter.updateContextUsage(percentUsed);
-            // Update persistent prompt status bar with context usage
-            this.persistentPrompt.updateStatusBar({ contextUsage: percentUsed });
             display.showSystemMessage([
                 `Context usage: ${totalTokens.toLocaleString('en-US')} of ${windowTokens.toLocaleString('en-US')} tokens`,
                 `(${percentUsed}% full). Running automatic cleanup...`,
@@ -4105,14 +2868,6 @@ What's the next action?`;
         const entry = this.agentMenu.options.find((option) => option.name === name);
         return entry?.label ?? name;
     }
-    updatePersistentPromptFileChanges() {
-        const summary = this._fileChangeTracker.getSummary();
-        if (summary.files === 0) {
-            return;
-        }
-        const fileChangesText = `${summary.files} file${summary.files === 1 ? '' : 's'} +${summary.additions} -${summary.removals}`;
-        this.persistentPrompt.updateStatusBar({ fileChanges: fileChangesText });
-    }
     extractThoughtSummary(thought) {
         // Extract first non-empty line
         const lines = thought?.split('\n').filter(line => line.trim()) ?? [];
@@ -4402,32 +3157,6 @@ What's the next action?`;
         ];
         display.showSystemMessage(lines.join('\n'));
     }
-    enableBracketedPasteMode() {
-        if (!input.isTTY || !output.isTTY) {
-            return false;
-        }
-        try {
-            output.write(BRACKETED_PASTE_ENABLE);
-            return true;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            display.showWarning(`Unable to enable bracketed paste: ${message}`);
-            return false;
-        }
-    }
-    disableBracketedPasteMode() {
-        if (!this.bracketedPasteEnabled || !output.isTTY) {
-            return;
-        }
-        try {
-            output.write(BRACKETED_PASTE_DISABLE);
-        }
-        finally {
-            this.bracketedPasteEnabled = false;
-            this.bracketedPaste.reset();
-        }
-    }
     /**
      * Set the cached provider status for unified status bar display.
      * Called once at startup after checking providers.
@@ -4435,10 +3164,6 @@ What's the next action?`;
     setProviderStatus(providers) {
         this.cachedProviderStatus = providers;
     }
-    // NOTE: showWaitingPrompt() was removed because the PinnedChatBox scroll region
-    // now handles rendering the prompt at the bottom via renderPersistentInput().
-    // The scroll region approach keeps the cursor in the correct location during
-    // streaming while allowing the user to type in the reserved bottom area.
     /**
      * Show the unified status bar (Claude Code style).
      * Displays provider indicators and ready hints before the prompt.