erosolar-cli 2.1.170 → 2.1.172

package/dist/shell/interactiveShell.js

@@ -7,6 +7,7 @@ import { join, resolve } from 'node:path';
 import { display } from '../ui/display.js';
 import { theme } from '../ui/theme.js';
 import { getTerminalColumns } from '../ui/layout.js';
+import { StreamingResponseFormatter } from '../ui/streamingFormatter.js';
 import { getContextWindowTokens } from '../core/contextWindow.js';
 import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue, listSecretDefinitions, 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';
@@ -18,6 +19,7 @@ import { detectNetworkError } from '../core/errors/networkErrors.js';
 import { buildWorkspaceContext } from '../workspace.js';
 import { buildInteractiveSystemPrompt } from './systemPrompt.js';
 import { getTaskCompletionDetector, resetTaskCompletionDetector, } from './taskCompletionDetector.js';
+import { assessAiFlow } from '../core/aiFlowSupervisor.js';
 import { discoverAllModels, quickCheckProviders, getCachedDiscoveredModels, sortModelsByPriority } from '../core/modelDiscovery.js';
 import { getModels, getSlashCommands, getProviders } from '../core/agentSchemaLoader.js';
 import { loadMcpServers } from '../mcp/config.js';
@@ -27,7 +29,7 @@ import { SkillRepository } from '../skills/skillRepository.js';
 import { createSkillTools } from '../tools/skillTools.js';
 import { FileChangeTracker } from './fileChangeTracker.js';
 import { formatShortcutsHelp } from '../ui/shortcutsHelp.js';
-import { setPlanApprovalCallback } from '../tools/planningTools.js';
+import { setPlanApprovalCallback, setPlanUpdateCallback } from '../tools/planningTools.js';
 import { MetricsTracker } from '../core/metricsTracker.js';
 import { detectFailure, clearActionHistory, findRecoveryStrategy, } from '../core/failureRecovery.js';
 import { addToolPattern } from '../core/learningPersistence.js';
@@ -40,6 +42,7 @@ import { startOffsecRun, resumeOffsecRun, recordOffsecOutcome, getOffsecNextActi
 import { generateTestFlows, detectBugs, detectUIUpdates, saveTestFlows, saveBugReports, saveUIUpdates, getTestFlowStatus, } from '../core/intelligentTestFlows.js';
 import { PromptController } from '../ui/PromptController.js';
 import { enterStreamingMode, exitStreamingMode, isStreamingMode } from '../ui/globalWriteLock.js';
+import { PlanOverlay } from '../ui/planOverlay.js';
 import { setGlobalAIEnhancer } from '../tools/localExplore.js';
 import { createProvider } from '../providers/providerFactory.js';
 import { getParallelAgentManager } from '../subagents/parallelAgentManager.js';
@@ -129,11 +132,14 @@ export class InteractiveShell {
     activeContextWindowTokens = null;
     latestTokenUsage = { used: null, limit: null };
     planApprovalBridgeRegistered = false;
+    planUpdateBridgeRegistered = false;
+    planOverlay = new PlanOverlay();
     contextCompactionInFlight = false;
     contextCompactionLog = [];
     lastContextWarningLevel = null;
     sessionPreferences;
     autosaveEnabled;
+    autoContinueEnabled;
     verificationEnabled = false;
     criticalApprovalMode = 'auto';
     editGuardMode = 'display-edits';
@@ -179,6 +185,7 @@ export class InteractiveShell {
     streamingOutputSuppressed = false;
     aiRuntimeStart = null;
     aiRuntimeTotalMs = 0;
+    streamingFormatter = null;
     streamingThoughtBuffer = '';
     statusLineState = null;
     statusMessageOverride = null;
@@ -203,6 +210,7 @@ export class InteractiveShell {
         this.sessionPreferences = loadSessionPreferences();
         this.thinkingMode = this.sessionPreferences.thinkingMode;
         this.autosaveEnabled = this.sessionPreferences.autosave;
+        this.autoContinueEnabled = this.sessionPreferences.autoContinue;
         this.criticalApprovalMode = this.sessionPreferences.criticalApprovalMode;
         const featureFlags = loadFeatureFlags();
         this.verificationEnabled = featureFlags.verification === true;
@@ -261,6 +269,11 @@ export class InteractiveShell {
             description: 'Switch between auto and approval mode for high-impact actions',
             category: 'configuration',
         });
+        this.slashCommands.push({
+            command: '/plan',
+            description: 'Show, hide, or clear the current plan panel (/plan show|hide|clear)',
+            category: 'workflow',
+        });
         this.slashCommands.push({
             command: '/offsec',
             description: 'AlphaZero offensive security run (start/status/next)',
@@ -279,10 +292,6 @@ export class InteractiveShell {
         this.uiAdapter.setToolStatusCallback((status) => {
             this.updateStatusMessage(status ?? null);
         });
-        // Set up activity callback to update activity line with streaming bash output
-        this.uiAdapter.setActivityCallback((activity) => {
-            this.renderer?.setActivity(activity);
-        });
         this.skillRepository = new SkillRepository({
             workingDir: this.workingDir,
             env: process.env,
@@ -296,18 +305,20 @@ export class InteractiveShell {
             onQueue: (text) => this.handleQueuedInput(text),
             onCtrlC: ({ hadBuffer }) => this.handleCtrlCPress(hadBuffer),
             onInterrupt: () => this.handleInterrupt(),
-            onExit: () => this.handleExit(),
+            onExit: () => this.shutdown(),
+            onExpandToolResult: () => display.expandLastToolResult?.(),
             onChange: ({ text, cursor }) => this.handleInputChange(text, cursor, 'renderer'),
             onEditModeChange: (mode) => this.handleEditModeChange(mode),
             onToggleVerify: () => this.toggleVerificationMode(),
+            onToggleAutoContinue: () => this.toggleAutoContinueMode(),
             onToggleThinking: () => this.cycleThinkingMode(),
             onClearContext: () => this.handleClearContext(),
             onToggleCriticalApproval: () => this.toggleCriticalApprovalMode('shortcut'),
-            onExpandToolResult: () => this.expandLastToolResult(),
         });
         // Share renderer with Display so all output flows through the unified queue
         this.renderer = this.terminalInput.getRenderer();
         display.setRenderer(this.renderer);
+        this.uiAdapter.attachRenderer(this.renderer);
         display.setInlinePanelHandler((content) => {
             if (!this.shouldCaptureInlinePanel()) {
                 return false;
@@ -327,6 +338,7 @@ export class InteractiveShell {
         // The control bar will be refreshed after the welcome banner
         // Allow planning tools (e.g., ProposePlan) to open the interactive approval UI just like Codex CLI
         this.registerPlanApprovalBridge();
+        this.registerPlanUpdateBridge();
         // Set up command autocomplete with all slash commands
         this.setupCommandAutocomplete();
         this.rebuildAgent();
@@ -447,21 +459,18 @@ export class InteractiveShell {
         const top = `╭${'─'.repeat(labelLeft)}${label}${'─'.repeat(labelRight)}╮`;
         const bottom = `╰${'─'.repeat(contentWidth)}╯`;
         const userName = process.env['USER'] || 'there';
-        const logo = '⟣╍◎╍⟢';
+        const logo = clamp('⟣╍◎╍⟢');
         const versionLabel = version ? clamp(`${brand} · v${version}`) : brand;
         const modelLine = clamp(model);
         const workspaceLine = clamp(workspace);
-        // Compact welcome line with logo on same line
-        const welcomeLine = clamp(`${logo} Welcome back ${userName}! ${logo}`);
-        // Quick reference hints
-        const hintsLine = clamp('/model · /secrets · /help · ? shortcuts');
+        const welcomeLine = clamp(`Welcome back ${userName}!`);
         const lines = [
             frame(top),
             frame(`│${padCenter(welcomeLine, contentWidth)}│`),
+            frame(`│${padCenter(logo, contentWidth)}│`),
             frame(`│${padCenter(modelLine, contentWidth)}│`),
             frame(`│${padCenter(versionLabel, contentWidth)}│`),
             frame(`│${padCenter(workspaceLine, contentWidth)}│`),
-            frame(`│${padCenter(hintsLine, contentWidth)}│`),
             frame(bottom),
         ].join('\n');
         if (this.renderer) {
@@ -472,6 +481,8 @@ export class InteractiveShell {
         else {
             display.stream(`\n${lines}\n`);
         }
+        // Check for updates asynchronously (non-blocking)
+        void this.checkAndShowUpdates();
         // Keep UI pinned; no scrollback banners
         this.requestPromptRefresh(true);
     }
@@ -509,32 +520,22 @@ export class InteractiveShell {
     }
     async checkAndShowUpdates() {
         try {
-            const { checkForUpdates, getUpdateDecision, formatUpdateBanner, performBackgroundUpdate, readAutoUpdateState, shouldShowUpdateNotification, } = await import('../core/updateChecker.js');
+            const { checkForUpdates, formatUpdateNotification, maybeAutoUpdate } = await import('../core/updateChecker.js');
             const currentVersion = this.version || this.getPackageInfo().version || '1.7.458';
             const updateInfo = await checkForUpdates(currentVersion);
             if (!updateInfo || !updateInfo.updateAvailable) {
                 return;
             }
-            // Check if we should show notification (respects quiet period)
-            const state = readAutoUpdateState();
-            if (!shouldShowUpdateNotification(state)) {
-                return;
-            }
-            // Get user's preference-based decision (no interactive prompt)
-            const sessionPrefs = loadSessionPreferences();
-            const decision = getUpdateDecision(sessionPrefs.autoUpdate);
-            if (decision === 'skip') {
-                // User chose to always skip - silently ignore updates
+            const updateResult = await maybeAutoUpdate(currentVersion, {
+                updateInfo,
+                logger: (message) => this.streamEventBlock(message),
+            });
+            if (updateResult?.updated) {
                 return;
             }
-            // Show non-interactive banner notification
-            this.streamEventBlock(formatUpdateBanner(updateInfo, decision));
-            if (decision === 'auto') {
-                // User chose to always update - perform background update
-                await performBackgroundUpdate(updateInfo, (message) => this.streamEventBlock(message));
-            }
-            // If decision === 'ask', we just show the banner with instructions
-            // User can run /update check or /update auto to update
+            const note = this.describeUpdateSkipReason(updateResult);
+            const notification = formatUpdateNotification(updateInfo, note);
+            this.streamEventBlock(notification);
         }
         catch {
             // Silently fail - don't interrupt user experience
@@ -618,8 +619,6 @@ export class InteractiveShell {
         this.pushUiEvent('raw', block);
     }
     async start(initialPrompt) {
-        // Check for updates BEFORE terminal input starts (to avoid keypress conflicts)
-        await this.checkAndShowUpdates();
         // Initialize the renderer before emitting the banner so we don't render the prompt twice
         this.terminalInput.start();
         this.resetRendererStreamingMode();
@@ -628,9 +627,8 @@ export class InteractiveShell {
         this.refreshControlBar();
         // Now sync renderer and control bar state
         this.syncRendererInput();
-        // CRITICAL: Force prompt render after banner - flushEvents should have done this,
-        // but explicitly ensure the prompt area is visible
-        this.renderer?.render();
+        // Ensure the prompt/control bar is rendered after the welcome banner
+        this.ensureReadlineReady();
         if (initialPrompt) {
             await this.enqueuePromptForProcessing(initialPrompt, 'programmatic');
             return;
@@ -638,7 +636,7 @@ export class InteractiveShell {
         this.showLaunchCommandPalette();
         // Ensure the terminal input is visible
         this.syncRendererInput();
-        this.renderer?.render();
+        this.ensureReadlineReady();
     }
     showLaunchCommandPalette() {
         // Disabled: Quick commands palette takes up too much space
@@ -706,10 +704,6 @@ export class InteractiveShell {
      */
     async runPromptJob(job) {
         try {
-            // Show thinking indicator instead of "processing queued prompt"
-            display.showThinking('Thinking…');
-            // Re-echo the prompt to make it clear what's being processed
-            this.renderer?.emitPrompt(job.text);
             await this.processInputBlock(job.text);
             job.resolve();
         }
@@ -805,6 +799,7 @@ export class InteractiveShell {
             '/output-style',
             // Mode toggles
             '/thinking',
+            '/autocontinue',
             // Discovery and plugins
             '/local', '/discover',
             '/plugins',
@@ -894,22 +889,25 @@ export class InteractiveShell {
             : '🛡️ High-impact actions now require your approval. (Ctrl+Shift+A to toggle; use /approvals ask to persist)';
         display.showSystemMessage(message);
     }
-    /**
-     * Expand the last tool result (Ctrl+O shortcut).
-     * Shows the full output from the most recent tool call.
-     */
-    expandLastToolResult() {
-        const result = this.uiAdapter.getLastToolResult();
-        if (!result) {
-            display.showInfo('No tool result to expand. Run a tool first, then press Ctrl+O.');
+    toggleAutoContinueMode() {
+        this.setAutoContinueMode(!this.autoContinueEnabled, 'shortcut');
+    }
+    setAutoContinueMode(enabled, source) {
+        const changed = this.autoContinueEnabled !== enabled;
+        this.autoContinueEnabled = enabled;
+        saveSessionPreferences({ autoContinue: this.autoContinueEnabled });
+        if (this.agent) {
+            this.agent.setAutoContinue(this.autoContinueEnabled);
+        }
+        this.refreshControlBar();
+        if (!changed && source === 'shortcut') {
             return;
         }
-        // Format the expanded output with tool name header
-        const header = `${theme.info('━━━')} ${theme.tool(result.toolName)} ${theme.ui.muted('output')} ${theme.info('━━━')}`;
-        const content = result.output.trim() || '(empty result)';
-        const footer = theme.ui.muted('━'.repeat(Math.min(60, header.length)));
-        // Display the expanded result
-        display.stream(`\n${header}\n${content}\n${footer}\n\n`);
+        const modeLabel = this.autoContinueEnabled ? 'enabled' : 'disabled';
+        const behavior = this.autoContinueEnabled
+            ? 'The model will be auto-prompted to continue when it expresses intent but does not use tools.'
+            : 'The model will not be auto-prompted to continue.';
+        display.showInfo(`Auto-continue ${modeLabel}. ${behavior} Toggle with Ctrl+Shift+C.`);
     }
     /**
      * Cycle through thinking modes (Tab shortcut).
@@ -1063,13 +1061,6 @@ export class InteractiveShell {
         }
         this.ctrlCHandledThisPress = false;
     }
-    /**
-     * Handle exit request (Ctrl+C with empty buffer in idle mode)
-     */
-    handleExit() {
-        display.showSystemMessage('\nGoodbye!\n');
-        this.shutdown();
-    }
     /**
      * Gracefully tear down the shell and exit
      */
@@ -1079,7 +1070,7 @@ export class InteractiveShell {
         }
         this.shuttingDown = true;
         // Stop any active spinner to prevent process hang
-        display.stopThinking(false);
+        display.stopThinking();
         this.stopStreamingHeartbeat('quit', { quiet: true });
         this.endAiRuntime();
         this.uiUpdates.dispose();
@@ -1091,6 +1082,7 @@ export class InteractiveShell {
         this.pendingCleanup = null;
         // Unregister plan approval bridge
         setPlanApprovalCallback(null);
+        setPlanUpdateCallback(null);
         // Dispose terminal input handler
         this.terminalInput.dispose();
         // Dispose unified UI adapter
@@ -1111,6 +1103,38 @@ export class InteractiveShell {
         });
         this.planApprovalBridgeRegistered = true;
     }
+    registerPlanUpdateBridge() {
+        if (this.planUpdateBridgeRegistered) {
+            return;
+        }
+        setPlanUpdateCallback((payload) => {
+            if (!payload || !payload.steps.length) {
+                this.planOverlay.clear();
+                this.applyPlanOverlay();
+                return;
+            }
+            this.applyPlanUpdate(payload.steps, payload.explanation);
+        });
+        this.planUpdateBridgeRegistered = true;
+    }
+    applyPlanUpdate(steps, explanation) {
+        this.planOverlay.setPlan(steps, explanation);
+        this.applyPlanOverlay();
+    }
+    applyPlanOverlay() {
+        const lines = this.planOverlay.render();
+        if (!this.renderer) {
+            if (this.planOverlay.hasPlan()) {
+                display.showSystemMessage(this.planOverlay.asText());
+            }
+            return;
+        }
+        if (!lines.length) {
+            this.renderer.clearPersistentPanel();
+            return;
+        }
+        this.renderer.setPersistentPanel(lines);
+    }
     /**
      * Update status bar message
      */
@@ -1639,7 +1663,9 @@ export class InteractiveShell {
     refreshControlBar() {
         this.terminalInput.setModeToggles({
             verificationEnabled: this.verificationEnabled,
+            autoContinueEnabled: this.autoContinueEnabled,
             verificationHotkey: 'ctrl+shift+v',
+            autoContinueHotkey: 'ctrl+shift+c',
             thinkingModeLabel: (this.thinkingMode || 'off').toString(),
             thinkingHotkey: 'tab',
             criticalApprovalMode: this.criticalApprovalMode,
@@ -1730,14 +1756,15 @@ export class InteractiveShell {
      */
     refreshStatusLine(forceRender = false) {
         const elapsedSeconds = this.getAiRuntimeSeconds();
+        const thinkingMs = display.isSpinnerActive() ? display.getThinkingElapsedMs() : null;
         const tokensUsed = this.latestTokenUsage.used;
         const tokenLimit = this.latestTokenUsage.limit ?? this.activeContextWindowTokens;
         this.terminalInput.setMetaStatus({
             elapsedSeconds,
             tokensUsed,
             tokenLimit,
-            thinkingMs: null,
-            thinkingHasContent: false,
+            thinkingMs,
+            thinkingHasContent: display.isSpinnerActive(),
         });
         // Keep model/provider visible in the controls bar
         this.terminalInput.setModelContext({
@@ -1913,16 +1940,12 @@ export class InteractiveShell {
         enterStreamingMode();
         // Set up scroll region for streaming content
         this.uiUpdates.setMode('streaming');
-        // Show activity status with animated spinner - use provided label or default
-        const activityLabel = label || 'Thinking';
-        this.renderer?.setActivity(activityLabel);
         this.streamingHeartbeatStart = Date.now();
         this.streamingContentSeen = false;
         this.streamingStatusText = null;
         this.streamingStatusLastUpdate = null;
-        this.streamingTokenCount = 0; // Reset token count for new prompt
-        // Show raw streaming output in real-time (Claude Code style)
-        this.streamingOutputSuppressed = false;
+        // Suppress raw streaming lines; show only a single summary/status + final response
+        this.streamingOutputSuppressed = true;
         const initialLabel = this.isMeaningfulStreamingSnippet(label)
             ? this.truncateStreamingLabel(label)
             : this.getStreamingFallbackLabel();
@@ -1966,8 +1989,6 @@ export class InteractiveShell {
         this.streamingStatusLastUpdate = null;
         this.streamingStatusText = null;
         this.streamingOutputSuppressed = false;
-        // Clear activity status when streaming ends
-        this.renderer?.setActivity(null);
         // Emit a streaming note for stop/quit so the status stays inside the stream
         if (reason === 'stop' || reason === 'quit') {
             const note = reason === 'quit' ? 'Session closed.' : 'Stream stopped.';
@@ -1984,15 +2005,11 @@ export class InteractiveShell {
     // Buffer for accumulating partial <thinking> tags during streaming
     thinkingTagBuffer = '';
     insideThinkingBlock = false;
-    streamingTokenCount = 0;
     handleStreamChunk(chunk, type = 'content') {
         if (!chunk) {
             return;
         }
         const isReasoning = type === 'reasoning';
-        // Approximate token count (roughly 4 chars per token)
-        this.streamingTokenCount += Math.ceil(chunk.length / 4);
-        this.renderer?.updateStreamingTokens(this.streamingTokenCount);
         // Keep pinned status updated for all streaming chunks
         this.updateStreamingStatusFromChunk(chunk);
         // Handle <thinking> tags as separate events in the queue
@@ -2001,32 +2018,37 @@ export class InteractiveShell {
         if (!processed.contentChunk && !processed.thinkingChunk) {
             return;
         }
-        // Don't emit thinking blocks during streaming - they will be rendered
-        // as a complete block by onAssistantMessage when the response is final.
-        // This prevents duplicate display.
+        // Emit thinking block as separate 'thought' event
+        if (processed.thinkingChunk) {
+            this.pushUiEvent('thought', `${theme.ui.muted('⏺')} ${theme.ui.muted('<thinking>')}${processed.thinkingChunk}${theme.ui.muted('</thinking>')}`);
+        }
         // Process regular content (skip if no content after extracting thinking)
         const contentChunk = processed.contentChunk;
         if (!contentChunk) {
             return;
         }
         // Suppress raw streaming output in scrollback; keep only status + final message.
-        // Reasoning tokens should also be suppressed and shown only in the indicator.
-        if (this.streamingOutputSuppressed) {
+        // Reasoning chunks bypass this so the thought process stays visible.
+        if (this.streamingOutputSuppressed && !isReasoning) {
             this.captureStreamingThought(contentChunk);
             this.streamingContentSeen = true;
-            // Update thinking indicator with a snippet of the content
-            const prefix = isReasoning ? '○ ' : '';
-            const snippet = contentChunk.replace(/\s+/g, ' ').trim().slice(0, 60);
-            if (snippet) {
-                display.updateThinking(prefix + snippet + (contentChunk.length > 60 ? '…' : ''));
-            }
             return;
         }
-        // Buffer all streaming content - rendered as complete block via onAssistantMessage
-        // This prevents fragmented display and ensures thinking tags are properly processed
+        if (!this.streamingFormatter) {
+            this.streamingFormatter = new StreamingResponseFormatter(output.columns ?? undefined);
+            this.pushUiEvent('streaming', this.streamingFormatter.header());
+        }
+        this.streamingFormatter.setMode(isReasoning ? 'reasoning' : 'content');
+        const formatted = isReasoning
+            ? this.streamingFormatter.formatReasoningChunk(contentChunk)
+            : this.streamingFormatter.formatChunk(contentChunk);
         this.captureStreamingThought(contentChunk);
-        // Activity: show what the model is doing (stable, informative)
-        this.renderer?.setActivity(type === 'reasoning' ? 'Reasoning' : 'Writing');
+        if (formatted) {
+            if (formatted.trim().length > 0) {
+                this.streamingContentSeen = true;
+            }
+            this.pushUiEvent('streaming', formatted);
+        }
     }
     /**
      * Process streaming content to extract <thinking> blocks as separate events.
@@ -2074,12 +2096,22 @@ export class InteractiveShell {
         }
         return { thinkingChunk: thinkingContent, contentChunk: remainingContent };
     }
-    finishStreamingFormatter(_note, options) {
-        // Flush any remaining buffered thoughts
+    finishStreamingFormatter(note, options) {
+        if (!this.streamingFormatter) {
+            return;
+        }
+        const closing = this.streamingFormatter.finish({
+            note,
+            mode: options?.mode ?? 'complete',
+        });
+        if (closing) {
+            this.pushUiEvent('streaming', closing);
+        }
         if (this.streamingThoughtBuffer.trim()) {
             this.ui.controller.recordAssistantThought(this.streamingThoughtBuffer.trim());
         }
         this.streamingThoughtBuffer = '';
+        this.streamingFormatter = null;
         if (options?.refreshPrompt ?? true) {
             this.requestPromptRefresh(true);
         }
@@ -2371,6 +2403,9 @@ export class InteractiveShell {
                 case '/approvals':
                     this.handleApprovalsCommand(input);
                     break;
+                case '/plan':
+                    this.handlePlanCommand(input);
+                    break;
                 case '/learn':
                     this.showLearningStatus(input);
                     break;
@@ -2418,6 +2453,9 @@ export class InteractiveShell {
                 case '/thinking':
                     this.handleThinkingCommand(input);
                     break;
+                case '/autocontinue':
+                    this.handleAutoContinueCommand(input);
+                    break;
                 case '/shortcuts':
                 case '/keys':
                     this.handleShortcutsCommand();
@@ -2521,9 +2559,6 @@ export class InteractiveShell {
                 case '/permissions':
                     this.handlePermissionsCommand();
                     break;
-                case '/update':
-                    await this.handleUpdateCommand(input);
-                    break;
                 case '/init':
                     this.handleInitCommand(input);
                     break;
@@ -2581,6 +2616,7 @@ export class InteractiveShell {
             theme.bold('  Mode Toggles'),
             `    ${theme.info('Shift+Tab')}      ${theme.ui.muted('Toggle edit mode (auto/ask)')}`,
             `    ${theme.info('Option+V')}       ${theme.ui.muted('Toggle verification')}`,
+            `    ${theme.info('Option+C')}       ${theme.ui.muted('Toggle auto-continue')}`,
             `    ${theme.info('Ctrl+Shift+A')}   ${theme.ui.muted('Toggle approvals for high-impact actions')}`,
             `    ${theme.info('Option+T')}       ${theme.ui.muted('Cycle thinking mode')}`,
             `    ${theme.info('Option+E')}       ${theme.ui.muted('Toggle edit permission mode')}`,
@@ -4294,6 +4330,20 @@ export class InteractiveShell {
         clearAutosaveSnapshot(this.profile);
         display.showInfo('Cleared autosave history.');
     }
+    handleAutoContinueCommand(input) {
+        const tokens = input.split(/\s+/).slice(1);
+        const value = tokens[0]?.toLowerCase();
+        if (!value) {
+            // Show current status
+            display.showInfo(`Auto-continue is ${this.autoContinueEnabled ? 'enabled' : 'disabled'}. Use /autocontinue on|off or Ctrl+Shift+C to toggle.`);
+            return;
+        }
+        if (value !== 'on' && value !== 'off') {
+            display.showWarning('Usage: /autocontinue on|off');
+            return;
+        }
+        this.setAutoContinueMode(value === 'on', 'command');
+    }
     // ==================== Erosolar-CLI Style Commands ====================
     async handleRewindCommand(_input) {
         const lines = [];
@@ -4525,6 +4575,7 @@ export class InteractiveShell {
         lines.push(`${theme.primary('Provider/Model')}: ${theme.info(`${this.providerLabel(this.sessionState.provider)} · ${this.sessionState.model}`)}`);
         lines.push(`${theme.primary('Workspace')}: ${theme.ui.muted(this.abbreviatePath(this.workingDir))}`);
         lines.push(`${theme.primary('Autosave')}: ${this.autosaveEnabled ? theme.success('on') : theme.ui.muted('off')}`);
+        lines.push(`${theme.primary('Auto-continue')}: ${this.autoContinueEnabled ? theme.success('on') : theme.ui.muted('off')}`);
         lines.push(`${theme.primary('Verification')}: ${this.verificationEnabled ? theme.success('on') : theme.ui.muted('off')}`);
         lines.push(`${theme.primary('Approvals')}: ${theme.ui.muted(this.describeEditGuardMode())}`);
         lines.push(`${theme.primary('Critical approvals')}: ${this.criticalApprovalMode === 'approval' ? theme.warning('ask') : theme.ui.muted('auto')}`);
@@ -4660,6 +4711,52 @@ export class InteractiveShell {
         }
         display.showWarning('Usage: /approvals [auto|ask|status]');
     }
+    handlePlanCommand(input) {
+        const action = input.split(/\s+/)[1]?.toLowerCase() || 'show';
+        const hasPlan = this.planOverlay.hasPlan();
+        const syncPanel = () => {
+            this.applyPlanOverlay();
+            this.syncRendererInput();
+        };
+        switch (action) {
+            case 'show':
+            case 'on':
+                if (!hasPlan) {
+                    display.showInfo('No active plan. The panel will populate when a planning tool updates the plan.');
+                    return;
+                }
+                this.planOverlay.show();
+                syncPanel();
+                display.showInfo('Plan panel pinned. Use /plan hide to minimize.');
+                return;
+            case 'hide':
+            case 'off':
+                if (!hasPlan) {
+                    display.showInfo('No active plan to hide.');
+                    return;
+                }
+                this.planOverlay.hide();
+                syncPanel();
+                display.showInfo('Plan panel hidden. Use /plan show to restore.');
+                return;
+            case 'clear':
+                if (!hasPlan) {
+                    display.showInfo('No active plan to clear.');
+                    return;
+                }
+                this.planOverlay.clear();
+                syncPanel();
+                display.showInfo('Plan cleared.');
+                return;
+            case 'status':
+            case 'view':
+            case 'text':
+                display.showSystemMessage(this.planOverlay.asText());
+                return;
+            default:
+                display.showWarning('Usage: /plan [show|hide|clear|status]');
+        }
+    }
     handlePermissionsCommand() {
         const lines = [];
         lines.push(theme.bold('Tool Permissions'));
@@ -4680,67 +4777,6 @@ export class InteractiveShell {
         lines.push(theme.ui.muted('Use /tools to manage which tool suites are enabled.'));
         display.showSystemMessage(lines.join('\n'));
     }
-    async handleUpdateCommand(input) {
-        const tokens = input.split(/\s+/).slice(1);
-        const subcommand = tokens[0]?.toLowerCase();
-        const prefs = loadSessionPreferences();
-        const currentPref = prefs.autoUpdate;
-        const prefLabel = currentPref === true ? 'always update' : currentPref === false ? 'always skip' : 'notify only';
-        // Show status or help
-        if (!subcommand || subcommand === 'status') {
-            const lines = [];
-            lines.push(theme.bold('Update Settings'));
-            lines.push('');
-            lines.push(`Current preference: ${theme.info(prefLabel)}`);
-            lines.push('');
-            lines.push(theme.secondary('Commands:'));
-            lines.push('  /update check   - Check for updates and install immediately');
-            lines.push('  /update auto    - Always auto-update in background');
-            lines.push('  /update skip    - Never auto-update (silent)');
-            lines.push('  /update notify  - Show notification only (default)');
-            display.showSystemMessage(lines.join('\n'));
-            return;
-        }
-        if (subcommand === 'check') {
-            // Force check and perform update immediately (non-interactive)
-            try {
-                const { checkForUpdates, performUpdate } = await import('../core/updateChecker.js');
-                const currentVersion = this.version || this.getPackageInfo().version || '1.7.458';
-                const updateInfo = await checkForUpdates(currentVersion);
-                if (!updateInfo) {
-                    display.showWarning('Unable to check for updates (network issue or timeout).');
-                    return;
-                }
-                if (!updateInfo.updateAvailable) {
-                    display.showSuccess(`You're on the latest version (v${updateInfo.current}).`);
-                    return;
-                }
-                // Show update info and perform update immediately (no interactive prompt)
-                display.showInfo(`Update available: v${updateInfo.current} → v${updateInfo.latest}`);
-                await performUpdate(updateInfo, (msg) => this.streamEventBlock(msg));
-            }
-            catch (error) {
-                display.showError(`Update check failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            return;
-        }
-        if (subcommand === 'auto' || subcommand === 'always') {
-            saveSessionPreferences({ autoUpdate: true });
-            display.showSuccess('Auto-update enabled. Updates will install automatically.');
-            return;
-        }
-        if (subcommand === 'skip' || subcommand === 'never' || subcommand === 'off') {
-            saveSessionPreferences({ autoUpdate: false });
-            display.showInfo('Auto-update disabled. Updates will be skipped silently.');
-            return;
-        }
-        if (subcommand === 'ask' || subcommand === 'prompt' || subcommand === 'reset' || subcommand === 'notify') {
-            saveSessionPreferences({ autoUpdate: null });
-            display.showInfo('Update preference reset. You will see a notification when updates are available.');
-            return;
-        }
-        display.showWarning('Usage: /update [check|auto|skip|notify|status]');
-    }
     handleInitCommand(input) {
         const tokens = input.split(/\s+/).slice(1);
         const confirm = tokens[0]?.toLowerCase() === 'confirm';
@@ -5765,7 +5801,6 @@ export class InteractiveShell {
         }
         this.isProcessing = true;
         this.uiUpdates.setMode('processing');
-        this.streamingTokenCount = 0; // Reset token counter for new request
         this.terminalInput.setStreaming(true);
         // Keep the persistent input/control bar active as we transition into streaming.
         this.syncRendererInput();
@@ -5780,7 +5815,6 @@ export class InteractiveShell {
         this.currentTaskType = classifyTaskType(request);
         this.currentToolCalls = [];
         this.clearToolUsageMeta();
-        this.renderer?.setActivity('Starting...');
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
         this.beginAiRuntime();
@@ -5836,6 +5870,8 @@ export class InteractiveShell {
                 clearActionHistory();
                 this.lastFailure = null;
             }
+            // Run post-hoc AI flow sanity check to catch "looks right but wrong" responses
+            this.analyzeAiFlowForRun(request, responseText, requestStartTime);
         }
         catch (error) {
             const handled = this.handleProviderError(error, () => this.processRequest(request));
@@ -5855,7 +5891,7 @@ export class InteractiveShell {
                 this.responseRendered = true;
             }
             this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
-            display.stopThinking(false);
+            display.stopThinking();
             this.uiUpdates.setMode('processing');
             this.stopStreamingHeartbeat('complete', { quiet: true });
             this.endAiRuntime();
@@ -5906,7 +5942,6 @@ export class InteractiveShell {
         this.clearToolUsageMeta();
         this.isProcessing = true;
         this.uiUpdates.setMode('processing');
-        this.streamingTokenCount = 0; // Reset token counter for new request
         this.terminalInput.setStreaming(true);
         if (this.suppressNextNetworkReset) {
             this.suppressNextNetworkReset = false;
@@ -6072,7 +6107,7 @@ What's the next action?`;
                     await new Promise(resolve => setTimeout(resolve, 500));
                 }
                 catch (error) {
-                    display.stopThinking(false);
+                    display.stopThinking();
                     // Handle context overflow specially - the agent should auto-recover
                     // but if it propagates here, we continue the loop
                     if (this.isContextOverflowError(error)) {
@@ -6314,6 +6349,43 @@ What's the next action?`;
         const parts = candidates.filter((part) => typeof part === 'string' && part.trim().length > 0);
         return parts.join('\n').trim();
     }
+    /**
+     * Post-run sanity check to catch hallucinated "looks right" answers.
+     * Compares the prompt/response against per-run tool usage and surfaces risks.
+     */
+    analyzeAiFlowForRun(prompt, responseText, startedAt) {
+        const toolHistory = this.runtimeSession.toolRuntime.getToolHistory?.();
+        if (!toolHistory) {
+            return;
+        }
+        const diffSnapshots = this.runtimeSession.toolRuntime.getDiffSnapshots?.() ?? [];
+        const recentDiffs = diffSnapshots
+            .filter((snapshot) => snapshot.timestamp >= startedAt)
+            .map(({ command, output }) => ({ command, output }));
+        const assessment = assessAiFlow({
+            prompt,
+            response: responseText,
+            startedAt,
+            toolHistory,
+            diffSnapshots: recentDiffs,
+        });
+        this.reportAiFlowAssessment(assessment);
+    }
+    reportAiFlowAssessment(assessment) {
+        if (!assessment || assessment.risks.length === 0) {
+            return;
+        }
+        display.showSystemMessage('⚠️ AI flow check: potential unverified completion detected.');
+        for (const risk of assessment.risks) {
+            const detail = risk.details ? ` — ${risk.details}` : '';
+            display.showWarning(`${risk.summary}${detail}`);
+        }
+        if (assessment.recommendations.length > 0) {
+            const uniqueRecommendations = Array.from(new Set(assessment.recommendations));
+            const advice = uniqueRecommendations.slice(0, 3).map((rec, idx) => `${idx + 1}. ${rec}`).join('\n');
+            display.showSystemMessage(`Follow-ups to de-risk this run:\n${advice}`);
+        }
+    }
     runAutoQualityChecks(trigger, assistantResponse, verificationContext) {
         if (!this.verificationEnabled) {
             return;
@@ -6694,41 +6766,21 @@ Return ONLY JSON array:
                 maxTokens: this.sessionState.maxTokens,
                 systemPrompt: this.buildSystemPrompt(),
                 reasoningEffort: this.sessionState.reasoningEffort,
+                autoContinue: this.autoContinueEnabled,
             };
             this.agent = this.runtimeSession.createAgent(selection, {
-                onRequestReceived: (requestPreview) => {
-                    const normalized = requestPreview?.trim();
-                    const activity = normalized ? `Working: ${normalized}` : 'Working';
-                    this.renderer?.setActivity(activity);
-                },
-                onBeforeFirstToolCall: (toolNames) => {
-                    const primaryTool = toolNames[0];
-                    if (primaryTool) {
-                        this.renderer?.setActivity(`Running ${primaryTool}`);
-                    }
-                    return undefined;
-                },
                 onStreamChunk: (chunk, type) => {
                     this.handleStreamChunk(chunk, type ?? 'content');
                 },
+                onStreamFallback: (info) => this.handleStreamingFallback(info),
                 onAssistantMessage: (content, metadata) => {
                     const enriched = this.buildDisplayMetadata(metadata);
                     const streamedVisible = metadata.wasStreamed && this.streamingContentSeen && !this.streamingOutputSuppressed;
                     let renderedFinal = false;
-                    // Update streaming token count from usage info (more accurate than chunk counting)
-                    if (metadata.usage) {
-                        const totalTokens = this.totalTokens(metadata.usage);
-                        if (totalTokens !== null && totalTokens > this.streamingTokenCount) {
-                            this.streamingTokenCount = totalTokens;
-                            this.renderer?.updateStreamingTokens(this.streamingTokenCount);
-                        }
-                    }
                     // Update spinner based on message type
                     if (metadata.isFinal) {
                         const parsed = this.splitThinkingResponse(content);
-                        // If we successfully parsed thinking, use the parsed response (may be empty)
-                        // Don't fall back to original content with raw <thinking> tags
-                        const finalContent = parsed ? parsed.response?.trim() : content;
+                        const finalContent = parsed?.response?.trim() || content;
                         const thoughtContent = parsed?.thinking?.trim() || null;
                         // Show the response if it wasn't already rendered during streaming
                         if (!streamedVisible) {
@@ -6831,6 +6883,12 @@ Return ONLY JSON array:
                     this.updateStatusMessage('Retrying with reduced context...');
                     this.syncRendererInput();
                 },
+                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.syncRendererInput();
+                },
                 onCancelled: () => {
                     // Update UI to show operation was cancelled
                     display.showWarning('Operation cancelled.');
@@ -6839,42 +6897,10 @@ Return ONLY JSON array:
                     this.updateStatusMessage(null);
                     this.terminalInput.setStreaming(false);
                 },
-                onToolExecution: (toolName, isStart, args) => {
-                    // Update activity status to show what tool is being executed
-                    if (isStart) {
-                        // Show more specific activity for long-running tools
-                        let activity = `Running ${toolName}`;
-                        if (toolName === 'execute_bash' && args?.['command']) {
-                            const cmd = String(args['command']).slice(0, 40);
-                            activity = `$ ${cmd}${String(args['command']).length > 40 ? '...' : ''}`;
-                        }
-                        else if (toolName === 'read_file' && args?.['file_path']) {
-                            const path = String(args['file_path']).split('/').pop() || args['file_path'];
-                            activity = `Reading ${path}`;
-                        }
-                        this.renderer?.setActivity(activity);
-                        // Estimate tokens for tool call (~50 tokens per call)
-                        this.streamingTokenCount += 50;
-                        this.renderer?.updateStreamingTokens(this.streamingTokenCount);
-                    }
-                    else {
-                        // Tool finished - estimate result tokens (~100 per result)
-                        this.streamingTokenCount += 100;
-                        this.renderer?.updateStreamingTokens(this.streamingTokenCount);
-                        // Reset to thinking state while model generates next response
-                        this.renderer?.setActivity('Thinking');
-                    }
-                },
                 onVerificationNeeded: (response, context) => {
                     this.lastAssistantResponse = response;
                     void this.runAutoQualityChecks('verification', response, context);
                 },
-                // Retry notification for transient errors
-                onRetrying: (attempt, maxAttempts, error) => {
-                    const shortError = error.message.slice(0, 100);
-                    display.showSystemMessage(`⚡ Retry ${attempt}/${maxAttempts}: ${shortError}${error.message.length > 100 ? '...' : ''}`);
-                    this.renderer?.setActivity(`Retrying (${attempt}/${maxAttempts})...`);
-                },
             });
             // Register global AI enhancer for explore tool - uses active model by default
             this.registerExploreAIEnhancer();
@@ -6969,30 +6995,20 @@ Return ONLY JSON array:
         return lines.join('\n').trim();
     }
     buildThinkingDirective() {
-        // Base requirement: ALWAYS think before acting (applies to all modes)
-        const baseRequirement = [
-            'CRITICAL: Before calling ANY tool, ALWAYS output a <thinking>...</thinking> block explaining:',
-            '1. What you understand the user is asking',
-            '2. Your approach/plan to solve it',
-            '3. Which tools you will use and why',
-            'This thinking block MUST appear before your first tool call in every response.',
-        ].join('\n');
         switch (this.thinkingMode) {
             case 'extended':
                 return [
-                    baseRequirement,
-                    '',
-                    'Extended thinking mode: Use detailed multi-step reasoning in your <thinking> block.',
-                    'Reference tool runs/files when relevant. Keep secrets redacted.',
-                    'After thinking, wrap your final answer in <response>...</response>.',
+                    'Extended thinking mode is enabled. Format every reply as:',
+                    '<thinking>',
+                    'Detailed multi-step reasoning (reference tool runs/files when relevant, keep secrets redacted, no code blocks unless citing filenames).',
+                    '</thinking>',
+                    '<response>',
+                    'Final answer with actionable next steps and any code/commands requested.',
+                    '</response>',
                 ].join('\n');
             case 'balanced':
             default:
-                return [
-                    baseRequirement,
-                    '',
-                    'Balanced mode: Keep thinking concise (2-4 sentences) but always present.',
-                ].join('\n');
+                return 'Balanced thinking mode: include a short <thinking>...</thinking> block before <response> when the reasoning is non-trivial; skip it for simple answers.';
         }
     }
     buildDisplayMetadata(metadata) {
@@ -7083,14 +7099,13 @@ Return ONLY JSON array:
             });
             cleanupOverlayActive = true;
             const triggerReason = trigger?.reason ?? 'Context optimization';
-            // Claude Code style: Show "Compacting conversation..." with animation
-            // The renderer handles the animated spinner display
-            if (this.renderer) {
-                this.renderer.showCompactingStatus('Compacting conversation… (esc to interrupt)');
-            }
-            else {
-                display.showSystemMessage(`✻ Compacting conversation… (esc to interrupt)`);
-            }
+            const limitLabel = resolvedWindowTokens
+                ? `of ${resolvedWindowTokens.toLocaleString('en-US')} tokens`
+                : 'of estimated context';
+            display.showSystemMessage([
+                `Context usage: ${resolvedTotalTokens.toLocaleString('en-US')} ${limitLabel}`,
+                `(${percentUsed}% full). Auto-compacting${triggerReason ? `: ${triggerReason}` : '...'}`,
+            ].join(' '));
             const result = await contextManager.intelligentCompact(history);
             let afterStats = contextManager.getStats(result.compacted);
             let appliedHistory = result.compacted;
@@ -7117,18 +7132,10 @@ Return ONLY JSON array:
                 }
             }
             if (!changed) {
-                // Hide compacting status before showing info message
-                if (this.renderer) {
-                    this.renderer.hideCompactingStatus();
-                }
                 display.showInfo('Context compaction completed but no changes were applied.');
                 return;
             }
             if (!this.hasMeaningfulCompaction(changed, bestTokenSavings, bestPercentSavings, trigger?.forced)) {
-                // Hide compacting status before showing info message
-                if (this.renderer) {
-                    this.renderer.hideCompactingStatus();
-                }
                 display.showInfo('Auto-compaction completed but did not meaningfully reduce context size. Keeping existing history.');
                 return;
             }
@@ -7144,18 +7151,15 @@ Return ONLY JSON array:
             this.updateContextUsage(newPercentUsed, CONTEXT_AUTOCOMPACT_PERCENT);
             this.lastContextWarningLevel = this.getContextWarningLevel(newPercentUsed);
             this.refreshStatusLine(true);
-            // Claude Code style: Show compaction complete with separator and ctrl+o hint
-            // Stop the compacting animation first
-            if (this.renderer) {
-                this.renderer.hideCompactingStatus();
-            }
-            // Show the Claude Code style separator: ══ Conversation compacted · ctrl+o for history ═
-            if (this.renderer) {
-                this.renderer.addCompactBlock('', 'Conversation compacted · ctrl+o for history');
-            }
-            else {
-                display.showSystemMessage('══ Conversation compacted · ctrl+o for history ═');
-            }
+            const primarySignal = result.analysis.signals[0]?.reason ?? triggerReason;
+            const savingsLabel = bestTokenSavings > 0
+                ? `(saved ~${bestTokenSavings.toLocaleString('en-US')} tokens, ~${bestPercentSavings.toFixed(1)}%)`
+                : '(no token savings)';
+            display.showSystemMessage([
+                `Context compacted: ${beforeStats.percentage}% → ${afterStats.percentage}%`,
+                savingsLabel,
+                primarySignal ? `Reason: ${primarySignal}.` : '',
+            ].filter(Boolean).join(' '));
             this.recordContextCompaction({
                 timestamp: Date.now(),
                 source: trigger?.source ?? 'auto',
@@ -7169,20 +7173,12 @@ Return ONLY JSON array:
             });
         }
         catch (error) {
-            // Hide compacting status animation on error
-            if (this.renderer) {
-                this.renderer.hideCompactingStatus();
-            }
             display.showError('Context compaction failed.', error);
         }
         finally {
             if (cleanupOverlayActive) {
                 this.statusTracker.clearOverride(cleanupStatusId);
             }
-            // Ensure compacting status is cleared
-            if (this.renderer) {
-                this.renderer.hideCompactingStatus();
-            }
             this.cleanupInProgress = false;
             this.contextCompactionInFlight = false;
         }
@@ -7484,6 +7480,28 @@ Return ONLY JSON array:
         const message = error instanceof Error ? error.message : String(error);
         display.showError(message);
     }
+    handleStreamingFallback(info) {
+        const promptBlock = detectPromptBlockError(info.error ?? info.message);
+        if (promptBlock) {
+            this.handlePromptBlock(promptBlock);
+            this.finishStreamingFormatter('Prompt blocked mid-stream', { mode: 'update' });
+            display.showSystemMessage('Retrying without streaming, but the provider will likely block again until you rephrase.');
+            this.startStreamingHeartbeat('Re-running without streaming');
+            this.requestPromptRefresh(true);
+            return;
+        }
+        const detailText = info.message?.trim() ?? '';
+        const detail = detailText ? ` ${detailText}` : '';
+        const reason = info.reason ? ` (${info.reason.replace(/-/g, ' ')})` : '';
+        const partialNote = info.partialResponse
+            ? ' Partial stream captured before failure; continuing from it without restarting.'
+            : '';
+        const baseMessage = 'Streaming interrupted, retrying without streaming';
+        display.showWarning(`${baseMessage}${reason}.${detail}${partialNote}`.trim());
+        this.finishStreamingFormatter('Stream interrupted - retrying without streaming', { mode: 'update' });
+        this.startStreamingHeartbeat('Fallback in progress');
+        this.requestPromptRefresh(true);
+    }
     handleProviderError(error, retryAction) {
         const promptBlock = detectPromptBlockError(error);
         if (promptBlock) {