erosolar-cli 1.7.78 → 1.7.80

package/dist/shell/interactiveShell.js

@@ -23,6 +23,7 @@ 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,
@@ -73,6 +74,7 @@ export class InteractiveShell {
     workspaceOptions;
     sessionState;
     isProcessing = false;
+    isInsideThinkingBlock = false;
     pendingInteraction = null;
     pendingSecretRetry = null;
     bufferedInputLines = [];
@@ -105,8 +107,12 @@ export class InteractiveShell {
     pendingHistoryLoad = null;
     cachedHistory = [];
     activeSessionId = null;
+    sessionStartTime = Date.now();
     activeSessionTitle = null;
     sessionResumeNotice = null;
+    lastAssistantResponse = null;
+    verificationRetryCount = 0;
+    maxVerificationRetries = 2;
     customCommands;
     customCommandMap;
     sessionRestoreConfig;
@@ -167,16 +173,11 @@ export class InteractiveShell {
             // Update persistent prompt status bar with file changes
             this.updatePersistentPromptFileChanges();
         });
-        // Set up tool status callback to update pinned chat box during tool execution
+        // Set up tool status callback to update streaming status line during tool execution
+        // Uses Claude Code style: single line at bottom that updates in-place
         this.uiAdapter.setToolStatusCallback((status) => {
-            if (status) {
-                this.pinnedChatBox.setStatusMessage(status);
-            }
-            else {
-                // Clear status but keep processing indicator if still processing
-                this.pinnedChatBox.setStatusMessage(null);
-            }
-            this.pinnedChatBox.forceRender();
+            // Update the streaming status line (Claude Code style)
+            display.updateStreamingStatus(status);
         });
         this.skillRepository = new SkillRepository({
             workingDir: this.workingDir,
@@ -188,9 +189,8 @@ export class InteractiveShell {
         this.rl = readline.createInterface({
             input,
             output,
-            // Use empty prompt since PinnedChatBox handles all prompt rendering
-            // This prevents duplicate '>' characters from appearing
-            prompt: '',
+            // Claude Code style: simple '> ' prompt
+            prompt: '> ',
             terminal: true,
             historySize: 100, // Enable native readline history
         });
@@ -281,7 +281,10 @@ 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;
@@ -472,9 +475,9 @@ export class InteractiveShell {
                 inputStream.off('keypress', this.keypressHandler);
                 this.keypressHandler = null;
             }
-            // Restore original stdin emit (cleanup from paste interception)
-            if (this.rawDataHandler) {
-                this.rawDataHandler(); // This restores the original emit function
+            // Remove raw data handler
+            if (inputStream && this.rawDataHandler) {
+                inputStream.off('data', this.rawDataHandler);
                 this.rawDataHandler = null;
             }
             // Clear any pending cleanup to prevent hanging
@@ -486,8 +489,6 @@ 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',
@@ -525,31 +526,21 @@ 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 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
-                }
+        // 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.
             }
-            // 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;
@@ -574,8 +565,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
-                this.pinnedChatBox.setInput(currentLine);
+                // Sync to pinned chat box for display only (include cursor position)
+                this.pinnedChatBox.setInput(currentLine, cursorPos);
                 if (this.composableMessage.hasContent()) {
                     this.composableMessage.setDraft(currentLine);
                     this.updateComposeStatusSummary();
@@ -834,9 +825,6 @@ 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;
@@ -854,16 +842,13 @@ 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
     }
     /**
@@ -1203,6 +1188,9 @@ 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}".`);
@@ -1319,7 +1307,6 @@ 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.');
@@ -1497,9 +1484,7 @@ export class InteractiveShell {
         }
         this.thinkingMode = value;
         saveSessionPreferences({ thinkingMode: this.thinkingMode });
-        if (this.rebuildAgent()) {
-            this.resetChatBoxAfterModelSwap();
-        }
+        this.rebuildAgent();
         const descriptions = {
             concise: 'Hides internal reasoning and responds directly.',
             balanced: 'Shows short thoughts only when helpful.',
@@ -1522,7 +1507,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();
@@ -1546,7 +1531,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}`);
         }
@@ -1556,6 +1541,211 @@ 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) {
@@ -2194,7 +2384,6 @@ export class InteractiveShell {
             display.showInfo(`Switched to ${preset.label}.`);
             this.refreshBannerSessionInfo();
             this.persistSessionPreference();
-            this.resetChatBoxAfterModelSwap();
         }
     }
     async handleSecretSelection(input) {
@@ -2255,9 +2444,7 @@ export class InteractiveShell {
             const deferred = this.pendingSecretRetry;
             this.pendingSecretRetry = null;
             if (pending.secret.providers.includes(this.sessionState.provider)) {
-                if (this.rebuildAgent()) {
-                    this.resetChatBoxAfterModelSwap();
-                }
+                this.rebuildAgent();
             }
             if (deferred) {
                 await deferred();
@@ -2285,25 +2472,20 @@ export class InteractiveShell {
             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); // Clear any previous status to avoid duplication
+        this.pinnedChatBox.setStatusMessage(null);
         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();
@@ -2325,17 +2507,15 @@ export class InteractiveShell {
             this.isProcessing = false;
             this.uiAdapter.endProcessing('Ready for prompts');
             this.setIdleStatus();
-            display.newLine();
+            // Clear the pinned processing box before showing final output
+            this.pinnedChatBox.clear();
+            this.pinnedChatBox.setProcessing(false);
+            this.pinnedChatBox.setStatusMessage(null);
             // 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
-            // Call ensureReadlineReady to resume stdin if paused and re-enable keypress
-            this.ensureReadlineReady();
+            // This is a safety net in case the caller doesn't call rl.prompt()
             this.rl.prompt();
             this.scheduleQueueProcessing();
             this.refreshQueueIndicators();
@@ -2551,13 +2731,13 @@ What's the next action?`;
             // 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
+            // Clear streaming status line (Claude Code style)
+            display.clearStreamingStatus();
+            // Update pinned chat box to show ready state
             this.pinnedChatBox.setProcessing(false);
             this.pinnedChatBox.setStatusMessage(null);
-            this.pinnedChatBox.forceRender();
             // CRITICAL: Ensure readline prompt is active for user input
-            // Call ensureReadlineReady to resume stdin if paused and re-enable keypress
-            this.ensureReadlineReady();
+            // This is a safety net in case the caller doesn't call rl.prompt()
             this.rl.prompt();
             this.scheduleQueueProcessing();
             this.refreshQueueIndicators();
@@ -2728,9 +2908,6 @@ What's the next action?`;
                 systemPrompt: this.buildSystemPrompt(),
                 reasoningEffort: this.sessionState.reasoningEffort,
             };
-            // Track streaming state for thinking vs content transitions
-            let wasThinking = false;
-            let thinkingHeaderShown = false;
             this.agent = this.runtimeSession.createAgent(selection, {
                 onStreamChunk: (chunk) => {
                     // Stream text directly to console for real-time display (Claude Code style)
@@ -2741,76 +2918,46 @@ What's the next action?`;
                             display.stopThinking(false);
                             process.stdout.write('\n'); // Newline after spinner
                         }
-                        // If transitioning from thinking to content, add separator
-                        if (wasThinking) {
-                            process.stdout.write('\n\n'); // Double newline to separate thinking from answer
-                            wasThinking = false;
-                            thinkingHeaderShown = false;
-                        }
-                        process.stdout.write(chunk);
-                    });
-                },
-                onThinkingChunk: (thinking) => {
-                    // Display thinking/reasoning content from models (DeepSeek-reasoner, GPT-5, Claude extended thinking)
-                    // Stream the thinking content in a muted style to show Chain of Thought
-                    display.safeWrite(() => {
-                        // Stop spinner on first thinking chunk to show streaming content
-                        if (display.isSpinnerActive()) {
-                            display.stopThinking(false);
-                            process.stdout.write('\n'); // Newline after spinner
-                        }
-                        // Show thinking header once
-                        if (!thinkingHeaderShown) {
-                            process.stdout.write(theme.ui.muted('💭 Thinking...\n'));
-                            thinkingHeaderShown = true;
-                        }
-                        // Stream thinking content in muted style (distinguish from final answer)
-                        process.stdout.write(theme.ui.muted(thinking));
-                        wasThinking = true;
+                        // Style thinking blocks (Claude Code style)
+                        const styledChunk = this.styleStreamingChunk(chunk);
+                        process.stdout.write(styledChunk);
                     });
                 },
                 onAssistantMessage: (content, metadata) => {
                     const enriched = this.buildDisplayMetadata(metadata);
                     // Update spinner based on message type
                     if (metadata.isFinal) {
-                        // 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);
-                            }
+                        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);
                         }
-                        // Show status line at end (Claude Code style: "• Context X% used • Ready for prompts (2s)")
+                        // 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)")
                         display.stopThinking();
-                        // Calculate context usage
-                        let contextInfo;
+                        // Calculate context usage and session time
+                        const sessionElapsedMs = Date.now() - this.sessionStartTime;
+                        let contextInfo = { sessionElapsedMs };
                         if (enriched.contextWindowTokens && metadata.usage) {
                             const total = this.totalTokens(metadata.usage);
                             if (total && total > 0) {
                                 const percentage = Math.round((total / enriched.contextWindowTokens) * 100);
-                                contextInfo = { percentage, tokens: total };
+                                contextInfo = { ...contextInfo, percentage, tokens: total };
                             }
                         }
                         display.showStatusLine('Ready for prompts', enriched.elapsedMs, contextInfo);
                     }
                     else {
-                        // Non-final message = narrative text before tool calls (Claude Code style)
-                        // Stop spinner and show the narrative text directly
+                        // 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
                         display.stopThinking();
-                        // 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();
+                        // Continue processing - content already shown via streaming
                         return;
                     }
                     const cleanup = this.handleContextTelemetry(metadata, enriched);
@@ -2881,18 +3028,6 @@ 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 = [
@@ -3254,27 +3389,6 @@ 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;
@@ -3297,6 +3411,61 @@ 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,
@@ -3351,7 +3520,6 @@ 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