erosolar-cli 1.7.394 → 1.7.396

package/dist/shell/interactiveShell.js

@@ -1,10 +1,11 @@
 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 { 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';
@@ -35,7 +36,6 @@ import { generateTestFlows, detectBugs, detectUIUpdates, saveTestFlows, saveBugR
 import { TerminalInputAdapter } from './terminalInputAdapter.js';
 import { renderSessionFrame } from '../ui/unified/layout.js';
 import { isUpdateInProgress, maybeOfferCliUpdate } from './updateManager.js';
-import { writeLock } from '../ui/writeLock.js';
 import { enterStreamingMode, exitStreamingMode } from '../ui/globalWriteLock.js';
 import { setGlobalAIEnhancer } from '../tools/localExplore.js';
 import { createProvider } from '../providers/providerFactory.js';
@@ -119,6 +119,7 @@ export class InteractiveShell {
     statusSubscription = null;
     followUpQueue = [];
     isDrainingQueue = false;
+    apiKeyGateActive = false;
     activeContextWindowTokens = null;
     latestTokenUsage = { used: null, limit: null };
     planApprovalBridgeRegistered = false;
@@ -128,6 +129,8 @@ export class InteractiveShell {
     autosaveEnabled;
     autoContinueEnabled;
     verificationEnabled = true;
+    alphaZeroModeEnabled;
+    alphaZeroVerificationSnapshot = null;
     editGuardMode = 'display-edits';
     pendingPermissionInput = null;
     pendingHistoryLoad = null;
@@ -149,6 +152,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;
@@ -161,10 +171,12 @@ export class InteractiveShell {
     lastStreamingElapsedSeconds = null; // Preserve final elapsed time
     statusLineState = null;
     statusMessageOverride = null;
+    hasShownThoughtProcess = false;
     promptRefreshTimer = null;
     launchPaletteShown = false;
     version;
     alternateScreenEnabled;
+    inputInitialized = false;
     constructor(config) {
         this.profile = config.profile;
         this.profileLabel = config.profileLabel;
@@ -176,6 +188,7 @@ export class InteractiveShell {
         this.thinkingMode = this.sessionPreferences.thinkingMode;
         this.autosaveEnabled = this.sessionPreferences.autosave;
         this.autoContinueEnabled = this.sessionPreferences.autoContinue;
+        this.alphaZeroModeEnabled = this.sessionPreferences.alphaZeroMode;
         this.sessionRestoreConfig = config.sessionRestore ?? { mode: 'none' };
         this._enabledPlugins = config.enabledPlugins ?? [];
         this.version = config.version ?? '0.0.0';
@@ -231,6 +244,11 @@ export class InteractiveShell {
             description: 'AlphaZero offensive security run (start/status/next)',
             category: 'automation',
         });
+        this.slashCommands.push({
+            command: '/alphazero',
+            description: 'Toggle AlphaZero RL mode with full-cycle verification',
+            category: 'mode',
+        });
         this.statusTracker = config.statusTracker;
         this.ui = config.ui;
         this.uiAdapter = config.ui.adapter;
@@ -242,7 +260,11 @@ export class InteractiveShell {
         });
         // Set up tool status callback to update status during tool execution
         this.uiAdapter.setToolStatusCallback((status) => {
-            this.updateStatusMessage(status ?? null);
+            const statusText = status?.text ?? null;
+            if (statusText) {
+                this.terminalInput.recordRecentAction(`[tool] ${statusText}`);
+            }
+            this.updateStatusMessage(statusText, { logRecent: false });
         });
         this.skillRepository = new SkillRepository({
             workingDir: this.workingDir,
@@ -262,14 +284,13 @@ export class InteractiveShell {
             onToggleVerify: () => this.toggleVerificationMode(),
             onToggleAutoContinue: () => this.toggleAutoContinueMode(),
             onToggleThinking: () => this.cycleThinkingMode(),
+            onToggleAlphaZero: () => this.toggleAlphaZeroMode('shortcut'),
             onClearContext: () => this.handleClearContext(),
         });
         // 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
@@ -287,9 +308,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.terminalInput.forceRender();
         this.rebuildAgent();
         this.setupHandlers();
         this.refreshBannerSessionInfo();
@@ -304,7 +322,13 @@ export class InteractiveShell {
             this.parallelAgentDisplayLines = manager.formatDisplay();
             // Trigger UI refresh if streaming
             if (this.streamingHeartbeatStart) {
-                this.displayParallelAgents();
+                this.uiUpdates.enqueue({
+                    lane: 'stream',
+                    mode: ['streaming', 'processing'],
+                    coalesceKey: 'parallel-agents',
+                    description: 'parallel agent status',
+                    run: () => this.displayParallelAgents(),
+                });
             }
         };
         manager.on('agent:started', updateDisplay);
@@ -375,17 +399,88 @@ 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;
         }
         this.showLaunchCommandPalette();
         // Ensure the terminal input is visible
-        this.terminalInput.render();
+        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
@@ -482,6 +577,7 @@ export class InteractiveShell {
             // Mode toggles
             '/thinking',
             '/autocontinue',
+            '/alphazero',
             // Discovery and plugins
             '/local', '/discover',
             '/plugins',
@@ -533,7 +629,7 @@ export class InteractiveShell {
                 display.showSystemMessage('✏️ Display edits mode enabled.');
             }
         }
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     toggleVerificationMode() {
         this.setVerificationMode(!this.verificationEnabled, 'shortcut');
@@ -570,6 +666,37 @@ export class InteractiveShell {
                 : 'The model will not be auto-prompted to continue.') +
             ' Toggle with Ctrl+Shift+C.');
     }
+    toggleAlphaZeroMode(source = 'shortcut') {
+        this.setAlphaZeroMode(!this.alphaZeroModeEnabled, source);
+    }
+    setAlphaZeroMode(enabled, source) {
+        const changed = this.alphaZeroModeEnabled !== enabled;
+        this.alphaZeroModeEnabled = enabled;
+        saveSessionPreferences({ alphaZeroMode: this.alphaZeroModeEnabled });
+        // Force verification on while AlphaZero mode is active to guarantee deep checks
+        if (enabled) {
+            if (this.alphaZeroVerificationSnapshot === null) {
+                this.alphaZeroVerificationSnapshot = this.verificationEnabled;
+            }
+            if (!this.verificationEnabled) {
+                this.setVerificationMode(true, 'command');
+            }
+        }
+        else if (this.alphaZeroVerificationSnapshot !== null) {
+            this.setVerificationMode(this.alphaZeroVerificationSnapshot, 'command');
+            this.alphaZeroVerificationSnapshot = null;
+        }
+        this.refreshControlBar();
+        if (!changed && source === 'shortcut') {
+            return;
+        }
+        if (enabled) {
+            display.showSystemMessage('♞ AlphaZero RL mode enabled. Difficult prompts will use the duel/self-critique playbook with full lifecycle verification.');
+        }
+        else {
+            display.showInfo('AlphaZero RL mode disabled. Returning to standard flow.');
+        }
+    }
     /**
      * Cycle through thinking modes (Ctrl+Shift+T keyboard shortcut).
      */
@@ -647,7 +774,7 @@ export class InteractiveShell {
         if (['n', 'no', 'cancel', '/cancel'].includes(lower)) {
             this.pendingPermissionInput = null;
             display.showInfo('Request cancelled.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return null;
         }
         // Treat any other input as a replacement request that also needs confirmation
@@ -665,7 +792,7 @@ export class InteractiveShell {
         ]
             .filter(Boolean)
             .join('\n'));
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     /**
      * Handle Ctrl+C presses in three stages:
@@ -680,7 +807,7 @@ export class InteractiveShell {
             this.clearChatInput();
             const prefix = hadBuffer ? 'Input cleared.' : 'Nothing to clear.';
             display.showSystemMessage(`${prefix} Press Ctrl+C again to pause the AI; a third time quits.`);
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (this.ctrlCPressCount === 2) {
@@ -781,8 +908,11 @@ export class InteractiveShell {
     /**
      * Update status bar message
      */
-    updateStatusMessage(message) {
+    updateStatusMessage(message, options = {}) {
         this.statusMessageOverride = message;
+        if (message && options.logRecent !== false) {
+            this.terminalInput.recordRecentAction(`[status] ${message}`);
+        }
         // During streaming we still want the spinner prefix; when idle force a fast refresh.
         this.refreshStatusLine(!this.isProcessing);
     }
@@ -794,26 +924,26 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number, "save", "defaults", or "cancel".');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const normalized = trimmed.toLowerCase();
         if (normalized === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Tool selection cancelled.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (normalized === 'defaults') {
             pending.selection = buildEnabledToolSet(null);
             this.renderToolMenu(pending);
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (normalized === 'save') {
             await this.persistToolSelection(pending);
             this.pendingInteraction = null;
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
@@ -831,11 +961,11 @@ export class InteractiveShell {
                 }
                 this.renderToolMenu(pending);
             }
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         display.showWarning('Enter a number, "save", "defaults", or "cancel".');
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     async persistToolSelection(interaction) {
         if (setsEqual(interaction.selection, interaction.initialSelection)) {
@@ -862,36 +992,36 @@ export class InteractiveShell {
         if (!this.agentMenu) {
             this.pendingInteraction = null;
             display.showWarning('Agent selection is unavailable in this CLI.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number or type "cancel".');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Agent selection cancelled.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
             display.showWarning('Please enter a valid number.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const option = pending.options[choice - 1];
         if (!option) {
             display.showWarning('That option is not available.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         await this.persistAgentSelection(option.name);
         this.pendingInteraction = null;
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     async persistAgentSelection(profileName) {
         if (!this.agentMenu) {
@@ -964,7 +1094,7 @@ export class InteractiveShell {
         lines.push(`  ${theme.primary('[text]')}   Submit your own solution instead`);
         lines.push('');
         display.showSystemMessage(lines.join('\n'));
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     async handlePlanApprovalInput(input) {
         const pending = this.pendingInteraction;
@@ -973,7 +1103,7 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a command or your own solution.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const lower = trimmed.toLowerCase();
@@ -981,7 +1111,7 @@ export class InteractiveShell {
         if (lower === 'cancel' || lower === 'c') {
             this.pendingInteraction = null;
             display.showInfo('Plan cancelled. You can continue with a different approach.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         // Select all
@@ -1001,7 +1131,7 @@ export class InteractiveShell {
             const selectedSteps = pending.steps.filter(s => pending.selectedSteps.has(s.id));
             if (selectedSteps.length === 0) {
                 display.showWarning('No steps selected. Select steps or enter your own solution.');
-                this.terminalInput.render();
+                this.renderPromptArea();
                 return;
             }
             this.pendingInteraction = null;
@@ -1034,15 +1164,18 @@ export class InteractiveShell {
             return;
         }
         display.showWarning('Invalid input. Enter a step number, command (go/cancel/all/none), or your own solution.');
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     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.terminalInput.render();
     }
     /**
      * Set up command autocomplete with all available slash commands.
@@ -1073,6 +1206,14 @@ export class InteractiveShell {
         catch {
             // Custom commands are optional
         }
+        // Add manual commands that are not yet in the schema
+        if (!commands.some((cmd) => cmd.command === '/alphazero')) {
+            commands.push({
+                command: '/alphazero',
+                description: 'Toggle AlphaZero RL mode',
+                category: 'mode',
+            });
+        }
         // Sort commands alphabetically
         commands.sort((a, b) => a.command.localeCompare(b.command));
         this.terminalInput.setAvailableCommands(commands);
@@ -1153,23 +1294,51 @@ export class InteractiveShell {
             autoContinueHotkey: 'ctrl+shift+c',
             thinkingModeLabel: this.thinkingMode,
             thinkingHotkey: 'ctrl+shift+t',
+            alphaZeroEnabled: this.alphaZeroModeEnabled,
+            alphaZeroHotkey: 'ctrl+shift+a',
+            alphaZeroLabel: 'AlphaZero RL',
         });
         this.refreshStatusLine();
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     writeLocked(content) {
         if (!content) {
             return;
         }
-        // If lock is already held, write directly - we're in a protected context
-        // This prevents queuing issues where content gets delayed
-        if (writeLock.isLocked()) {
-            process.stdout.write(content);
+        // Route through display stream so scroll regions and streaming locks stay in sync
+        display.stream(content);
+    }
+    isStreamingUiActive() {
+        return this.streamingHeartbeatStart !== null;
+    }
+    /**
+     * Render the prompt/control bar. During streaming, rely on the streaming frame
+     * renderer and enqueue through the UIUpdateCoordinator to avoid fighting the
+     * scroll region or duplicating the prompt.
+     */
+    renderPromptArea(force = false) {
+        if (this.isStreamingUiActive()) {
+            this.uiUpdates.enqueue({
+                lane: 'prompt',
+                mode: ['streaming', 'processing'],
+                coalesceKey: 'prompt:streaming-frame',
+                description: 'render streaming prompt frame',
+                run: () => {
+                    if (force) {
+                        this.terminalInput.renderStreamingFrame(true);
+                        return;
+                    }
+                    this.terminalInput.renderStreamingFrame();
+                },
+            });
             return;
         }
-        writeLock.withLock(() => {
-            process.stdout.write(content);
-        }, 'interactiveShell.stdout');
+        if (force) {
+            this.terminalInput.forceRender();
+        }
+        else {
+            this.terminalInput.render();
+        }
     }
     /**
      * Refresh the status line in the persistent input area.
@@ -1215,7 +1384,7 @@ export class InteractiveShell {
             provider: this.providerLabel(this.sessionState.provider),
         });
         if (forceRender) {
-            this.terminalInput.render();
+            this.renderPromptArea(true);
         }
     }
     /**
@@ -1252,7 +1421,7 @@ export class InteractiveShell {
      * Ensure the terminal input is ready for interactive input.
      */
     ensureReadlineReady() {
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     /**
      * Log user prompt to the scroll region so it's part of the conversation flow.
@@ -1274,7 +1443,7 @@ export class InteractiveShell {
     }
     requestPromptRefresh(force = false) {
         if (force) {
-            this.terminalInput.forceRender();
+            this.renderPromptArea(true);
             return;
         }
         if (this.promptRefreshTimer) {
@@ -1282,7 +1451,7 @@ export class InteractiveShell {
         }
         this.promptRefreshTimer = setTimeout(() => {
             this.promptRefreshTimer = null;
-            this.terminalInput.render();
+            this.renderPromptArea();
         }, 48);
     }
     clearPromptRefreshTimer() {
@@ -1291,6 +1460,25 @@ export class InteractiveShell {
             this.promptRefreshTimer = null;
         }
     }
+    async withStreamingUi(label, run) {
+        if (this.isStreamingUiActive()) {
+            return run();
+        }
+        this.terminalInput.setStreaming(true);
+        this.startStreamingHeartbeat(label);
+        try {
+            return await run();
+        }
+        finally {
+            this.stopStreamingHeartbeat();
+            this.terminalInput.setStreaming(false);
+            const nextMode = this.isProcessing ? 'processing' : 'idle';
+            this.uiUpdates.setMode(nextMode);
+            if (nextMode === 'processing') {
+                queueMicrotask(() => this.uiUpdates.setMode('idle'));
+            }
+        }
+    }
     startStreamingHeartbeat(label = 'Streaming') {
         this.stopStreamingHeartbeat();
         // Enter global streaming mode - blocks all non-streaming UI output
@@ -1371,7 +1559,7 @@ export class InteractiveShell {
         else {
             this.setIdleStatus();
         }
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     enqueueFollowUpAction(action) {
         this.followUpQueue.push(action);
@@ -1390,14 +1578,21 @@ export class InteractiveShell {
         this.refreshQueueIndicators();
         this.scheduleQueueProcessing();
         // Re-show the prompt so user can continue typing more follow-ups
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     scheduleQueueProcessing() {
         if (!this.followUpQueue.length) {
             this.refreshQueueIndicators();
             return;
         }
+        if (this.apiKeyGateActive) {
+            this.refreshQueueIndicators();
+            return;
+        }
         queueMicrotask(() => {
+            if (this.apiKeyGateActive) {
+                return;
+            }
             void this.processQueuedActions();
         });
     }
@@ -1405,12 +1600,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';
@@ -1445,12 +1640,12 @@ export class InteractiveShell {
         }
         if (lower === 'clear') {
             display.clear();
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (lower === 'help') {
             this.showHelp();
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (trimmed.startsWith('/')) {
@@ -1460,12 +1655,12 @@ export class InteractiveShell {
         // Check for continuous/infinite loop commands
         if (this.isContinuousCommand(trimmed)) {
             await this.processContinuousRequest(trimmed);
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         // Direct execution for all inputs, including multi-line pastes
         await this.processRequest(trimmed);
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     /**
      * Check if the command is a continuous/infinite loop command
@@ -1503,6 +1698,153 @@ export class InteractiveShell {
         ];
         return patterns.some(pattern => pattern.test(lower));
     }
+    isDifficultProblem(input) {
+        const normalized = input.toLowerCase();
+        const wordCount = normalized.split(/\s+/).filter(Boolean).length;
+        if (normalized.length > 600 || wordCount > 80) {
+            return true;
+        }
+        const signals = [
+            'root cause',
+            'postmortem',
+            'crash',
+            'incident',
+            'outage',
+            'optimiz',
+            'performance',
+            'throughput',
+            'latency',
+            'scalab',
+            'architecture',
+            'rewrite',
+            'migration',
+            'refactor',
+            'reverse engineer',
+            'security',
+            'exploit',
+            'injection',
+            'vulnerability',
+            'compliance',
+            'multi-step',
+            'complex',
+            'difficult',
+            'hard problem',
+            'debug',
+            'trace',
+            'profil',
+            'bottleneck',
+        ];
+        return signals.some((signal) => normalized.includes(signal));
+    }
+    buildAlphaZeroPrompt(request, flaggedDifficult) {
+        const playbook = [
+            'AlphaZero RL MODE is ACTIVE. Operate as a self-play reinforcement loop.',
+            flaggedDifficult
+                ? 'Treat this as a difficult, high-risk task and over-verify the result.'
+                : 'Apply the reinforcement loop even if the task looks small.',
+            'Follow this closed-loop playbook:',
+            '- Draft two competing solution strategies and merge the strongest ideas before executing.',
+            '- Execute with tools while logging decisions and evidence.',
+            '- Self-critique and repair until the quality is excellent (aim ≥90/100).',
+            '- Run full-lifecycle verification like a human reviewer: build/tests, manual sanity checks, edge cases, performance/safety/security probes, docs/UX/readiness notes.',
+            '- Keep a verification ledger: each check with PASS/FAIL, evidence, and remaining risks. If anything fails, fix and re-verify before claiming completion.',
+            'Finish with a concise sign-off that lists what was achieved and the proof of completion.',
+        ];
+        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;
@@ -1510,7 +1852,7 @@ export class InteractiveShell {
         switch (this.pendingInteraction.type) {
             case 'model-loading':
                 display.showInfo('Still fetching model options. Please wait a moment.');
-                this.terminalInput.render();
+                this.renderPromptArea();
                 return true;
             case 'model-provider':
                 await this.handleModelProviderSelection(input);
@@ -1541,7 +1883,7 @@ export class InteractiveShell {
         const [command] = input.split(/\s+/);
         if (!command) {
             display.showWarning('Enter a slash command.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         switch (command) {
@@ -1599,6 +1941,9 @@ export class InteractiveShell {
             case '/autocontinue':
                 this.handleAutoContinueCommand(input);
                 break;
+            case '/alphazero':
+                this.handleAlphaZeroCommand(input);
+                break;
             case '/shortcuts':
             case '/keys':
                 this.handleShortcutsCommand();
@@ -1703,7 +2048,7 @@ export class InteractiveShell {
                 }
                 break;
         }
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     async tryCustomSlashCommand(command, fullInput) {
         const custom = this.customCommandMap.get(command);
@@ -1740,6 +2085,7 @@ export class InteractiveShell {
             `    ${theme.info('Option+V')}       ${theme.ui.muted('Toggle verification')}`,
             `    ${theme.info('Option+C')}       ${theme.ui.muted('Toggle auto-continue')}`,
             `    ${theme.info('Option+T')}       ${theme.ui.muted('Cycle thinking mode')}`,
+            `    ${theme.info('Option+A')}       ${theme.ui.muted('Toggle AlphaZero RL mode')}`,
             `    ${theme.info('Option+E')}       ${theme.ui.muted('Toggle edit permission mode')}`,
             `    ${theme.info('Option+X')}       ${theme.ui.muted('Clear/compact context')}`,
             '',
@@ -2025,6 +2371,24 @@ export class InteractiveShell {
         };
         display.showInfo(`Thinking mode set to ${theme.info(value)} – ${descriptions[this.thinkingMode]}`);
     }
+    handleAlphaZeroCommand(input) {
+        const value = input.slice('/alphazero'.length).trim().toLowerCase();
+        if (!value || value === 'status') {
+            const status = this.alphaZeroModeEnabled ? theme.success('on') : theme.ui.muted('off');
+            const verification = this.verificationEnabled ? 'verification locked on' : 'verification optional';
+            display.showInfo(`AlphaZero RL mode is ${status}. When enabled, difficult prompts use duel/self-critique and human-style verification (${verification}).`);
+            return;
+        }
+        if (['on', 'enable', 'enabled'].includes(value)) {
+            this.setAlphaZeroMode(true, 'command');
+            return;
+        }
+        if (['off', 'disable', 'disabled'].includes(value)) {
+            this.setAlphaZeroMode(false, 'command');
+            return;
+        }
+        display.showWarning('Usage: /alphazero [on|off|status]');
+    }
     handleShortcutsCommand() {
         // Display keyboard shortcuts help (Claude Code style)
         display.showSystemMessage(formatShortcutsHelp());
@@ -3494,7 +3858,7 @@ export class InteractiveShell {
         display.clear();
         clearAutosaveSnapshot(this.profile);
         display.showInfo('Conversation cleared. Starting fresh.');
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     async handleResumeCommand(input) {
         const tokens = input.split(/\s+/).slice(1);
@@ -3803,7 +4167,7 @@ export class InteractiveShell {
             if (!providerOptions.length) {
                 display.showWarning('No providers are available.');
                 this.pendingInteraction = null;
-                this.terminalInput.render();
+                this.renderPromptArea();
                 return;
             }
             const lines = [
@@ -3824,7 +4188,7 @@ export class InteractiveShell {
         catch (error) {
             display.showError('Failed to load model list. Try again in a moment.', error);
             this.pendingInteraction = null;
-            this.terminalInput.render();
+            this.renderPromptArea();
         }
     }
     buildProviderOptions() {
@@ -4369,29 +4733,29 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number or type cancel.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Model selection cancelled.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
             display.showWarning('Please enter a valid number.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const option = pending.options[choice - 1];
         if (!option) {
             display.showWarning('That option is not available.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         this.showProviderModels(option);
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     async handleModelSelection(input) {
         const pending = this.pendingInteraction;
@@ -4401,35 +4765,35 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number, type "back", or type "cancel".');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (trimmed.toLowerCase() === 'back') {
             this.showModelMenu();
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Model selection cancelled.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
             display.showWarning('Please enter a valid number.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const preset = pending.options[choice - 1];
         if (!preset) {
             display.showWarning('That option is not available.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         this.pendingInteraction = null;
         await this.applyModelPreset(preset);
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     async applyModelPreset(preset) {
         try {
@@ -4462,30 +4826,30 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a number or type cancel.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             display.showInfo('Secret management cancelled.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
             display.showWarning('Please enter a valid number.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         const secret = pending.options[choice - 1];
         if (!secret) {
             display.showWarning('That option is not available.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         display.showSystemMessage(`Enter a new value for ${secret.label} or type "cancel".`);
         this.pendingInteraction = { type: 'secret-input', secret };
-        this.terminalInput.render();
+        this.renderPromptArea();
     }
     async handleSecretInput(input) {
         const pending = this.pendingInteraction;
@@ -4495,14 +4859,16 @@ export class InteractiveShell {
         const trimmed = input.trim();
         if (!trimmed) {
             display.showWarning('Enter a value or type cancel.');
-            this.terminalInput.render();
+            this.renderPromptArea();
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             this.pendingSecretRetry = null;
+            this.apiKeyGateActive = false;
             display.showInfo('Secret unchanged.');
-            this.terminalInput.render();
+            this.renderPromptArea();
+            this.scheduleQueueProcessing();
             return;
         }
         try {
@@ -4511,6 +4877,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();
@@ -4525,12 +4892,14 @@ export class InteractiveShell {
             display.showError(message);
             this.pendingInteraction = null;
             this.pendingSecretRetry = null;
+            this.apiKeyGateActive = false;
         }
-        this.terminalInput.render();
+        this.renderPromptArea();
+        this.scheduleQueueProcessing();
     }
-    async processRequest(request) {
+    async processRequest(userRequest) {
         if (this.isProcessing) {
-            this.enqueueFollowUpAction({ type: 'request', text: request });
+            this.enqueueFollowUpAction({ type: 'request', text: userRequest });
             return;
         }
         if (!this.agent && !this.rebuildAgent()) {
@@ -4541,28 +4910,54 @@ export class InteractiveShell {
         if (!agent) {
             return;
         }
-        this.logUserPrompt(request);
+        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;
+        let alphaZeroTaskCompleted = false;
+        if (alphaZeroEngaged) {
+            const detail = alphaZeroDifficult ? 'Difficult request detected' : 'Reinforcement loop enabled';
+            this.statusTracker.pushOverride(alphaZeroStatusId, 'AlphaZero RL active', {
+                detail: `${detail} · full verification`,
+                tone: 'info',
+            });
+            alphaZeroStatusApplied = true;
+            display.showInfo(`AlphaZero RL mode engaged${alphaZeroDifficult ? ' for a difficult request' : ''}. Duel + self-critique with verification enabled.`);
+            this.alphaZeroMetrics.startAlphaZeroTask(userRequest);
+            alphaZeroTaskStarted = true;
+        }
+        this.logUserPrompt(userRequest);
         this.isProcessing = true;
         this.uiUpdates.setMode('processing');
         this.terminalInput.setStreaming(true);
         // Keep the persistent input/control bar active as we transition into streaming.
-        this.terminalInput.forceRender();
+        this.renderPromptArea(true);
         const requestStartTime = Date.now(); // Alpha Zero 2 timing
         // Clear previous parallel agents and start fresh for new request
         const parallelManager = getParallelAgentManager();
         parallelManager.clear();
         parallelManager.startBatch();
         // AlphaZero: Track task for learning
-        this.lastUserQuery = request;
-        this.currentTaskType = classifyTaskType(request);
+        this.lastUserQuery = userRequest;
+        this.currentTaskType = classifyTaskType(userRequest);
         this.currentToolCalls = [];
         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('Streaming response');
-            responseText = await agent.send(request, true);
+            this.startStreamingHeartbeat(alphaZeroEngaged ? 'AlphaZero RL' : 'Streaming response');
+            responseText = await agent.send(requestForAgent, true);
             await this.awaitPendingCleanup();
             this.captureHistorySnapshot();
             this.autosaveIfEnabled();
@@ -4581,14 +4976,18 @@ export class InteractiveShell {
                 duration: 0,
             }));
             // AlphaZero: Check for failure in response
-            const failure = detectFailure(responseText, {
+            detectedFailure = detectFailure(responseText, {
                 toolCalls: this.currentToolCalls,
-                userMessage: request,
+                userMessage: userRequest,
             });
-            if (failure) {
-                this.lastFailure = failure;
+            if (alphaZeroEngaged && alphaZeroTaskStarted && !alphaZeroTaskCompleted) {
+                this.alphaZeroMetrics.completeAlphaZeroTask(!detectedFailure);
+                alphaZeroTaskCompleted = true;
+            }
+            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)}%)`);
                 }
@@ -4611,13 +5010,42 @@ export class InteractiveShell {
             }
         }
         catch (error) {
-            const handled = this.handleProviderError(error, () => this.processRequest(request));
+            const handled = this.handleProviderError(error, () => this.processRequest(userRequest));
+            hadUnhandledError = !handled;
+            if (alphaZeroEngaged && alphaZeroTaskStarted && !alphaZeroTaskCompleted) {
+                this.alphaZeroMetrics.completeAlphaZeroTask(false);
+                alphaZeroTaskCompleted = true;
+            }
             if (!handled) {
                 // Pass full error object for enhanced formatting with stack trace
                 display.showError(error instanceof Error ? error.message : String(error), error);
             }
         }
         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);
+            }
+            if (alphaZeroEngaged && alphaZeroTaskStarted && !alphaZeroTaskCompleted) {
+                this.alphaZeroMetrics.completeAlphaZeroTask(false);
+            }
             display.stopThinking(false);
             this.uiUpdates.setMode('processing');
             this.stopStreamingHeartbeat();
@@ -4631,7 +5059,7 @@ export class InteractiveShell {
             // CRITICAL: Ensure readline prompt is active for user input
             // Claude Code style: New prompt naturally appears at bottom
             this.ensureReadlineReady();
-            this.terminalInput.render();
+            this.renderPromptArea();
             this.scheduleQueueProcessing();
             this.refreshQueueIndicators();
         }
@@ -4662,6 +5090,7 @@ export class InteractiveShell {
         if (!agent) {
             return;
         }
+        this.hasShownThoughtProcess = false;
         this.isProcessing = true;
         this.uiUpdates.setMode('processing');
         this.terminalInput.setStreaming(true);
@@ -4702,6 +5131,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 {
@@ -5102,6 +5532,8 @@ What's the next action?`;
         finally {
             this.updateStatusMessage(null);
             this.autoTestInFlight = false;
+            this.terminalInput.resetContentPosition();
+            this.terminalInput.forceRender();
         }
     }
     isBuildToolCall(entry) {
@@ -5208,7 +5640,8 @@ What's the next action?`;
             // Send the error to the agent for fixing
             display.showThinking('Analyzing build errors');
             this.refreshStatusLine(true);
-            const response = await this.agent.send(prompt, true);
+            this.hasShownThoughtProcess = false;
+            const response = await this.withStreamingUi('Fixing build errors', () => this.agent.send(prompt, true));
             display.stopThinking();
             this.refreshStatusLine(true);
             if (response) {
@@ -5243,22 +5676,15 @@ What's the next action?`;
                 onStreamFallback: (info) => this.handleStreamingFallback(info),
                 onAssistantMessage: (content, metadata) => {
                     const enriched = this.buildDisplayMetadata(metadata);
+                    const parsed = this.splitThinkingResponse(content);
+                    const thinking = parsed?.thinking ?? null;
+                    const responseContent = parsed ? parsed.response?.trim() ?? '' : content.trim();
                     // Update spinner based on message type
                     if (metadata.isFinal) {
+                        this.presentThoughtProcess(thinking, enriched, { wasStreamed: metadata.wasStreamed });
                         // 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 (!metadata.wasStreamed && responseContent) {
+                            display.showAssistantMessage(responseContent, enriched);
                         }
                         // Status shown in mode controls bar - no separate status line needed
                         display.stopThinking();
@@ -5275,12 +5701,16 @@ What's the next action?`;
                         void this.enforceAutoTests('final-response');
                     }
                     else {
+                        if (thinking) {
+                            this.presentThoughtProcess(thinking, enriched, { wasStreamed: 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());
+                            const narrative = parsed?.response ?? content;
+                            display.showNarrative(narrative.trim());
                         }
                         // The isProcessing flag already shows "⏳ Processing..." - no need for duplicate status
                         this.requestPromptRefresh();
@@ -5318,19 +5748,19 @@ What's the next action?`;
                         this.updateContextUsage(percentage);
                     }
                     // Ensure prompt remains visible at bottom after context messages
-                    this.terminalInput.render();
+                    this.renderPromptArea();
                 },
                 onContinueAfterRecovery: () => {
                     // Update UI to show we're continuing after context recovery
                     display.showSystemMessage(`🔄 Continuing after context recovery...`);
                     this.updateStatusMessage('Retrying with reduced context...');
-                    this.terminalInput.render();
+                    this.renderPromptArea();
                 },
                 onAutoContinue: (attempt, maxAttempts, _message) => {
                     // Show auto-continue progress in UI
                     display.showSystemMessage(`🔄 Auto-continue (${attempt}/${maxAttempts}): Model expressed intent, prompting to act...`);
                     this.updateStatusMessage('Auto-continuing...');
-                    this.terminalInput.render();
+                    this.renderPromptArea();
                 },
                 onCancelled: () => {
                     // Update UI to show operation was cancelled
@@ -5339,7 +5769,7 @@ What's the next action?`;
                     this.stopStreamingHeartbeat();
                     this.updateStatusMessage(null);
                     this.terminalInput.setStreaming(false);
-                    this.terminalInput.render();
+                    this.renderPromptArea();
                 },
                 onVerificationNeeded: () => {
                     void this.enforceAutoBuild('verification');
@@ -5377,7 +5807,7 @@ What's the next action?`;
     resetChatBoxAfterModelSwap() {
         this.updateStatusMessage(null);
         this.terminalInput.setStreaming(false);
-        this.terminalInput.render();
+        this.renderPromptArea();
         this.ensureReadlineReady();
     }
     /**
@@ -5463,6 +5893,19 @@ 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}`);
+        }
+        if (!options?.wasStreamed) {
+            display.showAssistantMessage(thinking, { ...metadata, isFinal: false });
+        }
+        this.hasShownThoughtProcess = true;
+    }
     handleContextTelemetry(metadata, displayMetadata) {
         if (!metadata.isFinal) {
             return null;
@@ -5823,7 +6266,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);
@@ -5843,7 +6286,8 @@ What's the next action?`;
         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;
         }
@@ -5852,13 +6296,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;
         }
@@ -5867,8 +6317,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 };