erosolar-cli 1.7.155 → 1.7.157

package/dist/shell/interactiveShell.js

@@ -84,7 +84,6 @@ export class InteractiveShell {
     cleanupInProgress = false;
     slashPreviewVisible = false;
     keypressHandler = null;
-    sigintHandler = null;
     rawDataHandler = null;
     skillRepository;
     skillToolHandlers = new Map();
@@ -114,6 +113,7 @@ export class InteractiveShell {
     _enabledPlugins;
     pinnedChatBox;
     readlineOutputSuppressed = false;
+    originalStdoutWrite = null;
     constructor(config) {
         this.profile = config.profile;
         this.profileLabel = config.profileLabel;
@@ -416,30 +416,6 @@ export class InteractiveShell {
         display.showInfo(`${this.agentMenuLabel(profileName)} will load the next time you start the CLI. Restart to switch now.`);
     }
     setupHandlers() {
-        // Set up SIGINT handler to clear input instead of exiting when there's content
-        // This is a backup in case the keypress handler doesn't catch Ctrl+C
-        this.sigintHandler = () => {
-            const currentLine = this.rl.line || '';
-            const hasComposedContent = this.composableMessage.hasContent();
-            const hasAnyContent = currentLine.length > 0 || hasComposedContent;
-            if (hasAnyContent) {
-                // Clear all input buffers instead of exiting
-                this.rl.line = '';
-                this.rl.cursor = 0;
-                this.composableMessage.clear();
-                this.bracketedPaste.reset();
-                this.persistentPrompt.updateInput('', 0);
-                this.pinnedChatBox.setInput('');
-                this.pinnedChatBox.clearPastedBlockState();
-                output.write('\r\x1b[K^C\n');
-                this.rl.prompt();
-                return;
-            }
-            // No content - allow exit
-            output.write('\n👋 Goodbye!\n');
-            process.exit(0);
-        };
-        process.on('SIGINT', this.sigintHandler);
         // Set up raw data interception for bracketed paste
         this.setupRawPasteHandler();
         this.rl.on('line', (line) => {
@@ -448,10 +424,7 @@ export class InteractiveShell {
             if (this.bracketedPaste.isCapturingRaw()) {
                 this.resetBufferedInputLines();
                 // Clear the line that readline just echoed - move up and clear
-                // Only write to output when not processing (during streaming, output is suppressed)
-                if (!this.isProcessing) {
-                    output.write('\x1b[A\r\x1b[K');
-                }
+                output.write('\x1b[A\r\x1b[K');
                 // Show paste progress (this will update in place)
                 this.showMultiLinePastePreview(this.bracketedPaste.getRawBufferLineCount(), this.bracketedPaste.getRawBufferPreview());
                 return;
@@ -461,10 +434,7 @@ export class InteractiveShell {
             if (this.bracketedPaste.shouldIgnoreLineEvent()) {
                 this.resetBufferedInputLines();
                 // Clear the echoed line that readline wrote
-                // Only write to output when not processing (during streaming, output is suppressed)
-                if (!this.isProcessing) {
-                    output.write('\x1b[A\r\x1b[K');
-                }
+                output.write('\x1b[A\r\x1b[K');
                 return;
             }
             const normalized = this.bracketedPaste.process(line);
@@ -474,21 +444,15 @@ export class InteractiveShell {
                 // If still accumulating multi-line paste, show preview
                 if (normalized.isPending) {
                     // Clear the line that readline just echoed - move up and clear
-                    // Only write to output when not processing (during streaming, output is suppressed)
-                    if (!this.isProcessing) {
-                        output.write('\x1b[A\r\x1b[K');
-                    }
+                    output.write('\x1b[A\r\x1b[K');
                     this.showMultiLinePastePreview(normalized.lineCount || 0, normalized.preview);
                     return;
                 }
-                // Paste complete - ALWAYS capture for confirmation, never auto-submit
-                // This is critical during streaming - pastes should be queued, not submitted
+                // Paste complete, store or submit the full content
                 if (typeof normalized.result === 'string') {
                     this.clearMultiLinePastePreview();
                     const lineCount = normalized.lineCount ?? normalized.result.split('\n').length;
-                    // During streaming: capture paste and queue as follow-up when user presses Enter
-                    // Not streaming: capture paste and wait for user to press Enter to submit
-                    // Either way, we NEVER auto-submit pasted content
+                    // All pastes (single or multi-line) are captured for confirmation before submit
                     this.capturePaste(normalized.result, lineCount);
                     return;
                 }
@@ -514,11 +478,6 @@ export class InteractiveShell {
                 this.rawDataHandler(); // This restores the original emit function
                 this.rawDataHandler = null;
             }
-            // Remove SIGINT handler
-            if (this.sigintHandler) {
-                process.off('SIGINT', this.sigintHandler);
-                this.sigintHandler = null;
-            }
             // Clear any pending cleanup to prevent hanging
             this.pendingCleanup = null;
             // Dispose persistent prompt
@@ -605,114 +564,15 @@ export class InteractiveShell {
         if (inputStream.setRawMode && !inputStream.isRaw) {
             inputStream.setRawMode(true);
         }
-        // Track last escape time for double-escape detection
-        let lastEscapeTime = 0;
         this.keypressHandler = (_str, key) => {
             // Handle special keys
             if (key) {
-                // Shift+Enter or Option+Enter: Insert newline for multi-line input
-                if ((key.name === 'enter' || key.name === 'return') && (key.shift || key.meta)) {
-                    const currentLine = this.rl.line || '';
-                    const cursorPos = this.rl.cursor || 0;
-                    // Insert newline at cursor position
-                    const newLine = currentLine.slice(0, cursorPos) + '\n' + currentLine.slice(cursorPos);
-                    this.rl.line = newLine;
-                    this.rl.cursor = cursorPos + 1;
-                    this.persistentPrompt.updateInput(newLine, cursorPos + 1);
-                    this.pinnedChatBox.setInput(newLine, cursorPos + 1);
-                    if (this.isProcessing) {
-                        this.pinnedChatBox.updatePersistentInput();
-                    }
-                    return; // Prevent readline from submitting
-                }
-                // Backslash+Enter: Insert newline (escape sequence for multi-line)
-                if (key.name === 'enter' || key.name === 'return') {
-                    const currentLine = this.rl.line || '';
-                    const cursorPos = this.rl.cursor || 0;
-                    // Check if last char before cursor is backslash
-                    if (cursorPos > 0 && currentLine[cursorPos - 1] === '\\') {
-                        // Replace backslash with newline
-                        const newLine = currentLine.slice(0, cursorPos - 1) + '\n' + currentLine.slice(cursorPos);
-                        this.rl.line = newLine;
-                        this.rl.cursor = cursorPos; // Cursor stays after newline
-                        this.persistentPrompt.updateInput(newLine, cursorPos);
-                        this.pinnedChatBox.setInput(newLine, cursorPos);
-                        if (this.isProcessing) {
-                            this.pinnedChatBox.updatePersistentInput();
-                        }
-                        return; // Prevent readline from submitting
-                    }
-                    // During AI streaming, use pinned chat box for input submission
-                    if (this.isProcessing) {
-                        // Check if there's content BEFORE calling handleSubmit
-                        const hadContent = this.pinnedChatBox.getInput().length > 0 || this.pinnedChatBox.hasPastedBlock();
-                        const hadComposedContent = this.composableMessage.hasContent();
-                        const submittedInput = this.pinnedChatBox.handleSubmit();
-                        // If there was content (now queued), clear readline buffer and return
-                        // This prevents double-queueing via readline's 'line' event
-                        if (hadContent || hadComposedContent || submittedInput !== null) {
-                            // Clear readline's buffer to prevent 'line' event from re-processing
-                            this.rl.line = '';
-                            this.rl.cursor = 0;
-                            // Also clear composableMessage to prevent duplication since
-                            // pinnedChatBox already queued the paste content
-                            if (hadComposedContent) {
-                                this.composableMessage.clear();
-                            }
-                            // Input was handled by pinned chat box (queued)
-                            return;
-                        }
-                    }
-                    // Otherwise, let readline handle the enter key normally
-                }
-                // Ctrl+L: Clear screen (like Claude Code)
-                if (key.ctrl && key.name === 'l') {
-                    display.clear();
-                    this.rl.prompt();
-                    return;
-                }
-                // ? alone: Show keyboard shortcuts help
-                if (_str === '?' && !key.ctrl && !key.meta && !key.shift) {
-                    const currentLine = this.rl.line || '';
-                    // Only show help if input is empty (typing ? normally otherwise)
-                    if (currentLine.length === 0 && !this.isProcessing) {
-                        this.handleShortcutsCommand();
-                        this.rl.prompt();
-                        return;
-                    }
-                }
                 // Shift+Tab for profile switching
                 if (key.name === 'tab' && key.shift && this.agentMenu) {
                     this.showProfileSwitcher();
                 }
-                // Escape: Cancel current operation or double-tap to clear
+                // Escape: Cancel current operation if agent is running
                 if (key.name === 'escape') {
-                    const now = Date.now();
-                    const timeSinceLastEscape = now - lastEscapeTime;
-                    lastEscapeTime = now;
-                    // Double Escape (within 500ms): Clear input and queue
-                    if (timeSinceLastEscape < 500 && !this.isProcessing) {
-                        const currentLine = this.rl.line || '';
-                        const hasQueue = this.followUpQueue.length > 0;
-                        if (currentLine.length > 0 || hasQueue) {
-                            // Clear everything
-                            this.rl.line = '';
-                            this.rl.cursor = 0;
-                            this.composableMessage.clear();
-                            this.bracketedPaste.reset();
-                            this.persistentPrompt.updateInput('', 0);
-                            this.pinnedChatBox.setInput('');
-                            this.pinnedChatBox.clearPastedBlockState();
-                            if (hasQueue) {
-                                this.followUpQueue.length = 0;
-                                this.refreshQueueIndicators();
-                            }
-                            output.write('\r\x1b[K');
-                            display.showInfo('Input and queue cleared.');
-                            this.rl.prompt();
-                            return;
-                        }
-                    }
                     if (this.isProcessing && this.agent) {
                         this.agent.requestCancellation();
                         output.write('\n');
@@ -740,15 +600,11 @@ export class InteractiveShell {
                         return;
                     }
                     const currentLine = this.rl.line || '';
-                    const hasComposedContent = this.composableMessage.hasContent();
-                    const hasChatBoxContent = this.pinnedChatBox.getInput().length > 0 || this.pinnedChatBox.hasPastedBlock();
-                    const hasAnyContent = currentLine.length > 0 || hasComposedContent || hasChatBoxContent;
-                    if (hasAnyContent) {
-                        // Clear all input buffers before exiting
+                    if (currentLine.length > 0) {
+                        // Clear the input buffer instead of exiting
+                        // Write Ctrl+U to clear the line in readline
                         this.rl.line = '';
                         this.rl.cursor = 0;
-                        this.composableMessage.clear();
-                        this.bracketedPaste.reset();
                         this.persistentPrompt.updateInput('', 0);
                         this.pinnedChatBox.setInput('');
                         this.pinnedChatBox.clearPastedBlockState();
@@ -760,79 +616,6 @@ export class InteractiveShell {
                     }
                     // If no text in buffer, let default Ctrl+C behavior exit
                 }
-                // Backspace: Handle chip-aware deletion
-                if (key.name === 'backspace') {
-                    const currentLine = this.rl.line || '';
-                    const cursorPos = this.rl.cursor || 0;
-                    // Check if we're at the end of a paste chip (character before cursor is ']')
-                    if (cursorPos > 0 && currentLine[cursorPos - 1] === ']') {
-                        const beforeCursor = currentLine.slice(0, cursorPos);
-                        const chipStart = beforeCursor.lastIndexOf('[');
-                        if (chipStart !== -1) {
-                            // Verify this looks like a paste chip
-                            const potentialChip = beforeCursor.slice(chipStart);
-                            if (potentialChip.match(/^\[(?:📋|📝|📊|📄)[^\]]*\]$/)) {
-                                // Delete the entire chip by updating readline directly
-                                const newLine = currentLine.slice(0, chipStart) + currentLine.slice(cursorPos);
-                                this.rl.line = newLine;
-                                this.rl.cursor = chipStart;
-                                // Sync to display components
-                                this.persistentPrompt.updateInput(newLine, chipStart);
-                                this.pinnedChatBox.setInput(newLine, chipStart);
-                                // Check if this was the last chip - clear composable message
-                                const hasChipRemaining = /\[(?:📋|📝|📊|📄)[^\]]*\]/.test(newLine);
-                                if (!hasChipRemaining && this.composableMessage.hasContent()) {
-                                    this.composableMessage.clear();
-                                    this.updateComposeStatusSummary();
-                                }
-                                // During processing, update the persistent display
-                                if (this.isProcessing) {
-                                    this.pinnedChatBox.updatePersistentInput();
-                                }
-                                else {
-                                    // Refresh readline display
-                                    this.rl.prompt(true);
-                                }
-                                // Prevent readline from processing this backspace
-                                return;
-                            }
-                        }
-                    }
-                }
-                // Delete key: Handle chip-aware deletion
-                if (key.name === 'delete') {
-                    const currentLine = this.rl.line || '';
-                    const cursorPos = this.rl.cursor || 0;
-                    // Check if we're at the start of a paste chip
-                    if (cursorPos < currentLine.length && currentLine[cursorPos] === '[') {
-                        const afterCursor = currentLine.slice(cursorPos);
-                        const chipMatch = afterCursor.match(/^\[(?:📋|📝|📊|📄)[^\]]*\]/);
-                        if (chipMatch) {
-                            // Delete the entire chip
-                            const newLine = currentLine.slice(0, cursorPos) + currentLine.slice(cursorPos + chipMatch[0].length);
-                            this.rl.line = newLine;
-                            // Cursor stays in same position
-                            // Sync to display components
-                            this.persistentPrompt.updateInput(newLine, cursorPos);
-                            this.pinnedChatBox.setInput(newLine, cursorPos);
-                            // Check if this was the last chip
-                            const hasChipRemaining = /\[(?:📋|📝|📊|📄)[^\]]*\]/.test(newLine);
-                            if (!hasChipRemaining && this.composableMessage.hasContent()) {
-                                this.composableMessage.clear();
-                                this.updateComposeStatusSummary();
-                            }
-                            // During processing, update the persistent display
-                            if (this.isProcessing) {
-                                this.pinnedChatBox.updatePersistentInput();
-                            }
-                            else {
-                                this.rl.prompt(true);
-                            }
-                            // Prevent readline from processing this delete
-                            return;
-                        }
-                    }
-                }
             }
             // Readline handles all keyboard input natively (history, shortcuts, etc.)
             // We just sync the current state to our display components
@@ -841,25 +624,6 @@ export class InteractiveShell {
                 const currentLine = this.rl.line || '';
                 const cursorPos = this.rl.cursor || 0;
                 this.persistentPrompt.updateInput(currentLine, cursorPos);
-                // During AI streaming, use handleInput for character-by-character input
-                // to enable the persistent chat box functionality
-                if (this.isProcessing && _str && key && key.name && !key.ctrl && !key.meta) {
-                    // Handle regular character input during streaming
-                    if (_str.length === 1 && !['enter', 'return', 'backspace', 'delete', 'escape', 'tab'].includes(key.name)) {
-                        this.pinnedChatBox.handleInput(_str);
-                        return; // Skip the normal sync since handleInput already updated the display
-                    }
-                    // Handle backspace during streaming
-                    if (key.name === 'backspace') {
-                        this.pinnedChatBox.handleBackspace();
-                        return; // Skip the normal sync since handleBackspace already updated the display
-                    }
-                    // Handle delete during streaming
-                    if (key.name === 'delete') {
-                        this.pinnedChatBox.handleDelete();
-                        return; // Skip the normal sync since handleDelete already updated the display
-                    }
-                }
                 // Sync to pinned chat box for display only
                 this.pinnedChatBox.setInput(currentLine, cursorPos);
                 // During processing, update the persistent input display so user can see what they're typing
@@ -867,18 +631,8 @@ export class InteractiveShell {
                     this.pinnedChatBox.updatePersistentInput();
                 }
                 if (this.composableMessage.hasContent()) {
-                    // Check if all paste chips have been deleted from the input
-                    // Chips look like: [📋 Pasted: ...] or [📝 Code: ...] etc.
-                    const hasChipInInput = /\[(?:📋|📝|📊|📄)[^\]]*\]/.test(currentLine);
-                    if (!hasChipInInput) {
-                        // User deleted all chips - clear the composable message
-                        this.composableMessage.clear();
-                        this.updateComposeStatusSummary();
-                    }
-                    else {
-                        this.composableMessage.setDraft(currentLine);
-                        this.updateComposeStatusSummary();
-                    }
+                    this.composableMessage.setDraft(currentLine);
+                    this.updateComposeStatusSummary();
                 }
                 this.handleSlashCommandPreviewChange();
             });
@@ -906,11 +660,7 @@ export class InteractiveShell {
         });
     }
     setProcessingStatus(detail) {
-        // Reasoning models (o1, deepseek-reasoner) don't stream - show distinct status
-        const model = this.sessionState.model?.toLowerCase() || '';
-        const isReasoningModel = model.includes('reasoner') || model.startsWith('o1') || model.includes('-reasoning');
-        const baseMessage = isReasoningModel ? '🧠 Reasoning...' : 'Working on your request';
-        this.statusTracker.setBase(baseMessage, {
+        this.statusTracker.setBase('Working on your request', {
             detail: this.describeStatusDetail(detail),
             tone: 'info',
         });
@@ -1042,47 +792,71 @@ export class InteractiveShell {
      * 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.
-     *
-     * Strategy: Completely redirect readline's output to a null stream.
-     * AI streaming writes directly to process.stdout, bypassing readline,
-     * so it will still appear. Only readline's echo is suppressed.
      */
     suppressReadlineOutput() {
         if (this.readlineOutputSuppressed || !output.isTTY) {
             return;
         }
-        // Save readline's original output stream
-        this.originalReadlineOutput = this.rl.output;
-        // Create a null stream that discards all writes
-        const nullStream = {
-            write: () => true,
-            end: () => { },
-            on: () => nullStream,
-            once: () => nullStream,
-            emit: () => false,
-            removeListener: () => nullStream,
-            isTTY: true,
-            columns: output.columns,
-            rows: output.rows,
+        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);
         };
-        // Redirect readline's output to null - this completely stops echo
-        this.rl.output = nullStream;
         this.readlineOutputSuppressed = true;
     }
-    // Store original readline output for restoration
-    originalReadlineOutput = null;
     /**
      * Restore normal readline output after streaming completes.
      */
     restoreReadlineOutput() {
-        if (!this.readlineOutputSuppressed) {
+        if (!this.readlineOutputSuppressed || !this.originalStdoutWrite) {
             return;
         }
-        // Restore readline's original output stream
-        if (this.originalReadlineOutput) {
-            this.rl.output = this.originalReadlineOutput;
-            this.originalReadlineOutput = null;
-        }
+        output.write = this.originalStdoutWrite;
+        this.originalStdoutWrite = null;
         this.readlineOutputSuppressed = false;
     }
     enqueueUserInput(line, flushImmediately = false) {
@@ -1135,20 +909,12 @@ export class InteractiveShell {
             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
-            ? `📋 Pasting: ${preview.slice(0, 50)}${preview.length > 50 ? '...' : ''}`
-            : `📋 Pasting ${lineCount} line${lineCount !== 1 ? 's' : ''}...`;
-        // During processing, show preview in the persistent chat box at the bottom
-        // This prevents it from appearing in the streaming output area
-        if (this.isProcessing) {
-            this.pinnedChatBox.setInput(statusText, statusText.length);
-            this.pinnedChatBox.updatePersistentInput();
-        }
-        else {
-            // Not processing - write to output normally
-            output.write('\r\x1b[K');
-            output.write(theme.ui.muted(statusText));
-        }
+            ? `${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
@@ -1157,18 +923,11 @@ export class InteractiveShell {
         if (!this.inPasteCapture) {
             return;
         }
+        // Clear current line
+        output.write('\r\x1b[K');
         // Reset tracking state
         this.lastPastePreviewLineCount = 0;
         this.inPasteCapture = false;
-        // During processing, clear the persistent chat box preview
-        if (this.isProcessing) {
-            this.pinnedChatBox.setInput('', 0);
-            this.pinnedChatBox.updatePersistentInput();
-        }
-        else {
-            // Not processing - clear output normally
-            output.write('\r\x1b[K');
-        }
     }
     /**
      * Capture any paste (single or multi-line) without immediately submitting it.
@@ -1187,15 +946,7 @@ export class InteractiveShell {
             const displayContent = lineCount === 1
                 ? content
                 : content.replace(/\n/g, ' ↵ '); // Visual newline indicator for 2-line pastes
-            // During processing, ONLY update pinnedChatBox - never write to output
-            // This prevents paste from leaking into the streaming area
-            if (this.isProcessing) {
-                // handleInput triggers handleMultilinePaste which handles rendering
-                // NO redundant updatePersistentInput call - it causes double renders
-                this.pinnedChatBox.handleInput(content);
-                return;
-            }
-            // Clear any echoed content first (only when not processing)
+            // Clear any echoed content first
             output.write('\r\x1b[K');
             // Get current readline content and append paste
             const currentLine = this.rl.line || '';
@@ -1205,55 +956,42 @@ export class InteractiveShell {
             const after = currentLine.slice(cursorPos);
             const newLine = before + displayContent + after;
             const newCursor = cursorPos + displayContent.length;
-            // Update readline buffer silently (without echoing to output)
-            this.rl.line = newLine;
-            this.rl.cursor = newCursor;
+            // 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);
-            // CRITICAL: Update pinnedChatBox to show paste in the persistent bottom area
-            // Always use handleInput to trigger consistent paste detection and summarization
-            // This ensures multi-line paste is handled the same way on load and during processing
-            this.pinnedChatBox.handleInput(content);
-            // Not processing - render pinned chat box and sync readline
-            this.pinnedChatBox.forceRender();
+            // 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
         this.composableMessage.addPaste(content);
-        // During processing, ONLY update pinnedChatBox - never write to output
-        // This prevents paste from leaking into the streaming area
-        if (this.isProcessing) {
-            // handleInput triggers handleMultilinePaste which handles rendering
-            // NO redundant updatePersistentInput call - it causes double renders
-            this.pinnedChatBox.handleInput(content);
-            return;
-        }
-        // Clear remaining echoed lines from terminal (only when not processing)
+        // 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();
-        const displayText = `${pasteChips} `;
-        const cursorPos = displayText.length;
         // Update status bar - minimal hint, no confirmation required
         this.persistentPrompt.updateStatusBar({
             message: 'Press Enter to send',
         });
-        // Update both prompt systems with the paste chips
-        this.persistentPrompt.updateInput(displayText, cursorPos);
+        // 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 = displayText;
-            this.rl.cursor = cursorPos;
-        }
-        // CRITICAL: Update pinnedChatBox to show paste chips in the persistent bottom area
-        // This ensures the paste indicator appears in the chat box, NOT in the streaming area
-        // Always use handleInput to trigger consistent paste detection and summarization
-        this.pinnedChatBox.handleInput(content);
-        // Not processing - render pinned chat box and sync readline
-        this.pinnedChatBox.forceRender();
+            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
     }
     /**
@@ -1279,13 +1017,6 @@ export class InteractiveShell {
         const combined = this.bufferedInputLines.join('\n');
         this.bufferedInputLines = [];
         this.bufferedInputTimer = null;
-        // CRITICAL: Long multi-line content (3+ lines) should NEVER be auto-submitted
-        // This catches rapid input that bypasses bracketed paste detection
-        // Instead, capture it like a paste and require explicit Enter to submit
-        if (lineCount >= 3) {
-            this.capturePaste(combined, lineCount);
-            return;
-        }
         try {
             await this.processInputBlock(combined, lineCount > 1);
         }
@@ -1379,14 +1110,6 @@ export class InteractiveShell {
         this.slashPreviewVisible = false;
         this.uiAdapter.hideSlashCommandPreview();
         const trimmed = line.trim();
-        // CRITICAL SAFETY: Long multi-line content (3+ lines) should NEVER be auto-submitted
-        // Capture it for explicit user confirmation, regardless of how it arrived
-        const lineCount = line.split('\n').length;
-        if (lineCount >= 3 && !this.composableMessage.hasContent()) {
-            // Don't re-capture if we already have composed content (user is submitting a paste)
-            this.capturePaste(line, lineCount);
-            return;
-        }
         if (await this.handlePendingInteraction(trimmed)) {
             return;
         }
@@ -1443,14 +1166,6 @@ export class InteractiveShell {
                 this.rl.prompt();
                 return;
             }
-            // CRITICAL: If we're processing, queue the assembled content as a follow-up
-            // This ensures multi-line pastes submitted during streaming don't interrupt
-            if (this.isProcessing) {
-                this.enqueueFollowUpAction({ type: 'request', text: assembled });
-                // Clear input display after queueing
-                this.pinnedChatBox.clearInput();
-                return;
-            }
             // Check if assembled content is a continuous command
             if (this.isContinuousCommand(assembled)) {
                 await this.processContinuousRequest(assembled);
@@ -1654,7 +1369,6 @@ export class InteractiveShell {
             this.buildSlashCommandList('Available Commands:'),
             '',
             'Type your request in natural language and press Enter.',
-            'Press ? or type /shortcuts for keyboard shortcuts.',
         ];
         display.showSystemMessage(info.join('\n'));
     }
@@ -1937,7 +1651,7 @@ export class InteractiveShell {
         lines.push(theme.bold('Session File Changes'));
         lines.push('');
         lines.push(`${theme.info('•')} ${summary.files} file${summary.files === 1 ? '' : 's'} modified`);
-        lines.push(`${theme.info('•')} ${theme.success(`+${summary.additions}`)} ${theme.error(`-${summary.removals}`)} lines`);
+        lines.push(`${theme.info('•')} ${theme.success('+' + summary.additions)} ${theme.error('-' + summary.removals)} lines`);
         lines.push('');
         // Group changes by file
         const fileMap = new Map();
@@ -1961,7 +1675,7 @@ export class InteractiveShell {
             if (stats.writes > 0)
                 operations.push(`${stats.writes} write${stats.writes === 1 ? '' : 's'}`);
             const opsText = operations.join(', ');
-            const diffText = `${theme.success(`+${stats.additions}`)} ${theme.error(`-${stats.removals}`)}`;
+            const diffText = `${theme.success('+' + stats.additions)} ${theme.error('-' + stats.removals)}`;
             lines.push(`  ${theme.dim(path)}`);
             lines.push(`    ${opsText} • ${diffText}`);
         }
@@ -2687,14 +2401,6 @@ export class InteractiveShell {
         this.rl.prompt();
     }
     async processRequest(request) {
-        // CRITICAL SAFETY: Long multi-line content should never be auto-queued
-        // This is a last-line defense - content should have been captured earlier
-        const lineCount = request.split('\n').length;
-        if (lineCount >= 3 && !this.composableMessage.hasContent()) {
-            // Capture instead of processing/queueing - user must explicitly confirm
-            this.capturePaste(request, lineCount);
-            return;
-        }
         if (this.isProcessing) {
             this.enqueueFollowUpAction({ type: 'request', text: request });
             return;
@@ -2709,17 +2415,10 @@ export class InteractiveShell {
         }
         this.isProcessing = true;
         const requestStartTime = Date.now(); // Alpha Zero 2 timing
-        // Detect reasoning models (o1, deepseek-reasoner) that don't stream text
-        const model = this.sessionState.model?.toLowerCase() || '';
-        const isReasoningModel = model.includes('reasoner') || model.startsWith('o1') || model.includes('-reasoning');
         // Keep persistent prompt visible during processing so users can type follow-up requests
         // The prompt will show a "processing" indicator but remain interactive
-        const statusMessage = isReasoningModel
-            ? '🧠 Reasoning... (type to queue follow-up)'
-            : '⏳ Processing... (type to queue follow-up)';
-        this.persistentPrompt.updateStatusBar({ message: statusMessage });
+        this.persistentPrompt.updateStatusBar({ message: '⏳ Processing... (type to queue follow-up)' });
         // Update pinned chat box to show processing state
-        this.pinnedChatBox.setReasoningModel(isReasoningModel);
         // Clear the input display since the request was already submitted
         // Note: Don't set statusMessage here - the isProcessing flag already shows "⏳ Processing..."
         this.pinnedChatBox.setProcessing(true);
@@ -2727,7 +2426,6 @@ export class InteractiveShell {
         this.pinnedChatBox.clearInput();
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
-        let renderInterval = null;
         try {
             // Add visual separator between user prompt and AI response
             display.newLine();
@@ -2736,12 +2434,6 @@ export class InteractiveShell {
             this.pinnedChatBox.enableScrollRegion();
             // Suppress readline echo so typed characters only appear in persistent input box
             this.suppressReadlineOutput();
-            // Set up periodic render timer to ensure pinned chat box stays visible during streaming
-            renderInterval = setInterval(() => {
-                if (this.isProcessing && this.pinnedChatBox.isActive()) {
-                    this.pinnedChatBox.forceRender();
-                }
-            }, 2000); // Render every 2 seconds during streaming
             // Enable streaming for real-time text output (Claude Code style)
             await agent.send(request, true);
             await this.awaitPendingCleanup();
@@ -2781,11 +2473,6 @@ export class InteractiveShell {
             this.rl.prompt();
             this.scheduleQueueProcessing();
             this.refreshQueueIndicators();
-            // Ensure any periodic render timer is cleaned up
-            if (renderInterval) {
-                clearInterval(renderInterval);
-                renderInterval = null;
-            }
         }
     }
     /**
@@ -2834,8 +2521,6 @@ export class InteractiveShell {
         this.pinnedChatBox.enableScrollRegion();
         // Suppress readline echo so typed characters only appear in persistent input box
         this.suppressReadlineOutput();
-        // Periodically refresh the pinned chat box while streaming
-        let renderInterval = null;
         let iteration = 0;
         let lastResponse = '';
         let consecutiveNoProgress = 0;
@@ -2858,11 +2543,6 @@ IMPORTANT: You have full git access. After making improvements:
 Commit frequently with descriptive messages. Push when ready.
 When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
             }
-            renderInterval = setInterval(() => {
-                if (this.isProcessing && this.pinnedChatBox.isActive()) {
-                    this.pinnedChatBox.forceRender();
-                }
-            }, 2000);
             while (iteration < MAX_ITERATIONS) {
                 iteration++;
                 display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
@@ -3000,10 +2680,6 @@ What's the next action?`;
             const minutes = Math.floor(totalElapsed / 60000);
             const seconds = Math.floor((totalElapsed % 60000) / 1000);
             display.showSystemMessage(`\n🏁 Continuous execution completed: ${iteration} iterations, ${minutes}m ${seconds}s total`);
-            if (renderInterval) {
-                clearInterval(renderInterval);
-                renderInterval = null;
-            }
             // Reset completion detector for next task
             resetTaskCompletionDetector();
             // Restore readline echo before other cleanup
@@ -3248,9 +2924,7 @@ What's the next action?`;
                             display.showNarrative(content.trim());
                         }
                         // The isProcessing flag already shows "⏳ Processing..." - no need for duplicate status
-                        // Note: Don't call forceRender() here - the output interceptor's afterWrite handles
-                        // re-rendering the persistent input. Calling forceRender() immediately can cause
-                        // cursor position issues when RESTORE_CURSOR doesn't work correctly in some terminals.
+                        this.pinnedChatBox.forceRender();
                         return;
                     }
                     const cleanup = this.handleContextTelemetry(metadata, enriched);
@@ -3719,7 +3393,7 @@ What's the next action?`;
         // Truncate to reasonable length
         const maxLength = 50;
         return cleaned.length > maxLength
-            ? `${cleaned.slice(0, maxLength - 3)}...`
+            ? cleaned.slice(0, maxLength - 3) + '...'
             : cleaned;
     }
     splitThinkingResponse(content) {