erosolar-cli 1.7.53 → 1.7.55

package/dist/shell/interactiveShell.js

@@ -23,7 +23,6 @@ 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 { verifyResponse, formatVerificationReport, } from '../core/responseVerifier.js';
 const DROPDOWN_COLORS = [
     theme.primary,
     theme.info,
@@ -74,7 +73,6 @@ export class InteractiveShell {
     workspaceOptions;
     sessionState;
     isProcessing = false;
-    isInsideThinkingBlock = false;
     pendingInteraction = null;
     pendingSecretRetry = null;
     bufferedInputLines = [];
@@ -107,12 +105,8 @@ export class InteractiveShell {
     pendingHistoryLoad = null;
     cachedHistory = [];
     activeSessionId = null;
-    sessionStartTime = Date.now();
     activeSessionTitle = null;
     sessionResumeNotice = null;
-    lastAssistantResponse = null;
-    verificationRetryCount = 0;
-    maxVerificationRetries = 2;
     customCommands;
     customCommandMap;
     sessionRestoreConfig;
@@ -173,11 +167,16 @@ export class InteractiveShell {
             // Update persistent prompt status bar with file changes
             this.updatePersistentPromptFileChanges();
         });
-        // Set up tool status callback to update streaming status line during tool execution
-        // Uses Claude Code style: single line at bottom that updates in-place
+        // Set up tool status callback to update pinned chat box during tool execution
         this.uiAdapter.setToolStatusCallback((status) => {
-            // Update the streaming status line (Claude Code style)
-            display.updateStreamingStatus(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.skillRepository = new SkillRepository({
             workingDir: this.workingDir,
@@ -189,8 +188,9 @@ export class InteractiveShell {
         this.rl = readline.createInterface({
             input,
             output,
-            // Claude Code style: simple '> ' prompt
-            prompt: '> ',
+            // Use empty prompt since PinnedChatBox handles all prompt rendering
+            // This prevents duplicate '>' characters from appearing
+            prompt: '',
             terminal: true,
             historySize: 100, // Enable native readline history
         });
@@ -281,10 +281,7 @@ export class InteractiveShell {
         this.pinnedChatBox.show();
         this.pinnedChatBox.forceRender();
         if (initialPrompt) {
-            // For command-line prompts, show the user's input with separator (Claude Code style)
             display.newLine();
-            const cols = Math.min(process.stdout.columns || 80, 72);
-            console.log(theme.ui.border('─'.repeat(cols)));
             console.log(`${formatUserPrompt(this.profileLabel || this.profile)}${initialPrompt}`);
             await this.processInputBlock(initialPrompt);
             return;
@@ -421,7 +418,24 @@ export class InteractiveShell {
         // Set up raw data interception for bracketed paste
         this.setupRawPasteHandler();
         this.rl.on('line', (line) => {
-            // Process through bracketed paste manager which handles paste markers
+            // 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
@@ -472,6 +486,8 @@ export class InteractiveShell {
             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',
@@ -494,17 +510,36 @@ export class InteractiveShell {
      * capture complete multi-line pastes without readline splitting them.
      */
     setupRawPasteHandler() {
-        // NOTE: Raw data interception is disabled because it doesn't reliably prevent
-        // readline from also receiving the data (prependListener doesn't block other handlers).
-        // Instead, we rely on the line-based bracketed paste handling in the 'line' event
-        // handler which processes the markers via bracketedPaste.process().
-        //
-        // The line-based approach works because:
-        // 1. Readline splits paste content at newlines and emits 'line' events
-        // 2. Each line event goes through bracketedPaste.process() which tracks markers
-        // 3. Content between markers is accumulated and returned as a complete paste
-        //
-        // This is simpler and more reliable than trying to intercept raw data.
+        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;
+            // All pastes (single or multi-line) are captured for confirmation before submit
+            this.capturePaste(content, lineCount);
+        });
+        // Set up raw data interception to catch bracketed paste before readline processes it
+        // We prepend our listener so it runs before readline's listener
+        this.rawDataHandler = (data) => {
+            const str = data.toString();
+            const result = this.bracketedPaste.processRawData(str);
+            if (result.consumed) {
+                // Don't show preview here - readline will still echo lines to the terminal,
+                // and our preview would get clobbered. Instead, we show the preview in the
+                // line handler after clearing readline's echoed output.
+                // The processRawData() sets flags that the line handler will check.
+            }
+        };
+        // Use prependListener to ensure our handler runs before readline's handlers
+        // This gives us first look at the raw data including bracketed paste markers
+        inputStream.prependListener('data', this.rawDataHandler);
     }
     setupSlashCommandPreviewHandler() {
         const inputStream = input;
@@ -512,12 +547,7 @@ export class InteractiveShell {
             return;
         }
         if (inputStream.listenerCount('keypress') === 0) {
-            try {
-                readline.emitKeypressEvents(inputStream, this.rl);
-            }
-            catch {
-                // emitKeypressEvents can throw EIO when setting raw mode - safe to ignore
-            }
+            readline.emitKeypressEvents(inputStream, this.rl);
         }
         this.keypressHandler = (_str, key) => {
             // Handle special keys
@@ -534,8 +564,8 @@ export class InteractiveShell {
                 const currentLine = this.rl.line || '';
                 const cursorPos = this.rl.cursor || 0;
                 this.persistentPrompt.updateInput(currentLine, cursorPos);
-                // Sync to pinned chat box for display only (include cursor position)
-                this.pinnedChatBox.setInput(currentLine, cursorPos);
+                // Sync to pinned chat box for display only
+                this.pinnedChatBox.setInput(currentLine);
                 if (this.composableMessage.hasContent()) {
                     this.composableMessage.setDraft(currentLine);
                     this.updateComposeStatusSummary();
@@ -656,9 +686,8 @@ export class InteractiveShell {
      * left the stream paused, raw mode disabled, or keypress listeners detached.
      */
     ensureReadlineReady() {
-        // NOTE: Do NOT reset bracketedPaste here! Resetting clears the pasteJustCaptured
-        // flag which is needed to ignore readline line events that come after a paste
-        // is captured via the raw data handler.
+        // 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();
@@ -677,13 +706,7 @@ export class InteractiveShell {
         if (inputStream.isTTY && typeof inputStream.isRaw === 'boolean') {
             const ttyStream = inputStream;
             if (!ttyStream.isRaw) {
-                try {
-                    ttyStream.setRawMode(true);
-                }
-                catch (err) {
-                    // EIO errors can occur when terminal is in unusual state
-                    // Safe to ignore - readline will still work in cooked mode
-                }
+                ttyStream.setRawMode(true);
             }
         }
         // Reattach keypress handler if it was removed
@@ -692,12 +715,7 @@ export class InteractiveShell {
             const hasHandler = listeners.includes(this.keypressHandler);
             if (!hasHandler) {
                 if (inputStream.listenerCount('keypress') === 0) {
-                    try {
-                        readline.emitKeypressEvents(inputStream, this.rl);
-                    }
-                    catch {
-                        // emitKeypressEvents can throw EIO when setting raw mode - safe to ignore
-                    }
+                    readline.emitKeypressEvents(inputStream, this.rl);
                 }
                 inputStream.on('keypress', this.keypressHandler);
             }
@@ -775,55 +793,62 @@ export class InteractiveShell {
     }
     /**
      * Capture any paste (single or multi-line) without immediately submitting it.
-     * All pastes are stored as composable blocks and shown as short descriptions.
-     * The full content is sent to the AI when the user presses Enter.
-     *
-     * Display format:
-     * - Single paste: "[📋 Pasted: 15 lines] "
-     * - Multiple pastes: "[📋 Pasted: 15 lines] [📋 Pasted: 50 lines] "
+     * - 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.
      */
-    capturePaste(content, _lineCount) {
+    capturePaste(content, lineCount) {
         this.resetBufferedInputLines();
-        // If there's a pending interaction (menu selection, etc.), process the paste
-        // as direct input to that interaction instead of storing it
-        if (this.pendingInteraction) {
-            // Clear any echoed content
+        // 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');
-            // Use only the first line for menu selections
-            const firstLine = content.split('\n')[0]?.trim() || '';
-            if (firstLine) {
-                // Process through the normal input flow which handles pending interactions
-                this.processInputBlock(firstLine).catch((err) => {
-                    display.showError(err instanceof Error ? err.message : String(err));
-                });
-            }
-            return;
-        }
-        // Store ALL pastes (including short ones) as composable blocks
-        // This ensures consistent behavior and avoids readline buffer issues
+            // 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);
+            // 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);
-        // Clear any echoed content from terminal
+        // Clear remaining echoed lines from terminal
         output.write('\r\x1b[K');
-        // Build the paste description to show inline with prompt
-        // Format: "[📋 Pasted: 15 lines] [📋 Pasted: 50 lines] "
+        // 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 with instructions
         this.persistentPrompt.updateStatusBar({
             message: 'Paste more, type text, or press Enter to send (/cancel to discard)',
         });
-        // Clear readline buffer completely to avoid duplication issues
-        // Then show the paste chips in the prompt area without putting them in the buffer
-        this.rl.write(null, { ctrl: true, name: 'u' }); // Clear line completely
-        // Update persistent prompt display with paste chips
-        this.persistentPrompt.updateInput(`${pasteChips} `, pasteChips.length + 1);
-        // Reset readline's internal state to empty
-        // The paste chips are visual-only; actual content is in composableMessage
+        // 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 = '';
-            this.rl.cursor = 0;
+            this.rl.line = pasteChips + ' ';
+            this.rl.cursor = pasteChips.length + 1;
         }
-        // Re-prompt without preserving cursor (fresh start)
-        this.rl.prompt(false);
+        this.rl.prompt(true); // preserveCursor=true to keep position after chips
     }
     /**
      * Update the status bar to reflect any pending composed message parts
@@ -943,19 +968,21 @@ export class InteractiveShell {
         if (await this.handlePendingInteraction(trimmed)) {
             return;
         }
-        // If we have captured paste blocks, respect control commands before assembling
+        // If we have captured multi-line paste blocks, respect control commands before assembling
         if (this.composableMessage.hasContent()) {
-            // With the new paste handling, chips are visual-only and NOT in the readline buffer
-            // So userText is just the trimmed input directly (any text the user typed after pasting)
-            const userText = trimmed;
+            // 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);
-                // Clear paste state to prevent blocking follow-up prompts
-                this.bracketedPaste.clearPasteJustCaptured();
                 display.showInfo('Discarded captured paste.');
                 this.rl.prompt();
                 return;
@@ -990,8 +1017,6 @@ export class InteractiveShell {
             this.composableMessage.clear();
             this.updateComposeStatusSummary();
             this.persistentPrompt.updateInput('', 0);
-            // Clear paste state to prevent blocking follow-up prompts
-            this.bracketedPaste.clearPasteJustCaptured();
             if (!assembled) {
                 this.rl.prompt();
                 return;
@@ -1162,9 +1187,6 @@ export class InteractiveShell {
             case '/discover':
                 await this.discoverModelsCommand();
                 break;
-            case '/verify':
-                await this.handleVerifyCommand();
-                break;
             default:
                 if (!(await this.tryCustomSlashCommand(command, input))) {
                     display.showWarning(`Unknown command "${command}".`);
@@ -1278,7 +1300,7 @@ export class InteractiveShell {
         const context = buildWorkspaceContext(this.workingDir, this.workspaceOptions);
         const profileConfig = this.runtimeSession.refreshWorkspaceContext(context);
         const tools = this.runtimeSession.toolRuntime.listProviderTools();
-        this.baseSystemPrompt = buildInteractiveSystemPrompt(profileConfig.systemPrompt, profileConfig.label, tools, this.workingDir);
+        this.baseSystemPrompt = buildInteractiveSystemPrompt(profileConfig.systemPrompt, profileConfig.label, tools);
         if (this.rebuildAgent()) {
             display.showInfo(`Workspace snapshot refreshed (${this.describeWorkspaceOptions()}).`);
         }
@@ -1481,7 +1503,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();
@@ -1505,7 +1527,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}`);
         }
@@ -1515,211 +1537,6 @@ export class InteractiveShell {
         const summary = this.alphaZeroMetrics.getPerformanceSummary();
         display.showSystemMessage(summary);
     }
-    /**
-     * Create a verification context for isolated process verification.
-     *
-     * Verification now runs in a completely separate Node.js process for full isolation.
-     * This ensures:
-     * - Separate memory space from main CLI
-     * - Independent event loop
-     * - No shared state
-     * - Errors in verification cannot crash main process
-     */
-    createVerificationContext() {
-        // Build conversation history for context
-        const conversationHistory = this.cachedHistory
-            .filter(msg => msg.role === 'user' || msg.role === 'assistant')
-            .slice(-10) // Last 10 messages for context
-            .map(msg => `${msg.role}: ${typeof msg.content === 'string' ? msg.content.slice(0, 500) : '[complex content]'}`);
-        return {
-            workingDirectory: this.workingDir,
-            conversationHistory,
-            provider: this.sessionState.provider,
-            model: this.sessionState.model,
-        };
-    }
-    /**
-     * Handle /verify command - verify the last assistant response
-     */
-    async handleVerifyCommand() {
-        if (!this.lastAssistantResponse) {
-            display.showWarning('No assistant response to verify. Send a message first.');
-            return;
-        }
-        display.showSystemMessage('Verifying last response in isolated process...\n');
-        try {
-            const context = this.createVerificationContext();
-            const report = await verifyResponse(this.lastAssistantResponse, context);
-            const formattedReport = formatVerificationReport(report);
-            display.showSystemMessage(formattedReport);
-            // Show actionable summary
-            if (report.overallVerdict === 'contradicted') {
-                display.showError('Some claims in the response could not be verified!');
-            }
-            else if (report.overallVerdict === 'verified') {
-                display.showInfo('All verifiable claims in the response were verified.');
-            }
-            else if (report.overallVerdict === 'partially_verified') {
-                display.showWarning('Some claims were verified, but not all.');
-            }
-            else {
-                display.showInfo('No verifiable claims found in the response.');
-            }
-        }
-        catch (err) {
-            display.showError(`Verification failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * Check if a response looks like a completion (claims to be done)
-     * vs. asking follow-up questions or waiting for user input.
-     * Uses LLM to intelligently determine if verification should run.
-     * Only run auto-verification when assistant claims task completion.
-     */
-    async shouldRunAutoVerification(response) {
-        // Quick pre-filter: very short responses are unlikely to have verifiable claims
-        if (response.length < 100) {
-            return false;
-        }
-        try {
-            // Use LLM to determine if this response contains verifiable completion claims
-            const prompt = `Analyze this AI assistant response and determine if it claims to have COMPLETED a task that can be verified.
-
-RESPONSE:
----
-${response.slice(0, 2000)}
----
-
-Answer with ONLY "YES" or "NO":
-- YES: The response claims to have completed something verifiable (created/modified files, ran commands, fixed bugs, implemented features, etc.)
-- NO: The response is asking questions, requesting clarification, explaining concepts, or hasn't completed any verifiable action yet.
-
-Answer:`;
-            const agent = this.runtimeSession.createAgent({
-                provider: this.sessionState.provider,
-                model: this.sessionState.model,
-                temperature: 0,
-                maxTokens: 10,
-                systemPrompt: 'You are a classifier. Answer only YES or NO.',
-            });
-            const result = await agent.send(prompt);
-            const answer = result.trim().toUpperCase();
-            return answer.startsWith('YES');
-        }
-        catch {
-            // On error, fall back to not running verification
-            return false;
-        }
-    }
-    /**
-     * Schedule auto-verification after assistant response.
-     * Uses LLM-based semantic analysis to verify ALL claims.
-     * Runs asynchronously to not block the UI.
-     * Only runs when assistant claims completion, not when asking questions.
-     */
-    scheduleAutoVerification(response) {
-        // Run verification asynchronously after a short delay
-        // This allows the UI to update first
-        setTimeout(async () => {
-            try {
-                // Use LLM to determine if this response should be verified
-                const shouldVerify = await this.shouldRunAutoVerification(response);
-                if (!shouldVerify) {
-                    return;
-                }
-                display.showSystemMessage(`\n🔍 Auto-verifying response in isolated process...`);
-                const context = this.createVerificationContext();
-                const report = await verifyResponse(response, context);
-                const formattedReport = formatVerificationReport(report);
-                // Show compact result
-                if (report.summary.total === 0) {
-                    display.showInfo('No verifiable claims found in the response.');
-                    this.verificationRetryCount = 0;
-                    return;
-                }
-                if (report.overallVerdict === 'verified') {
-                    display.showInfo(`✅ Verified: ${report.summary.verified}/${report.summary.total} claims confirmed`);
-                    // Reset retry count on success
-                    this.verificationRetryCount = 0;
-                }
-                else if (report.overallVerdict === 'contradicted' || report.overallVerdict === 'partially_verified') {
-                    const failedCount = report.summary.failed;
-                    const icon = report.overallVerdict === 'contradicted' ? '❌' : '⚠️';
-                    const label = report.overallVerdict === 'contradicted' ? 'Verification failed' : 'Partial verification';
-                    display.showError(`${icon} ${label}: ${failedCount} claim${failedCount > 1 ? 's' : ''} could not be verified`);
-                    display.showSystemMessage(formattedReport);
-                    // Attempt to fix if we have retries left
-                    if (this.verificationRetryCount < this.maxVerificationRetries) {
-                        this.verificationRetryCount++;
-                        this.requestVerificationFix(report);
-                    }
-                    else {
-                        display.showWarning(`Max verification retries (${this.maxVerificationRetries}) reached. Use /verify to check manually.`);
-                        this.verificationRetryCount = 0;
-                    }
-                }
-            }
-            catch (err) {
-                // Silently ignore verification errors to not disrupt the flow
-                // User can always run /verify manually
-            }
-        }, 500);
-    }
-    /**
-     * Request the AI to fix failed verification claims.
-     * Generates a strategic fix request with context about what failed and why.
-     */
-    requestVerificationFix(report) {
-        const failedResults = report.results.filter(r => !r.verified && r.confidence === 'high');
-        if (failedResults.length === 0) {
-            return;
-        }
-        // Build detailed failure descriptions with suggested fixes
-        const failureDetails = failedResults.map(r => {
-            const claim = r.claim;
-            const evidence = r.evidence;
-            // Generate specific fix strategy based on claim category
-            let suggestedFix = '';
-            switch (claim.category) {
-                case 'file_op':
-                    suggestedFix = `Re-create or update the file at: ${claim.context['path'] || 'specified path'}`;
-                    break;
-                case 'code':
-                    suggestedFix = 'Fix any type errors or syntax issues, then run the build again';
-                    break;
-                case 'command':
-                    suggestedFix = 'Re-run the command and verify it completes successfully';
-                    break;
-                case 'state':
-                    suggestedFix = 'Verify the state change was applied correctly';
-                    break;
-                case 'behavior':
-                    suggestedFix = 'Test the feature manually or check implementation';
-                    break;
-                default:
-                    suggestedFix = 'Retry the operation';
-            }
-            return `• ${claim.statement}
-  Evidence: ${evidence.slice(0, 150)}
-  Suggested fix: ${suggestedFix}`;
-        }).join('\n\n');
-        const fixMessage = `🔧 VERIFICATION FAILED - AUTO-RETRY (attempt ${this.verificationRetryCount}/${this.maxVerificationRetries})
-
-The following claims could not be verified:
-
-${failureDetails}
-
-Think through this carefully, then:
-1. Analyze why each operation failed (check files, errors, state)
-2. Identify the root cause
-3. Fix the underlying issue
-4. Re-execute the failed operation(s)
-5. Verify the fix worked`;
-        display.showSystemMessage(`\n🔧 Auto-retry: Generating fix strategy for ${failedResults.length} failed claim${failedResults.length > 1 ? 's' : ''}...`);
-        // Queue the fix request
-        this.followUpQueue.push({ type: 'request', text: fixMessage });
-        this.scheduleQueueProcessing();
-    }
     showImprovementSuggestions() {
         const suggestions = this.alphaZeroMetrics.getImprovementSuggestions();
         if (suggestions.length === 0) {
@@ -2404,14 +2221,6 @@ Think through this carefully, then:
             this.rl.prompt();
             return;
         }
-        // Handle slash commands - exit secret input mode and process the command
-        if (trimmed.startsWith('/')) {
-            this.pendingInteraction = null;
-            this.pendingSecretRetry = null;
-            display.showInfo('Secret input cancelled.');
-            await this.processSlashCommand(trimmed);
-            return;
-        }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             this.pendingSecretRetry = null;
@@ -2454,20 +2263,25 @@ Think through this carefully, then:
             return;
         }
         this.isProcessing = true;
-        this.resetThinkingState(); // Reset thinking block styling state
         const requestStartTime = Date.now(); // Alpha Zero 2 timing
+        // Keep persistent prompt visible during processing so users can type follow-up requests
+        // The prompt will show a "processing" indicator but remain interactive
+        this.persistentPrompt.updateStatusBar({ message: '⏳ Processing... (type to queue follow-up)' });
         // Update pinned chat box to show processing state
+        // 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);
-        this.pinnedChatBox.setStatusMessage(null);
+        this.pinnedChatBox.setStatusMessage(null); // Clear any previous status to avoid duplication
         this.pinnedChatBox.clearInput();
-        // Add newline so user's submitted input stays visible
-        // (readline already displayed their input, we just need to preserve it)
-        process.stdout.write('\n');
-        // Note: Don't render pinned box during streaming - it interferes with content
-        // The spinner will handle showing activity
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
         try {
+            display.newLine();
+            // Pinned chat box already shows processing state - skip redundant spinner
+            // which would conflict with the pinned area at terminal bottom
+            // display.showThinking('Working on your request...');
+            // Force render the pinned chat box to ensure it's visible during processing
+            this.pinnedChatBox.forceRender();
             // Enable streaming for real-time text output (Claude Code style)
             await agent.send(request, true);
             await this.awaitPendingCleanup();
@@ -2489,21 +2303,14 @@ Think through this carefully, then:
             this.isProcessing = false;
             this.uiAdapter.endProcessing('Ready for prompts');
             this.setIdleStatus();
-            // Clear the pinned processing box before showing final output
-            this.pinnedChatBox.clear();
-            this.pinnedChatBox.setProcessing(false);
-            this.pinnedChatBox.setStatusMessage(null);
-            // SAFETY: Clear any stale composable message state to prevent blocking follow-ups
-            // This ensures the user can type normal follow-up prompts without being in "paste mode"
-            if (this.composableMessage.hasContent()) {
-                this.composableMessage.clear();
-            }
-            this.bracketedPaste.clearPasteJustCaptured();
-            // Also reset any stuck paste state to ensure clean input handling
-            this.bracketedPaste.reset();
+            display.newLine();
             // Clear the processing status and ensure persistent prompt is visible
             this.persistentPrompt.updateStatusBar({ message: undefined });
             this.persistentPrompt.show();
+            // Update pinned chat box to show ready state and force render
+            this.pinnedChatBox.setProcessing(false);
+            this.pinnedChatBox.setStatusMessage(null);
+            this.pinnedChatBox.forceRender();
             // CRITICAL: Ensure readline prompt is active for user input
             // This is a safety net in case the caller doesn't call rl.prompt()
             this.rl.prompt();
@@ -2721,11 +2528,10 @@ What's the next action?`;
             // Clear the processing status and ensure persistent prompt is visible
             this.persistentPrompt.updateStatusBar({ message: undefined });
             this.persistentPrompt.show();
-            // Clear streaming status line (Claude Code style)
-            display.clearStreamingStatus();
-            // Update pinned chat box to show ready state
+            // Update pinned chat box to show ready state and force render
             this.pinnedChatBox.setProcessing(false);
             this.pinnedChatBox.setStatusMessage(null);
+            this.pinnedChatBox.forceRender();
             // CRITICAL: Ensure readline prompt is active for user input
             // This is a safety net in case the caller doesn't call rl.prompt()
             this.rl.prompt();
@@ -2908,9 +2714,7 @@ What's the next action?`;
                             display.stopThinking(false);
                             process.stdout.write('\n'); // Newline after spinner
                         }
-                        // Style thinking blocks (Claude Code style)
-                        const styledChunk = this.styleStreamingChunk(chunk);
-                        process.stdout.write(styledChunk);
+                        process.stdout.write(chunk);
                     });
                 },
                 onAssistantMessage: (content, metadata) => {
@@ -2918,40 +2722,37 @@ What's the next action?`;
                     // Update spinner based on message type
                     if (metadata.isFinal) {
                         const parsed = this.splitThinkingResponse(content);
-                        // Don't re-display thinking - it was already streamed in real-time
-                        // Just extract the response part
-                        const finalContent = parsed?.response?.trim() || content.replace(/<thinking>[\s\S]*?<\/thinking>/gi, '').trim();
+                        if (parsed?.thinking) {
+                            const summary = this.extractThoughtSummary(parsed.thinking);
+                            if (summary) {
+                                display.updateThinking(`💭 ${summary}`);
+                            }
+                            display.showAssistantMessage(parsed.thinking, { ...enriched, isFinal: false });
+                        }
+                        const finalContent = parsed?.response?.trim() || content;
                         if (finalContent) {
                             display.showAssistantMessage(finalContent, enriched);
                         }
-                        // Store last response for verification
-                        this.lastAssistantResponse = content;
-                        // Auto-verify if response contains verifiable claims
-                        this.scheduleAutoVerification(content);
-                        // Show status line at end (Claude Code style: "Session 5m • Context X% used • Ready for prompts (2s)")
+                        // Show status line at end (Claude Code style: "• Context X% used • Ready for prompts (2s)")
                         display.stopThinking();
-                        // Calculate context usage and session time
-                        const sessionElapsedMs = Date.now() - this.sessionStartTime;
-                        let contextInfo = { sessionElapsedMs };
+                        // Calculate context usage
+                        let contextInfo;
                         if (enriched.contextWindowTokens && metadata.usage) {
                             const total = this.totalTokens(metadata.usage);
                             if (total && total > 0) {
                                 const percentage = Math.round((total / enriched.contextWindowTokens) * 100);
-                                contextInfo = { ...contextInfo, percentage, tokens: total };
+                                contextInfo = { percentage, tokens: total };
                             }
                         }
-                        // Check if the response ended with a question - show "Awaiting reply" instead
-                        const trimmedContent = finalContent?.trim() || content.trim();
-                        const endsWithQuestion = trimmedContent.endsWith('?');
-                        const statusText = endsWithQuestion ? 'Awaiting reply' : 'Ready for prompts';
-                        display.showStatusLine(statusText, enriched.elapsedMs, contextInfo);
+                        display.showStatusLine('Ready for prompts', enriched.elapsedMs, contextInfo);
                     }
                     else {
-                        // Non-final message = narrative text before tool calls
-                        // This content was already streamed in real-time via onStreamChunk
-                        // Don't display it again - just stop the spinner and continue
+                        // Non-final message = narrative text before tool calls (Claude Code style)
+                        // Stop spinner and show the narrative text directly
                         display.stopThinking();
-                        // Continue processing - content already shown via streaming
+                        display.showNarrative(content.trim());
+                        // The isProcessing flag already shows "⏳ Processing..." - no need for duplicate status
+                        this.pinnedChatBox.forceRender();
                         return;
                     }
                     const cleanup = this.handleContextTelemetry(metadata, enriched);
@@ -2999,12 +2800,6 @@ What's the next action?`;
                     this.pinnedChatBox.setStatusMessage('Retrying with reduced context...');
                     this.pinnedChatBox.forceRender();
                 },
-                onAutoContinue: (attempt, maxAttempts, message) => {
-                    // Update UI to show auto-continuation is happening
-                    display.showSystemMessage(`🔄 ${message} (${attempt}/${maxAttempts})`);
-                    this.pinnedChatBox.setStatusMessage('Auto-continuing...');
-                    this.pinnedChatBox.forceRender();
-                },
             });
             const historyToLoad = (this.pendingHistoryLoad && this.pendingHistoryLoad.length
                 ? this.pendingHistoryLoad
@@ -3389,6 +3184,27 @@ What's the next action?`;
         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()) ?? [];
+        if (!lines.length) {
+            return null;
+        }
+        // Remove common thought prefixes
+        const cleaned = lines[0]
+            .trim()
+            .replace(/^(Thinking|Analyzing|Considering|Looking at|Let me)[:.\s]+/i, '')
+            .replace(/^I (should|need to|will|am)[:.\s]+/i, '')
+            .trim();
+        if (!cleaned) {
+            return null;
+        }
+        // Truncate to reasonable length
+        const maxLength = 50;
+        return cleaned.length > maxLength
+            ? cleaned.slice(0, maxLength - 3) + '...'
+            : cleaned;
+    }
     splitThinkingResponse(content) {
         if (!content?.includes('<thinking') && !content?.includes('<response')) {
             return null;
@@ -3411,61 +3227,6 @@ What's the next action?`;
             response: responseBody ?? '',
         };
     }
-    /**
-     * Style streaming chunks in real-time (Claude Code style)
-     * Detects <thinking> blocks and applies cyan styling, hides XML tags
-     */
-    styleStreamingChunk(chunk) {
-        let result = '';
-        let remaining = chunk;
-        while (remaining.length > 0) {
-            if (this.isInsideThinkingBlock) {
-                // Look for </thinking> end tag
-                const endIdx = remaining.indexOf('</thinking>');
-                if (endIdx !== -1) {
-                    // End of thinking block found
-                    const thinkingContent = remaining.slice(0, endIdx);
-                    // Apply cyan thinking styling to content (hide the closing tag)
-                    result += theme.thinking.text(thinkingContent);
-                    remaining = remaining.slice(endIdx + '</thinking>'.length);
-                    this.isInsideThinkingBlock = false;
-                    // Add separator and newline after thinking block ends
-                    result += `\n${theme.thinking.border('─'.repeat(40))}\n`;
-                }
-                else {
-                    // Still inside thinking block, apply cyan styling to all remaining
-                    result += theme.thinking.text(remaining);
-                    remaining = '';
-                }
-            }
-            else {
-                // Look for <thinking> start tag
-                const startIdx = remaining.indexOf('<thinking>');
-                if (startIdx !== -1) {
-                    // Output text before thinking tag normally
-                    if (startIdx > 0) {
-                        result += remaining.slice(0, startIdx);
-                    }
-                    // Show thinking header with cyan styling (Claude Code style)
-                    result += `${theme.thinking.icon('💭')} ${theme.thinking.label('Thinking')}\n`;
-                    remaining = remaining.slice(startIdx + '<thinking>'.length);
-                    this.isInsideThinkingBlock = true;
-                }
-                else {
-                    // No thinking tag, output normally
-                    result += remaining;
-                    remaining = '';
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Reset thinking block state (call at start of new request)
-     */
-    resetThinkingState() {
-        this.isInsideThinkingBlock = false;
-    }
     persistSessionPreference() {
         saveModelPreference(this.profile, {
             provider: this.sessionState.provider,