erosolar-cli 1.7.396 → 1.7.398

package/dist/shell/interactiveShell.js

@@ -2,6 +2,7 @@ import { stdin as input, stdout as output, exit } from 'node:process';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createInterface } from 'node:readline/promises';
+import { AssistantBlockRenderer } from '../ui/assistantBlockRenderer.js';
 import { display } from '../ui/display.js';
 import { theme } from '../ui/theme.js';
 import { getContextWindowTokens } from '../core/contextWindow.js';
@@ -114,6 +115,8 @@ export class InteractiveShell {
     ui;
     uiAdapter;
     uiUpdates;
+    assistantBlocksEnabled;
+    assistantBlockRenderer = null;
     _fileChangeTracker = new FileChangeTracker(); // Reserved for future file tracking features
     alphaZeroMetrics; // Alpha Zero 2 performance tracking
     statusSubscription = null;
@@ -168,15 +171,19 @@ export class InteractiveShell {
     streamingHeartbeatStart = null;
     streamingHeartbeatFrame = 0;
     streamingStatusLabel = null;
+    streamingStatusBase = null;
+    streamingStatusDetail = null;
     lastStreamingElapsedSeconds = null; // Preserve final elapsed time
     statusLineState = null;
     statusMessageOverride = null;
+    latestThoughtSummary = null;
     hasShownThoughtProcess = false;
     promptRefreshTimer = null;
     launchPaletteShown = false;
     version;
     alternateScreenEnabled;
     inputInitialized = false;
+    assistantStreamBuffer = '';
     constructor(config) {
         this.profile = config.profile;
         this.profileLabel = config.profileLabel;
@@ -192,6 +199,7 @@ export class InteractiveShell {
         this.sessionRestoreConfig = config.sessionRestore ?? { mode: 'none' };
         this._enabledPlugins = config.enabledPlugins ?? [];
         this.version = config.version ?? '0.0.0';
+        this.assistantBlocksEnabled = Boolean(config.assistantBlocksEnabled);
         // Alternate screen disabled - use terminal-native mode for proper scrollback and text selection
         this.alternateScreenEnabled = false;
         this.initializeSessionHistory();
@@ -287,6 +295,12 @@ export class InteractiveShell {
             onToggleAlphaZero: () => this.toggleAlphaZeroMode('shortcut'),
             onClearContext: () => this.handleClearContext(),
         });
+        if (this.assistantBlocksEnabled) {
+            this.assistantBlockRenderer = new AssistantBlockRenderer({
+                write: (text) => this.terminalInput.streamContent(text),
+                updates: this.uiUpdates,
+            });
+        }
         // Initialize Alpha Zero 2 metrics tracking
         this.alphaZeroMetrics = new MetricsTracker(`${this.profile}-${Date.now()}`);
         this.setupStatusTracking();
@@ -538,7 +552,8 @@ export class InteractiveShell {
         // Keep adapter queue trimmed so hints stay accurate
         this.terminalInput.dequeue();
         this.followUpQueue.push({ type: 'request', text });
-        display.showInfo(`Queued: "${text}"`);
+        // Record the queued action in the pinned recent strip instead of the scroll log
+        this.terminalInput.recordRecentAction(`queued: ${text}`);
         this.refreshQueueIndicators();
         this.scheduleQueueProcessing();
         this.handleInputChange('');
@@ -599,15 +614,30 @@ export class InteractiveShell {
      * Execute a command immediately during streaming.
      */
     async executeImmediateCommand(text) {
-        // Pause streaming display briefly to show command output
-        display.showInfo(`Running command during stream: ${text}`);
-        await this.processSlashCommand(text);
+        const label = text.trim() || 'command';
+        // Keep the action visible in the pinned input area instead of the scroll log
+        this.terminalInput.recordRecentAction(label);
+        // Surface a lightweight inline status while the command runs
+        const previousOverride = this.statusMessageOverride;
+        this.statusMessageOverride = `Running ${label}`;
+        this.refreshStatusLine(true);
+        try {
+            await this.processSlashCommand(text);
+        }
+        finally {
+            this.statusMessageOverride = previousOverride;
+            this.refreshStatusLine(true);
+        }
     }
     /**
      * TerminalInputAdapter change handler
      */
     handleInputChange(text) {
+        const previous = this.currentInput;
         this.currentInput = text;
+        if (previous !== text) {
+            this.terminalInput.clearInlineCommandPanel();
+        }
         if (text.length > 0) {
             this.resetCtrlCSequence();
         }
@@ -1298,9 +1328,13 @@ export class InteractiveShell {
             alphaZeroHotkey: 'ctrl+shift+a',
             alphaZeroLabel: 'AlphaZero RL',
         });
+        this.refreshFeatureStatusDisplay();
         this.refreshStatusLine();
         this.renderPromptArea();
     }
+    refreshFeatureStatusDisplay() {
+        this.terminalInput.setFeatureStatus(this.buildFeatureStatusSnapshot());
+    }
     writeLocked(content) {
         if (!content) {
             return;
@@ -1308,6 +1342,29 @@ export class InteractiveShell {
         // Route through display stream so scroll regions and streaming locks stay in sync
         display.stream(content);
     }
+    resetAssistantStreamBuffer() {
+        this.assistantStreamBuffer = '';
+    }
+    appendAssistantStreamChunk(chunk) {
+        if (!this.assistantBlocksEnabled || !chunk) {
+            return;
+        }
+        this.assistantStreamBuffer += chunk;
+    }
+    consumeAssistantStreamBuffer(fallback) {
+        const buffered = this.assistantStreamBuffer;
+        this.assistantStreamBuffer = '';
+        if (buffered.trim()) {
+            return buffered;
+        }
+        return fallback ?? '';
+    }
+    renderAssistantBlock(type, content, metadata) {
+        if (!this.assistantBlockRenderer) {
+            return;
+        }
+        this.assistantBlockRenderer.renderBlock(type, content, metadata);
+    }
     isStreamingUiActive() {
         return this.streamingHeartbeatStart !== null;
     }
@@ -1356,19 +1413,23 @@ export class InteractiveShell {
         // Surface meta header (elapsed + context usage) above the divider
         // Use streaming elapsed time if available, otherwise fall back to status line state
         let elapsedSeconds = null;
-        if (this.streamingHeartbeatStart) {
+        const shouldShowElapsed = this.streamingHeartbeatStart !== null || this.isProcessing;
+        if (this.streamingHeartbeatStart && shouldShowElapsed) {
             // Actively streaming - compute live elapsed
             elapsedSeconds = Math.max(0, Math.floor((Date.now() - this.streamingHeartbeatStart) / 1000));
         }
-        else if (this.lastStreamingElapsedSeconds !== null) {
+        else if (shouldShowElapsed && this.lastStreamingElapsedSeconds !== null) {
             // Just finished streaming - use preserved final time
             elapsedSeconds = this.lastStreamingElapsedSeconds;
         }
-        else if (this.statusLineState) {
+        else if (shouldShowElapsed && this.statusLineState) {
             // Fallback to status line state elapsed
             elapsedSeconds = Math.max(0, Math.floor((Date.now() - this.statusLineState.startedAt) / 1000));
         }
-        const thinkingMs = display.isSpinnerActive() ? display.getThinkingElapsedMs() : null;
+        const hasThoughtSummary = !!this.latestThoughtSummary;
+        const thinkingMs = hasThoughtSummary && display.isSpinnerActive()
+            ? display.getThinkingElapsedMs()
+            : null;
         const tokensUsed = this.latestTokenUsage.used;
         const tokenLimit = this.latestTokenUsage.limit ?? this.activeContextWindowTokens;
         this.terminalInput.setMetaStatus({
@@ -1376,7 +1437,7 @@ export class InteractiveShell {
             tokensUsed,
             tokenLimit,
             thinkingMs,
-            thinkingHasContent: display.isSpinnerActive(),
+            thinkingHasContent: hasThoughtSummary,
         });
         // Keep model/provider visible in the controls bar
         this.terminalInput.setModelContext({
@@ -1483,14 +1544,17 @@ export class InteractiveShell {
         this.stopStreamingHeartbeat();
         // Enter global streaming mode - blocks all non-streaming UI output
         enterStreamingMode();
+        this.resetAssistantStreamBuffer();
+        this.streamingStatusBase = label;
+        this.streamingStatusDetail = null;
+        this.latestThoughtSummary = null;
+        this.lastStreamingElapsedSeconds = null;
         // Set up scroll region for streaming content
         this.terminalInput.enterStreamingScrollRegion();
         this.uiUpdates.setMode('streaming');
         this.streamingHeartbeatStart = Date.now();
         this.streamingHeartbeatFrame = 0;
-        const initialFrame = STREAMING_SPINNER_FRAMES[this.streamingHeartbeatFrame];
-        this.streamingStatusLabel = this.buildStreamingStatus(`${initialFrame} ${label}`, 0);
-        display.updateStreamingStatus(this.streamingStatusLabel);
+        this.rebuildStreamingStatusLabel();
         this.refreshStatusLine(true);
         // Periodically refresh the pinned input/status region while streaming so
         // elapsed time remains visible without interrupting the scroll region.
@@ -1500,14 +1564,9 @@ export class InteractiveShell {
             mode: ['streaming', 'processing'],
             coalesceKey: 'streaming:heartbeat',
             run: () => {
-                const elapsedSeconds = this.streamingHeartbeatStart
-                    ? Math.max(0, Math.floor((Date.now() - this.streamingHeartbeatStart) / 1000))
-                    : 0;
                 this.streamingHeartbeatFrame =
                     (this.streamingHeartbeatFrame + 1) % STREAMING_SPINNER_FRAMES.length;
-                const frame = STREAMING_SPINNER_FRAMES[this.streamingHeartbeatFrame];
-                this.streamingStatusLabel = this.buildStreamingStatus(`${frame} ${label}`, elapsedSeconds);
-                display.updateStreamingStatus(this.streamingStatusLabel);
+                this.rebuildStreamingStatusLabel();
                 // Update parallel agent display during streaming
                 const manager = getParallelAgentManager();
                 if (manager.isRunning()) {
@@ -1531,6 +1590,9 @@ export class InteractiveShell {
         this.streamingHeartbeatStart = null;
         this.streamingHeartbeatFrame = 0;
         this.streamingStatusLabel = null;
+        this.streamingStatusBase = null;
+        this.streamingStatusDetail = null;
+        this.latestThoughtSummary = null;
         // Clear streaming label specifically (keeps override and main status if set)
         this.terminalInput.setStreamingLabel(null);
         // Clear streaming status from display
@@ -1540,9 +1602,25 @@ export class InteractiveShell {
     }
     buildStreamingStatus(label, _elapsedSeconds) {
         // Model + elapsed time already live in the pinned meta header; keep the streaming
-        // status focused on the activity to avoid duplicate info.
+        // status focused on the activity and most recent thought summary.
         const prefix = theme.info('⏺');
-        return `${prefix} ${label}`.trim();
+        const parts = [label.trim()];
+        if (this.streamingStatusDetail) {
+            const detail = this.streamingStatusDetail.length > 52
+                ? `${this.streamingStatusDetail.slice(0, 51)}…`
+                : this.streamingStatusDetail;
+            parts.push(theme.ui.muted(detail));
+        }
+        return `${prefix} ${parts.join(' · ')}`.trim();
+    }
+    rebuildStreamingStatusLabel() {
+        if (this.streamingHeartbeatStart === null) {
+            return;
+        }
+        const frame = STREAMING_SPINNER_FRAMES[this.streamingHeartbeatFrame];
+        const base = this.streamingStatusBase ?? 'Streaming';
+        this.streamingStatusLabel = this.buildStreamingStatus(`${frame} ${base}`);
+        display.updateStreamingStatus(this.streamingStatusLabel);
     }
     formatElapsedShort(seconds) {
         if (seconds < 60) {
@@ -1886,170 +1964,197 @@ export class InteractiveShell {
             this.renderPromptArea();
             return;
         }
-        switch (command) {
-            case '/help':
-            case '/?':
-                this.showHelp();
-                break;
-            case '/features':
-                this.showFeaturesMenu(input);
-                break;
-            case '/learn':
-                this.showLearningStatus(input);
-                break;
-            case '/improve':
-                void this.handleImprovementCommand(input);
-                break;
-            case '/model':
-                this.showModelMenu();
-                break;
-            case '/exit':
-            case '/quit':
-            case '/q':
-                this.shutdown();
-                break;
-            case '/secrets':
-                this.showSecretsMenu();
-                break;
-            case '/tools':
-                this.showToolsMenu();
-                break;
-            case '/mcp':
-                await this.showMcpStatus();
-                break;
-            case '/doctor':
-                this.runDoctor();
-                break;
-            case '/checks':
-                await this.runRepoChecksCommand();
-                break;
-            case '/context':
-                await this.refreshWorkspaceContextCommand(input);
-                break;
-            case '/agents':
-                this.showAgentsMenu();
-                break;
-            case '/sessions':
-                await this.handleSessionCommand(input);
-                break;
-            case '/skills':
-                await this.handleSkillsCommand(input);
-                break;
-            case '/thinking':
-                this.handleThinkingCommand(input);
-                break;
-            case '/autocontinue':
-                this.handleAutoContinueCommand(input);
-                break;
-            case '/alphazero':
-                this.handleAlphaZeroCommand(input);
-                break;
-            case '/shortcuts':
-            case '/keys':
-                this.handleShortcutsCommand();
-                break;
-            case '/changes':
-            case '/summary':
-                this.showFileChangeSummary();
-                break;
-            case '/metrics':
-            case '/stats':
-            case '/perf':
-                this.showAlphaZeroMetrics();
-                break;
-            case '/suggestions':
-            case '/improve':
-                this.showImprovementSuggestions();
-                break;
-            case '/plugins':
-                this.showPluginStatus();
-                break;
-            case '/evolve':
-                void this.handleEvolveCommand(input);
-                break;
-            case '/modular':
-            case '/a0':
-                void this.handleModularCommand(input);
-                break;
-            case '/offsec':
-                void this.handleOffsecCommand(input);
-                break;
-            case '/test':
-            case '/tests':
-                void this.handleTestCommand(input);
-                break;
-            case '/provider':
-                await this.handleProviderCommand(input);
-                break;
-            case '/providers':
-                this.showConfiguredProviders();
-                break;
-            case '/local':
-                await this.handleLocalCommand(input);
-                break;
-            case '/discover':
-                await this.discoverModelsCommand();
-                break;
-            // Claude Code style commands
-            case '/rewind':
-                await this.handleRewindCommand(input);
-                break;
-            case '/memory':
-                this.handleMemoryCommand(input);
-                break;
-            case '/vim':
-                this.handleVimCommand();
-                break;
-            case '/output-style':
-                this.handleOutputStyleCommand(input);
-                break;
-            case '/cost':
-                this.handleCostCommand();
-                break;
-            case '/usage':
-                this.handleUsageCommand();
-                break;
-            case '/update':
-                await this.handleUpdateCommand();
-                break;
-            case '/clear':
-                this.handleClearCommand();
-                break;
-            case '/resume':
-                await this.handleResumeCommand(input);
-                break;
-            case '/export':
-                this.handleExportCommand(input);
-                break;
-            case '/review':
-                await this.handleReviewCommand();
-                break;
-            case '/security-review':
-                await this.handleSecurityReviewCommand();
-                break;
-            case '/bug':
-                this.handleBugCommand();
-                break;
-            case '/terminal-setup':
-                this.handleTerminalSetupCommand();
-                break;
-            case '/permissions':
-                this.handlePermissionsCommand();
-                break;
-            case '/init':
-                this.handleInitCommand();
-                break;
-            case '/compact':
-                await this.handleCompactCommand();
-                break;
-            default:
-                if (!(await this.tryCustomSlashCommand(command, input))) {
-                    display.showWarning(`Unknown command "${command}".`);
-                }
-                break;
+        // Keep the slash action visible in the pinned recent strip
+        this.terminalInput.recordRecentAction(command);
+        const runCommand = async () => {
+            switch (command) {
+                case '/help':
+                case '/?':
+                    this.showHelp();
+                    break;
+                case '/features':
+                    this.showFeaturesMenu(input);
+                    break;
+                case '/learn':
+                    this.showLearningStatus(input);
+                    break;
+                case '/improve':
+                    void this.handleImprovementCommand(input);
+                    break;
+                case '/model':
+                    this.showModelMenu();
+                    break;
+                case '/exit':
+                case '/quit':
+                case '/q':
+                    this.shutdown();
+                    break;
+                case '/secrets':
+                    this.showSecretsMenu();
+                    break;
+                case '/tools':
+                    this.showToolsMenu();
+                    break;
+                case '/mcp':
+                    await this.showMcpStatus();
+                    break;
+                case '/doctor':
+                    this.runDoctor();
+                    break;
+                case '/checks':
+                    await this.runRepoChecksCommand();
+                    break;
+                case '/context':
+                    await this.refreshWorkspaceContextCommand(input);
+                    break;
+                case '/agents':
+                    this.showAgentsMenu();
+                    break;
+                case '/sessions':
+                    await this.handleSessionCommand(input);
+                    break;
+                case '/skills':
+                    await this.handleSkillsCommand(input);
+                    break;
+                case '/thinking':
+                    this.handleThinkingCommand(input);
+                    break;
+                case '/autocontinue':
+                    this.handleAutoContinueCommand(input);
+                    break;
+                case '/alphazero':
+                    this.handleAlphaZeroCommand(input);
+                    break;
+                case '/shortcuts':
+                case '/keys':
+                    this.handleShortcutsCommand();
+                    break;
+                case '/changes':
+                case '/summary':
+                    this.showFileChangeSummary();
+                    break;
+                case '/metrics':
+                case '/stats':
+                case '/perf':
+                    this.showAlphaZeroMetrics();
+                    break;
+                case '/suggestions':
+                case '/improve':
+                    this.showImprovementSuggestions();
+                    break;
+                case '/plugins':
+                    this.showPluginStatus();
+                    break;
+                case '/evolve':
+                    void this.handleEvolveCommand(input);
+                    break;
+                case '/modular':
+                case '/a0':
+                    void this.handleModularCommand(input);
+                    break;
+                case '/offsec':
+                    void this.handleOffsecCommand(input);
+                    break;
+                case '/test':
+                case '/tests':
+                    void this.handleTestCommand(input);
+                    break;
+                case '/provider':
+                    await this.handleProviderCommand(input);
+                    break;
+                case '/providers':
+                    this.showConfiguredProviders();
+                    break;
+                case '/local':
+                    await this.handleLocalCommand(input);
+                    break;
+                case '/discover':
+                    await this.discoverModelsCommand();
+                    break;
+                // Claude Code style commands
+                case '/rewind':
+                    await this.handleRewindCommand(input);
+                    break;
+                case '/memory':
+                    this.handleMemoryCommand(input);
+                    break;
+                case '/vim':
+                    this.handleVimCommand();
+                    break;
+                case '/output-style':
+                    this.handleOutputStyleCommand(input);
+                    break;
+                case '/cost':
+                    this.handleCostCommand();
+                    break;
+                case '/usage':
+                    this.handleUsageCommand();
+                    break;
+                case '/update':
+                    await this.handleUpdateCommand();
+                    break;
+                case '/clear':
+                    this.handleClearCommand();
+                    break;
+                case '/resume':
+                    await this.handleResumeCommand(input);
+                    break;
+                case '/export':
+                    this.handleExportCommand(input);
+                    break;
+                case '/review':
+                    await this.handleReviewCommand();
+                    break;
+                case '/security-review':
+                    await this.handleSecurityReviewCommand();
+                    break;
+                case '/bug':
+                    this.handleBugCommand();
+                    break;
+                case '/terminal-setup':
+                    this.handleTerminalSetupCommand();
+                    break;
+                case '/permissions':
+                    this.handlePermissionsCommand();
+                    break;
+                case '/init':
+                    this.handleInitCommand();
+                    break;
+                case '/compact':
+                    await this.handleCompactCommand();
+                    break;
+                default:
+                    if (!(await this.tryCustomSlashCommand(command, input))) {
+                        display.showWarning(`Unknown command "${command}".`);
+                    }
+                    break;
+            }
+        };
+        let capturedOutput = '';
+        try {
+            const { output: outputBuffer } = await display.captureOutput(runCommand);
+            capturedOutput = outputBuffer;
         }
+        catch (error) {
+            capturedOutput = error?.capturedOutput ?? capturedOutput;
+            display.showError(error instanceof Error ? error.message : String(error), error);
+        }
+        const panelContent = this.buildInlineCommandPanel(command, capturedOutput);
+        this.terminalInput.setInlineCommandPanel(panelContent);
         this.renderPromptArea();
     }
+    buildInlineCommandPanel(command, output) {
+        const normalized = output ? output.replace(/\r\n/g, '\n').replace(/\r/g, '\n').trimEnd() : '';
+        if (!normalized) {
+            return null;
+        }
+        const header = theme.ui.muted(command);
+        const body = normalized.split('\n');
+        if (body.length === 1) {
+            return [`${header} ${body[0] ?? ''}`.trimEnd()];
+        }
+        return [header, ...body];
+    }
     async tryCustomSlashCommand(command, fullInput) {
         const custom = this.customCommandMap.get(command);
         if (!custom) {
@@ -2476,6 +2581,7 @@ export class InteractiveShell {
                 const updated = toggleFeatureFlag(matchedKey, newValue);
                 const status = updated[matchedKey] ? theme.success('enabled') : theme.ui.muted('disabled');
                 display.showInfo(`Feature "${FEATURE_FLAG_INFO[matchedKey].label}" is now ${status}.`);
+                this.refreshFeatureStatusDisplay();
                 display.showInfo('Changes will take effect on next launch or after /features refresh.');
                 return;
             }
@@ -2488,6 +2594,7 @@ export class InteractiveShell {
                 }
                 saveFeatureFlags(updated);
                 display.showInfo(`All features ${newValue ? theme.success('enabled') : theme.ui.muted('disabled')}.`);
+                this.refreshFeatureStatusDisplay();
                 return;
             }
             else {
@@ -3660,9 +3767,7 @@ export class InteractiveShell {
         }
         display.showInfo(`Deleted session "${summary.title}".`);
         if (this.activeSessionId === summary.id) {
-            this.activeSessionId = null;
-            this.activeSessionTitle = null;
-            saveSessionPreferences({ lastSessionId: null });
+            this.updateActiveSession(null, true);
         }
     }
     newSessionCommand(title) {
@@ -3682,6 +3787,7 @@ export class InteractiveShell {
         clearAutosaveSnapshot(this.profile);
         display.showInfo('Started a new empty session.');
         this.refreshContextGauge();
+        this.refreshFeatureStatusDisplay();
     }
     toggleAutosaveCommand(value) {
         if (!value) {
@@ -3999,6 +4105,7 @@ export class InteractiveShell {
         if (remember) {
             saveSessionPreferences({ lastSessionId: summary?.id ?? null });
         }
+        this.refreshFeatureStatusDisplay();
     }
     resolveSessionBySelector(selector) {
         const sessions = listSessions(this.profile);
@@ -5670,20 +5777,38 @@ What's the next action?`;
             };
             this.agent = this.runtimeSession.createAgent(selection, {
                 onStreamChunk: (chunk) => {
+                    if (this.assistantBlocksEnabled) {
+                        this.appendAssistantStreamChunk(chunk);
+                        return;
+                    }
                     // Stream output using clean streamContent() - chat box floats below
                     this.terminalInput.streamContent(chunk);
                 },
                 onStreamFallback: (info) => this.handleStreamingFallback(info),
                 onAssistantMessage: (content, metadata) => {
                     const enriched = this.buildDisplayMetadata(metadata);
-                    const parsed = this.splitThinkingResponse(content);
+                    const usingBlocks = this.assistantBlocksEnabled && this.assistantBlockRenderer !== null;
+                    const sourceContent = usingBlocks && metadata.wasStreamed ? this.consumeAssistantStreamBuffer(content) : content;
+                    const parsed = this.splitThinkingResponse(sourceContent);
                     const thinking = parsed?.thinking ?? null;
-                    const responseContent = parsed ? parsed.response?.trim() ?? '' : content.trim();
-                    // Update spinner based on message type
+                    const shouldRenderThoughtBlock = Boolean(thinking) && !this.hasShownThoughtProcess;
+                    const responseContent = parsed ? parsed.response?.trim() ?? '' : sourceContent.trim();
+                    const narrativeContent = parsed?.response ?? sourceContent;
                     if (metadata.isFinal) {
-                        this.presentThoughtProcess(thinking, enriched, { wasStreamed: metadata.wasStreamed });
-                        // Skip display if content was already streamed to avoid double-display
-                        if (!metadata.wasStreamed && responseContent) {
+                        if (thinking) {
+                            // Update status + summary, but skip the legacy UI output when blocks are enabled
+                            this.presentThoughtProcess(thinking, enriched, {
+                                wasStreamed: usingBlocks || metadata.wasStreamed,
+                            });
+                            if (usingBlocks && shouldRenderThoughtBlock) {
+                                this.renderAssistantBlock('thought', thinking, enriched);
+                            }
+                        }
+                        if (usingBlocks) {
+                            const body = responseContent || sourceContent;
+                            this.renderAssistantBlock('response', body, enriched);
+                        }
+                        else if (!metadata.wasStreamed && responseContent) {
                             display.showAssistantMessage(responseContent, enriched);
                         }
                         // Status shown in mode controls bar - no separate status line needed
@@ -5702,13 +5827,18 @@ What's the next action?`;
                     }
                     else {
                         if (thinking) {
-                            this.presentThoughtProcess(thinking, enriched, { wasStreamed: metadata.wasStreamed });
+                            this.presentThoughtProcess(thinking, enriched, {
+                                wasStreamed: usingBlocks || metadata.wasStreamed,
+                            });
                         }
                         // Non-final message = narrative text before tool calls (Claude Code style)
                         // Stop spinner and show the narrative text directly
                         display.stopThinking();
-                        // Skip display if content was already streamed to avoid double-display
-                        if (!metadata.wasStreamed) {
+                        if (usingBlocks) {
+                            const body = metadata.wasStreamed ? responseContent || sourceContent : narrativeContent;
+                            this.renderAssistantBlock('thought', body, enriched);
+                        }
+                        else if (!metadata.wasStreamed) {
                             const narrative = parsed?.response ?? content;
                             display.showNarrative(narrative.trim());
                         }
@@ -5900,6 +6030,11 @@ What's the next action?`;
         const summary = this.extractThoughtSummary(thinking);
         if (summary) {
             display.updateThinking(`💭 ${summary}`);
+            this.latestThoughtSummary = summary;
+            this.streamingStatusDetail = summary;
+            this.terminalInput.recordRecentAction(`💭 ${summary}`);
+            this.rebuildStreamingStatusLabel();
+            this.refreshStatusLine(true);
         }
         if (!options?.wasStreamed) {
             display.showAssistantMessage(thinking, { ...metadata, isFinal: false });
@@ -6281,6 +6416,7 @@ What's the next action?`;
         const detail = detailText ? ` Error: ${detailText}` : '';
         const reason = info.reason ? ` (${info.reason.replace(/-/g, ' ')})` : '';
         const partialNote = info.partialResponse ? ' Received partial stream before failure.' : '';
+        this.resetAssistantStreamBuffer();
         display.showWarning(`Streaming failed${reason}, retrying without streaming.${detail}${partialNote}`);
         this.startStreamingHeartbeat('Fallback in progress');
         this.requestPromptRefresh(true);
@@ -6360,10 +6496,6 @@ What's the next action?`;
     buildBanner() {
         const terminalWidth = output.columns ?? 100;
         const width = Math.min(terminalWidth - 4, 110);
-        // Collect tool categories for display
-        const toolCategories = this.collectToolCategories();
-        // Load feature flags for banner display
-        const featureFlags = loadFeatureFlags();
         return renderSessionFrame({
             profileLabel: this.profileLabel,
             profileName: this.profile,
@@ -6372,19 +6504,6 @@ What's the next action?`;
             workspace: this.workingDir,
             version: this.version,
             width,
-            features: {
-                verification: this.verificationEnabled,
-                autoContinue: this.autoContinueEnabled,
-                thinkingMode: this.thinkingMode,
-                plugins: this._enabledPlugins,
-                tools: toolCategories,
-                sessionId: this.activeSessionId ?? undefined,
-                // Include feature flags
-                alphaZeroDual: featureFlags.alphaZeroDual,
-                autoCompact: featureFlags.autoCompact,
-                mcpEnabled: featureFlags.mcpEnabled,
-                metrics: featureFlags.metrics,
-            },
         });
     }
     /**
@@ -6415,6 +6534,21 @@ What's the next action?`;
         }
         return categories;
     }
+    buildFeatureStatusSnapshot() {
+        const featureFlags = loadFeatureFlags();
+        const toolCategories = this.collectToolCategories();
+        const toolCount = toolCategories.reduce((sum, cat) => sum + cat.count, 0);
+        const pluginCount = this._enabledPlugins.length;
+        return {
+            pluginCount: pluginCount > 0 ? pluginCount : undefined,
+            toolCount: toolCount > 0 ? toolCount : undefined,
+            sessionId: this.activeSessionId,
+            mcpEnabled: featureFlags.mcpEnabled,
+            metricsEnabled: featureFlags.metrics,
+            autoCompact: featureFlags.autoCompact,
+            dualMode: featureFlags.alphaZeroDual,
+        };
+    }
     /**
      * Extract category from tool name.
      */