erosolar-cli 1.7.80 → 1.7.82

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;
@@ -475,9 +472,9 @@ export class InteractiveShell {
                 inputStream.off('keypress', this.keypressHandler);
                 this.keypressHandler = null;
             }
-            // Remove raw data handler
-            if (inputStream && this.rawDataHandler) {
-                inputStream.off('data', this.rawDataHandler);
+            // 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
@@ -489,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',
@@ -526,21 +525,31 @@ export class InteractiveShell {
             // 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.
+        // 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;
         };
-        // 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;
@@ -565,8 +574,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();
@@ -825,6 +834,9 @@ export class InteractiveShell {
             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;
@@ -842,13 +854,16 @@ export class InteractiveShell {
         });
         // 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);
+        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.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
     }
     /**
@@ -1188,9 +1203,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}".`);
@@ -1307,6 +1319,7 @@ export class InteractiveShell {
         this.baseSystemPrompt = buildInteractiveSystemPrompt(profileConfig.systemPrompt, profileConfig.label, tools);
         if (this.rebuildAgent()) {
             display.showInfo(`Workspace snapshot refreshed (${this.describeWorkspaceOptions()}).`);
+            this.resetChatBoxAfterModelSwap();
         }
         else {
             display.showWarning('Workspace snapshot refreshed, but the agent failed to rebuild. Run /doctor for details.');
@@ -1484,7 +1497,9 @@ export class InteractiveShell {
         }
         this.thinkingMode = value;
         saveSessionPreferences({ thinkingMode: this.thinkingMode });
-        this.rebuildAgent();
+        if (this.rebuildAgent()) {
+            this.resetChatBoxAfterModelSwap();
+        }
         const descriptions = {
             concise: 'Hides internal reasoning and responds directly.',
             balanced: 'Shows short thoughts only when helpful.',
@@ -1507,7 +1522,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();
@@ -1531,7 +1546,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}`);
         }
@@ -1541,211 +1556,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) {
@@ -2384,6 +2194,7 @@ Think through this carefully, then:
             display.showInfo(`Switched to ${preset.label}.`);
             this.refreshBannerSessionInfo();
             this.persistSessionPreference();
+            this.resetChatBoxAfterModelSwap();
         }
     }
     async handleSecretSelection(input) {
@@ -2444,7 +2255,9 @@ Think through this carefully, then:
             const deferred = this.pendingSecretRetry;
             this.pendingSecretRetry = null;
             if (pending.secret.providers.includes(this.sessionState.provider)) {
-                this.rebuildAgent();
+                if (this.rebuildAgent()) {
+                    this.resetChatBoxAfterModelSwap();
+                }
             }
             if (deferred) {
                 await deferred();
@@ -2472,20 +2285,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();
@@ -2507,15 +2325,17 @@ 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);
+            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()
+            // Call ensureReadlineReady to resume stdin if paused and re-enable keypress
+            this.ensureReadlineReady();
             this.rl.prompt();
             this.scheduleQueueProcessing();
             this.refreshQueueIndicators();
@@ -2731,13 +2551,13 @@ 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()
+            // Call ensureReadlineReady to resume stdin if paused and re-enable keypress
+            this.ensureReadlineReady();
             this.rl.prompt();
             this.scheduleQueueProcessing();
             this.refreshQueueIndicators();
@@ -2918,46 +2738,51 @@ 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) => {
                     const enriched = this.buildDisplayMetadata(metadata);
                     // 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 (finalContent) {
-                            display.showAssistantMessage(finalContent, enriched);
+                        // Skip display if content was already streamed to avoid double-display
+                        if (!metadata.wasStreamed) {
+                            const parsed = this.splitThinkingResponse(content);
+                            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 };
                             }
                         }
                         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
+                        // Skip display if content was already streamed to avoid double-display
+                        if (!metadata.wasStreamed) {
+                            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);
@@ -3028,6 +2853,18 @@ What's the next action?`;
             return false;
         }
     }
+    /**
+     * Reset the pinned chat box to a fresh state after model/provider swap.
+     * Ensures the input box is properly visible and ready for input,
+     * just like on fresh startup.
+     */
+    resetChatBoxAfterModelSwap() {
+        this.pinnedChatBox.setStatusMessage(null);
+        this.pinnedChatBox.setProcessing(false);
+        this.pinnedChatBox.show();
+        this.pinnedChatBox.forceRender();
+        this.ensureReadlineReady();
+    }
     buildSystemPrompt() {
         const providerLabel = this.providerLabel(this.sessionState.provider);
         const lines = [
@@ -3389,6 +3226,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 +3269,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,
@@ -3520,6 +3323,7 @@ What's the next action?`;
             this.persistSessionPreference();
             this.refreshBannerSessionInfo();
             display.showInfo(`Switched from ${this.providerLabel(oldProvider)}/${oldModel} to ${match.label}/${defaultModel.id}`);
+            this.resetChatBoxAfterModelSwap();
         }
         else {
             // Revert on failure