erosolar-cli 1.7.395 → 1.7.397

package/dist/shell/interactiveShell.js

@@ -1,10 +1,12 @@
 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';
-import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue, listSecretDefinitions, maskSecret, setSecretValue, } from '../core/secretStore.js';
+import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue, listSecretDefinitions, MissingSecretError, maskSecret, setSecretValue, } from '../core/secretStore.js';
 import { saveActiveProfilePreference, saveModelPreference, loadToolSettings, saveToolSettings, clearToolSettings, clearActiveProfilePreference, loadSessionPreferences, saveSessionPreferences, loadFeatureFlags, saveFeatureFlags, toggleFeatureFlag, FEATURE_FLAG_INFO, } from '../core/preferences.js';
 import { getLearningSummary, getRecentLearning, commitLearning, exportAllLearning, getLearningDir, } from '../core/learningPersistence.js';
 import { buildEnabledToolSet, evaluateToolPermissions, getToolToggleOptions, } from '../capabilities/toolRegistry.js';
@@ -113,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;
@@ -151,6 +155,13 @@ export class InteractiveShell {
     lastUserQuery = '';
     lastFailure = null;
     lastAutoTestRun = null;
+    runIdCounter = 0;
+    lastRunLog = null;
+    lastReflectedRunId = null;
+    skipNextAutoReflection = false;
+    alphaZeroAutoImproveActive = false;
+    alphaZeroAutoImproveIterations = 0;
+    alphaZeroAutoImproveMaxIterations = 6;
     // Auto-build tracking
     autoBuildInFlight = false;
     lastAutoBuildRun = null;
@@ -160,14 +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;
@@ -183,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();
@@ -278,12 +295,16 @@ 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();
         this.refreshContextGauge();
-        // Start terminal input (sets up handlers)
-        this.terminalInput.start();
         // Allow planning tools (e.g., ProposePlan) to open the interactive approval UI just like Codex CLI
         this.registerPlanApprovalBridge();
         // Capture display output into the scrollback/chat log so system messages
@@ -301,9 +322,6 @@ export class InteractiveShell {
         // Stream banner first - this sets up scroll region dynamically
         const banner = this.buildBanner();
         this.terminalInput.streamContent(banner + '\n\n');
-        // Render chat box after banner is streamed
-        this.refreshControlBar();
-        this.renderPromptArea(true);
         this.rebuildAgent();
         this.setupHandlers();
         this.refreshBannerSessionInfo();
@@ -395,10 +413,8 @@ export class InteractiveShell {
         this.sessionResumeNotice = null;
     }
     async start(initialPrompt) {
-        // Check for updates in background (non-blocking)
-        if (this.version) {
-            void maybeOfferCliUpdate(this.version);
-        }
+        await this.runStartupUpdatePrompt();
+        this.ensureInputInitialized();
         if (initialPrompt) {
             await this.processInputBlock(initialPrompt);
             return;
@@ -407,6 +423,79 @@ export class InteractiveShell {
         // Ensure the terminal input is visible
         this.renderPromptArea();
     }
+    async runStartupUpdatePrompt() {
+        if (this.version) {
+            try {
+                await maybeOfferCliUpdate(this.version, {
+                    prompt: (context) => this.promptForCliUpdate(context),
+                });
+            }
+            catch {
+                // Ignore update check failures at startup
+            }
+        }
+        this.showStartupSecretGuidance();
+    }
+    ensureInputInitialized() {
+        if (this.inputInitialized) {
+            return;
+        }
+        this.terminalInput.start();
+        this.refreshControlBar();
+        this.renderPromptArea(true);
+        this.inputInitialized = true;
+    }
+    async promptForCliUpdate(context) {
+        if (!input.isTTY || !output.isTTY) {
+            return true;
+        }
+        const lines = [
+            theme.gradient.primary('⬆️  Update available'),
+            `${theme.ui.muted('Current')}: ${theme.info(context.currentVersion)}`,
+            `${theme.ui.muted('Latest')}: ${theme.success(context.latestVersion)}`,
+            '',
+            `${theme.primary('>')} Update now (recommended)`,
+            `${theme.ui.muted('  Skip for now')}`,
+            '',
+            'Press Enter to accept the highlighted option, or type Y/n (1/2).',
+        ];
+        display.showSystemMessage(lines.join('\n'));
+        const prompt = createInterface({ input, output });
+        try {
+            const raw = (await prompt.question('> ')).trim().toLowerCase();
+            if (!raw || raw === 'y' || raw === 'yes' || raw === '1' || raw === 'update') {
+                return true;
+            }
+            if (raw === 'n' || raw === 'no' || raw === '2' || raw === 'skip') {
+                return false;
+            }
+            return false;
+        }
+        finally {
+            prompt.close();
+        }
+    }
+    showStartupSecretGuidance() {
+        const definitions = listSecretDefinitions();
+        const providerSecret = definitions.find((definition) => definition.providers.includes(this.sessionState.provider));
+        const missingProviderKey = providerSecret ? !getSecretValue(providerSecret.id) : false;
+        const hasSearchKey = Boolean(getSecretValue('TAVILY_API_KEY')) ||
+            Boolean(getSecretValue('BRAVE_SEARCH_API_KEY')) ||
+            Boolean(getSecretValue('SERPAPI_API_KEY'));
+        if (!missingProviderKey && hasSearchKey) {
+            return;
+        }
+        const lines = [];
+        lines.push(theme.gradient.primary('Quick setup needed:'));
+        if (missingProviderKey && providerSecret) {
+            lines.push(`${theme.primary('•')} Set ${providerSecret.label} to use ${this.providerLabel(this.sessionState.provider)}.`);
+        }
+        if (!hasSearchKey) {
+            lines.push(`${theme.primary('•')} Add a web search API key (Tavily recommended) for web tools.`);
+        }
+        lines.push(theme.ui.muted('Run /secrets to configure keys now. Stored values override env vars.'));
+        display.showSystemMessage(lines.join('\n'));
+    }
     showLaunchCommandPalette() {
         // Disabled: Quick commands palette takes up too much space
         // Users can type /help to see available commands
@@ -463,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('');
@@ -524,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();
         }
@@ -1094,12 +1199,13 @@ export class InteractiveShell {
     setupHandlers() {
         // Handle terminal resize
         output.on('resize', () => {
+            if (!this.inputInitialized) {
+                return;
+            }
             this.terminalInput.resetContentPosition();
             this.terminalInput.handleResize();
             this.terminalInput.forceRender();
         });
-        // Show initial input UI
-        this.renderPromptArea();
     }
     /**
      * Set up command autocomplete with all available slash commands.
@@ -1222,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;
@@ -1232,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;
     }
@@ -1280,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({
@@ -1300,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({
@@ -1407,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.
@@ -1424,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()) {
@@ -1455,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
@@ -1464,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) {
@@ -1509,7 +1663,14 @@ export class InteractiveShell {
             this.refreshQueueIndicators();
             return;
         }
+        if (this.apiKeyGateActive) {
+            this.refreshQueueIndicators();
+            return;
+        }
         queueMicrotask(() => {
+            if (this.apiKeyGateActive) {
+                return;
+            }
             void this.processQueuedActions();
         });
     }
@@ -1517,12 +1678,12 @@ export class InteractiveShell {
      * Process queued follow-up actions.
      */
     async processQueuedActions() {
-        if (this.isDrainingQueue || this.isProcessing || !this.followUpQueue.length) {
+        if (this.apiKeyGateActive || this.isDrainingQueue || this.isProcessing || !this.followUpQueue.length) {
             return;
         }
         this.isDrainingQueue = true;
         try {
-            while (!this.isProcessing && this.followUpQueue.length) {
+            while (!this.isProcessing && !this.apiKeyGateActive && this.followUpQueue.length) {
                 const next = this.followUpQueue.shift();
                 const remaining = this.followUpQueue.length;
                 const label = next.type === 'continuous' ? 'continuous command' : 'follow-up';
@@ -1669,6 +1830,99 @@ export class InteractiveShell {
         ];
         return `${playbook.join('\n')}\n\nPrimary user request:\n${request.trim()}`;
     }
+    buildRunLogExcerpt(startIndex) {
+        const buffer = this.terminalInput.getScrollbackBuffer();
+        const sinceStart = buffer.slice(Math.max(0, startIndex));
+        const excerpt = sinceStart.slice(-200); // Cap prompt size
+        return excerpt.join('\n').trim();
+    }
+    buildRunLogEntry(request, response, scrollbackStartIndex, meta) {
+        return {
+            id: ++this.runIdCounter,
+            request,
+            response,
+            timestamp: new Date().toISOString(),
+            alphaZero: meta.alphaZeroEngaged,
+            difficult: meta.alphaZeroDifficult,
+            failureType: meta.failureType,
+            outputExcerpt: this.buildRunLogExcerpt(scrollbackStartIndex),
+        };
+    }
+    buildAlphaZeroReflectionPrompt(runLog, options) {
+        const lines = [];
+        lines.push('AlphaZero Post-Run Self-Reflection (erosolar-cli)');
+        lines.push(`Timestamp: ${runLog.timestamp}`);
+        lines.push(`AlphaZero: ${runLog.alphaZero ? 'on' : 'off'}${runLog.difficult ? ' | difficult' : ''}${runLog.failureType ? ` | signal: ${runLog.failureType}` : ''}`);
+        lines.push('');
+        lines.push('User request:');
+        lines.push(runLog.request);
+        lines.push('');
+        lines.push('Previous run log excerpt:');
+        lines.push(runLog.outputExcerpt || '[empty]');
+        lines.push('');
+        lines.push('Instructions:');
+        lines.push('- Reflect on the log to spot erosolar-cli bugs, UX issues, or reliability gaps.');
+        lines.push('- Propose and apply targeted fixes in this repository only (no user workspace edits).');
+        lines.push('- Prefer small, test-backed changes; run any relevant checks you invoke.');
+        lines.push('- Keep notes concise and finish with applied changes plus follow-ups.');
+        if (options.autoChain) {
+            lines.push('- Continue iterating automatically while meaningful improvements remain.');
+            lines.push('- When no further improvements are possible, reply with NO_MORE_IMPROVEMENTS on its own line.');
+        }
+        return lines.join('\n');
+    }
+    maybeQueueAlphaZeroSelfReflection(runLog, alphaZeroEngaged, allowAutoChain) {
+        if (!alphaZeroEngaged) {
+            return;
+        }
+        if (!isErosolarRepo(this.workingDir)) {
+            return;
+        }
+        if (!runLog.outputExcerpt) {
+            return;
+        }
+        if (this.lastReflectedRunId === runLog.id) {
+            return;
+        }
+        if (allowAutoChain) {
+            if (!this.autoContinueEnabled) {
+                return;
+            }
+            if (this.alphaZeroAutoImproveIterations >= this.alphaZeroAutoImproveMaxIterations) {
+                display.showInfo('AlphaZero auto-improvement limit reached; stopping.');
+                this.alphaZeroAutoImproveActive = false;
+                this.alphaZeroAutoImproveIterations = 0;
+                return;
+            }
+            if (!this.alphaZeroAutoImproveActive) {
+                this.alphaZeroAutoImproveIterations = 0;
+            }
+            this.alphaZeroAutoImproveActive = true;
+            this.alphaZeroAutoImproveIterations++;
+        }
+        const prompt = this.buildAlphaZeroReflectionPrompt(runLog, { autoChain: allowAutoChain });
+        this.lastReflectedRunId = runLog.id;
+        this.skipNextAutoReflection = !allowAutoChain; // Prevent reflection-on-reflection unless auto-chaining
+        this.enqueueFollowUpAction({ type: 'request', text: prompt });
+        display.showInfo(allowAutoChain
+            ? 'Auto AlphaZero self-improvement queued (auto-continue enabled).'
+            : 'Queued AlphaZero self-reflection to improve erosolar-cli from the latest run log.');
+    }
+    shouldStopAlphaZeroAutoImprove(responseText, allowAutoChain) {
+        if (!this.alphaZeroAutoImproveActive) {
+            return false;
+        }
+        if (!allowAutoChain) {
+            return true;
+        }
+        if (!responseText) {
+            return false;
+        }
+        const normalized = responseText.toLowerCase();
+        return (normalized.includes('no_more_improvements') ||
+            normalized.includes('no more improvements') ||
+            normalized.includes('stop_auto_improve'));
+    }
     async handlePendingInteraction(input) {
         if (!this.pendingInteraction) {
             return false;
@@ -1710,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) {
@@ -2300,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;
             }
@@ -2312,6 +2594,7 @@ export class InteractiveShell {
                 }
                 saveFeatureFlags(updated);
                 display.showInfo(`All features ${newValue ? theme.success('enabled') : theme.ui.muted('disabled')}.`);
+                this.refreshFeatureStatusDisplay();
                 return;
             }
             else {
@@ -3484,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) {
@@ -3506,6 +3787,7 @@ export class InteractiveShell {
         clearAutosaveSnapshot(this.profile);
         display.showInfo('Started a new empty session.');
         this.refreshContextGauge();
+        this.refreshFeatureStatusDisplay();
     }
     toggleAutosaveCommand(value) {
         if (!value) {
@@ -3823,6 +4105,7 @@ export class InteractiveShell {
         if (remember) {
             saveSessionPreferences({ lastSessionId: summary?.id ?? null });
         }
+        this.refreshFeatureStatusDisplay();
     }
     resolveSessionBySelector(selector) {
         const sessions = listSessions(this.profile);
@@ -4689,8 +4972,10 @@ export class InteractiveShell {
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             this.pendingSecretRetry = null;
+            this.apiKeyGateActive = false;
             display.showInfo('Secret unchanged.');
             this.renderPromptArea();
+            this.scheduleQueueProcessing();
             return;
         }
         try {
@@ -4699,6 +4984,7 @@ export class InteractiveShell {
             this.pendingInteraction = null;
             const deferred = this.pendingSecretRetry;
             this.pendingSecretRetry = null;
+            this.apiKeyGateActive = false;
             if (pending.secret.providers.includes(this.sessionState.provider)) {
                 if (this.rebuildAgent()) {
                     this.resetChatBoxAfterModelSwap();
@@ -4713,8 +4999,10 @@ export class InteractiveShell {
             display.showError(message);
             this.pendingInteraction = null;
             this.pendingSecretRetry = null;
+            this.apiKeyGateActive = false;
         }
         this.renderPromptArea();
+        this.scheduleQueueProcessing();
     }
     async processRequest(userRequest) {
         if (this.isProcessing) {
@@ -4729,11 +5017,15 @@ export class InteractiveShell {
         if (!agent) {
             return;
         }
+        this.hasShownThoughtProcess = false;
         const alphaZeroEngaged = this.alphaZeroModeEnabled;
         const alphaZeroDifficult = alphaZeroEngaged ? this.isDifficultProblem(userRequest) : false;
         const requestForAgent = alphaZeroEngaged
             ? this.buildAlphaZeroPrompt(userRequest, alphaZeroDifficult)
             : userRequest;
+        const skipReflectionForThisRun = this.skipNextAutoReflection;
+        this.skipNextAutoReflection = false;
+        const scrollbackStartIndex = this.terminalInput.getScrollbackBuffer().length;
         const alphaZeroStatusId = 'alpha-zero';
         let alphaZeroStatusApplied = false;
         let alphaZeroTaskStarted = false;
@@ -4767,6 +5059,8 @@ export class InteractiveShell {
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
         let responseText = '';
+        let detectedFailure = null;
+        let hadUnhandledError = false;
         try {
             // Start streaming - no header needed, the input area already provides context
             this.startStreamingHeartbeat(alphaZeroEngaged ? 'AlphaZero RL' : 'Streaming response');
@@ -4789,18 +5083,18 @@ export class InteractiveShell {
                 duration: 0,
             }));
             // AlphaZero: Check for failure in response
-            const failure = detectFailure(responseText, {
+            detectedFailure = detectFailure(responseText, {
                 toolCalls: this.currentToolCalls,
                 userMessage: userRequest,
             });
             if (alphaZeroEngaged && alphaZeroTaskStarted && !alphaZeroTaskCompleted) {
-                this.alphaZeroMetrics.completeAlphaZeroTask(!failure);
+                this.alphaZeroMetrics.completeAlphaZeroTask(!detectedFailure);
                 alphaZeroTaskCompleted = true;
             }
-            if (failure) {
-                this.lastFailure = failure;
+            if (detectedFailure) {
+                this.lastFailure = detectedFailure;
                 // Check if we have a recovery strategy
-                const strategy = findRecoveryStrategy(failure);
+                const strategy = findRecoveryStrategy(detectedFailure);
                 if (strategy) {
                     display.showSystemMessage(`🔄 Found recovery strategy for this type of issue (success rate: ${Math.round(strategy.successRate * 100)}%)`);
                 }
@@ -4824,6 +5118,7 @@ export class InteractiveShell {
         }
         catch (error) {
             const handled = this.handleProviderError(error, () => this.processRequest(userRequest));
+            hadUnhandledError = !handled;
             if (alphaZeroEngaged && alphaZeroTaskStarted && !alphaZeroTaskCompleted) {
                 this.alphaZeroMetrics.completeAlphaZeroTask(false);
                 alphaZeroTaskCompleted = true;
@@ -4834,6 +5129,24 @@ export class InteractiveShell {
             }
         }
         finally {
+            const runLogEntry = this.buildRunLogEntry(userRequest, responseText, scrollbackStartIndex, {
+                alphaZeroEngaged,
+                alphaZeroDifficult,
+                failureType: detectedFailure?.type ?? (hadUnhandledError ? 'unhandled-error' : null),
+            });
+            this.lastRunLog = runLogEntry;
+            const allowAutoChain = alphaZeroEngaged && this.autoContinueEnabled && isErosolarRepo(this.workingDir);
+            let shouldStopAuto = false;
+            if (this.alphaZeroAutoImproveActive) {
+                shouldStopAuto = this.shouldStopAlphaZeroAutoImprove(responseText, allowAutoChain);
+                if (shouldStopAuto) {
+                    this.alphaZeroAutoImproveActive = false;
+                    this.alphaZeroAutoImproveIterations = 0;
+                }
+            }
+            if (!skipReflectionForThisRun && !shouldStopAuto) {
+                this.maybeQueueAlphaZeroSelfReflection(runLogEntry, alphaZeroEngaged, allowAutoChain);
+            }
             if (alphaZeroEngaged && alphaZeroStatusApplied) {
                 this.statusTracker.clearOverride(alphaZeroStatusId);
             }
@@ -4884,6 +5197,7 @@ export class InteractiveShell {
         if (!agent) {
             return;
         }
+        this.hasShownThoughtProcess = false;
         this.isProcessing = true;
         this.uiUpdates.setMode('processing');
         this.terminalInput.setStreaming(true);
@@ -4924,6 +5238,7 @@ When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
             }
             while (iteration < MAX_ITERATIONS) {
                 iteration++;
+                this.hasShownThoughtProcess = false;
                 display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
                 this.updateStatusMessage(`Working on iteration ${iteration}...`);
                 try {
@@ -5432,6 +5747,7 @@ What's the next action?`;
             // Send the error to the agent for fixing
             display.showThinking('Analyzing build errors');
             this.refreshStatusLine(true);
+            this.hasShownThoughtProcess = false;
             const response = await this.withStreamingUi('Fixing build errors', () => this.agent.send(prompt, true));
             display.stopThinking();
             this.refreshStatusLine(true);
@@ -5461,29 +5777,40 @@ 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);
-                    // Update spinner based on message type
+                    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 shouldRenderThoughtBlock = Boolean(thinking) && !this.hasShownThoughtProcess;
+                    const responseContent = parsed ? parsed.response?.trim() ?? '' : sourceContent.trim();
+                    const narrativeContent = parsed?.response ?? sourceContent;
                     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);
+                        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
                         display.stopThinking();
                         // Update context usage for mode controls display
@@ -5499,12 +5826,21 @@ What's the next action?`;
                         void this.enforceAutoTests('final-response');
                     }
                     else {
+                        if (thinking) {
+                            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) {
-                            display.showNarrative(content.trim());
+                        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());
                         }
                         // The isProcessing flag already shows "⏳ Processing..." - no need for duplicate status
                         this.requestPromptRefresh();
@@ -5687,6 +6023,24 @@ What's the next action?`;
             contextWindowTokens: this.activeContextWindowTokens,
         };
     }
+    presentThoughtProcess(thinking, metadata, options) {
+        if (!thinking || this.hasShownThoughtProcess) {
+            return;
+        }
+        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 });
+        }
+        this.hasShownThoughtProcess = true;
+    }
     handleContextTelemetry(metadata, displayMetadata) {
         if (!metadata.isFinal) {
             return null;
@@ -6047,7 +6401,7 @@ What's the next action?`;
     }
     handleAgentSetupError(error, retryAction, providerOverride) {
         this.pendingInteraction = null;
-        const provider = providerOverride ?? this.sessionState.provider;
+        const provider = providerOverride === undefined ? this.sessionState.provider : providerOverride;
         const apiKeyIssue = detectApiKeyError(error, provider);
         if (apiKeyIssue) {
             this.handleApiKeyIssue(apiKeyIssue, retryAction);
@@ -6062,12 +6416,14 @@ 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);
     }
     handleProviderError(error, retryAction) {
-        const apiKeyIssue = detectApiKeyError(error, this.sessionState.provider);
+        const providerHint = error instanceof MissingSecretError ? null : this.sessionState.provider;
+        const apiKeyIssue = detectApiKeyError(error, providerHint);
         if (!apiKeyIssue) {
             return false;
         }
@@ -6076,13 +6432,19 @@ What's the next action?`;
     }
     handleApiKeyIssue(info, retryAction) {
         const secret = info.secret ?? null;
-        const providerLabel = info.provider ? this.providerLabel(info.provider) : 'the selected provider';
+        const providerLabel = info.provider
+            ? this.providerLabel(info.provider)
+            : secret?.providers?.length
+                ? this.providerLabel(secret.providers[0])
+                : null;
+        const targetLabel = providerLabel ?? secret?.label ?? 'this tool';
+        this.apiKeyGateActive = !!secret;
         if (!secret) {
             this.pendingSecretRetry = null;
             const guidance = 'Run "/secrets" to configure the required API key or export it (e.g., EXPORT KEY=value) before launching the CLI.';
             const baseMessage = info.type === 'missing'
-                ? `An API key is required before using ${providerLabel}.`
-                : `API authentication failed for ${providerLabel}.`;
+                ? `An API key is required before using ${targetLabel}.`
+                : `API authentication failed for ${targetLabel}.`;
             display.showWarning(`${baseMessage} ${guidance}`.trim());
             return;
         }
@@ -6091,8 +6453,8 @@ What's the next action?`;
             display.showWarning(info.message.trim());
         }
         const prefix = isMissing
-            ? `${secret.label} is required before you can use ${providerLabel}.`
-            : `${secret.label} appears to be invalid for ${providerLabel}.`;
+            ? `${secret.label} is required before you can use ${targetLabel}.`
+            : `${secret.label} appears to be invalid for ${targetLabel}.`;
         display.showWarning(prefix);
         this.pendingSecretRetry = retryAction ?? null;
         this.pendingInteraction = { type: 'secret-input', secret };
@@ -6134,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,
@@ -6146,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,
-            },
         });
     }
     /**
@@ -6189,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.
      */